/* This file is part of the TDE libraries
   Copyright (C) 2012 Timothy Pearson <kb9vqf@pearsoncomputing.net>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#include <tqdir.h>

#include <tqdbusmessage.h>

#include "tdeconfig.h"
#include "tdehardwaredevices.h"
#include "tdenetworkdevice.h"

#include "network-manager.h"
#include "network-manager_p.h"

// #define DEBUG_NETWORK_MANAGER_COMMUNICATIONS

#define PRINT_ERROR(x) printf("[TDE NM Backend ERROR] [%s:%d] %s\n", __FILE__, __LINE__, x.ascii());

#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
#define PRINT_WARNING(x) printf("[TDE NM Backend WARNING] [%s:%d] %s\n", __FILE__, __LINE__, x.ascii());
#else
#define PRINT_WARNING(x)
#endif

#define UPDATE_STRING_SETTING_IF_VALID(string, key, settingsMap)	\
    if (!string.isNull()) { settingsMap[key] = (TQT_DBusData::fromString(string)).getAsVariantData();	} \
		else { settingsMap.remove(key); }

#define NM_ASYNC_TIMEOUT_MS 1000
// Give the user 5 minutes to authenticate to DBUS before timing out
#define NM_ASYNC_SECRETS_INTERACTION_TIMEOUT_MS (5*60*1000)

// #define WAIT_FOR_OPERATION_BEFORE_RETURNING 1
#define USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS 1

TQ_UINT32 reverseIPV4ByteOrder(TQ_UINT32 address) {
	TQ_UINT32 ret;
	unsigned char valuearray[4];
	valuearray[0] = (address & 0xff000000) >> 24;
	valuearray[1] = (address & 0x00ff0000) >> 16;
	valuearray[2] = (address & 0x0000ff00) >> 8;
	valuearray[3] = (address & 0x000000ff) >> 0;
	ret = 0;
	ret = ret | (valuearray[0] << 0);
	ret = ret | (valuearray[1] << 8);
	ret = ret | (valuearray[2] << 16);
	ret = ret | (valuearray[3] << 24);
	return ret;
}

void printDBUSObjectStructure(TQT_DBusData object, int level=0, TQString mapKey=TQString::null) {
	int i;
	TQString levelIndent = "";
	for (i=0; i<level; i++) {
		levelIndent = levelIndent + " ";
	}
	TQCString signature = object.buildDBusSignature();

	if (object.type() == TQT_DBusData::String) {
		printf("%s%s\t%s%s'%s'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toString().ascii()); fflush(stdout);
	}
	else if (object.type() == TQT_DBusData::Bool) {
		printf("%s%s\t%s%s'%s'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", (object.toBool())?"true":"false"); fflush(stdout);
	}
	else if (object.type() == TQT_DBusData::Byte) {
		printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toByte()); fflush(stdout);
	}
	else if (object.type() == TQT_DBusData::Int16) {
		printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toInt16()); fflush(stdout);
	}
	else if (object.type() == TQT_DBusData::UInt16) {
		printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toUInt16()); fflush(stdout);
	}
	else if (object.type() == TQT_DBusData::Int32) {
		printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toInt32()); fflush(stdout);
	}
	else if (object.type() == TQT_DBusData::UInt32) {
		printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toUInt32()); fflush(stdout);
	}
	else if (object.type() == TQT_DBusData::Int64) {
		printf("%s%s\t%s%s'%lld'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toInt64()); fflush(stdout);
	}
	else if (object.type() == TQT_DBusData::UInt64) {
		printf("%s%s\t%s%s'%lld'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toUInt64()); fflush(stdout);
	}
	else {
		printf("%s%s\n", levelIndent.ascii(), signature.data()); fflush(stdout);
	}

	if (object.type() == TQT_DBusData::Map) {
		// HACK
		// NetworkManager currently uses string key maps exclusively as far as I can tell, so this should be adequate for the time being
		TQMap<TQString, TQT_DBusData> outerMap = object.toStringKeyMap().toTQMap();
		TQMap<TQString, TQT_DBusData>::const_iterator it;
        	for (it = outerMap.begin(); it != outerMap.end(); ++it) {
			printDBUSObjectStructure(*it, level+1, it.key());
		}
	}
	else if (object.type() == TQT_DBusData::List) {
		TQT_DBusDataValueList valueList = object.toTQValueList();
		TQT_DBusDataValueList::const_iterator it;
		for (it = valueList.begin(); it != valueList.end(); ++it) {
			printDBUSObjectStructure(*it, level+1);
		}
	}
	else if (object.type() == TQT_DBusData::Variant) {
		TQT_DBusVariant dataValueVariant = object.toVariant();
		TQT_DBusData dataValue = dataValueVariant.value;
		printDBUSObjectStructure(dataValue, level+1, mapKey);
	}
}

TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags nmGlobalStateToTDEGlobalState(TQ_UINT32 nmType) {
	TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags ret = TDENetworkGlobalManagerFlags::Unknown;

	if (nmType == NM_STATE_UNKNOWN) {
		ret |= TDENetworkGlobalManagerFlags::Unknown;
	}
	else if (nmType == NM_STATE_ASLEEP) {
		ret |= TDENetworkGlobalManagerFlags::Disconnected;
		ret |= TDENetworkGlobalManagerFlags::Sleeping;
	}
	else if (nmType == NM_STATE_DISCONNECTED) {
		ret |= TDENetworkGlobalManagerFlags::Disconnected;
	}
	else if (nmType == NM_STATE_DISCONNECTING) {
		ret |= TDENetworkGlobalManagerFlags::Connected;
		ret |= TDENetworkGlobalManagerFlags::DeactivatingLink;
	}
	else if (nmType == NM_STATE_CONNECTING) {
		ret |= TDENetworkGlobalManagerFlags::Disconnected;
		ret |= TDENetworkGlobalManagerFlags::EstablishingLink;
	}
	else if (nmType == NM_STATE_CONNECTED_LOCAL) {
		ret |= TDENetworkGlobalManagerFlags::Connected;
		ret |= TDENetworkGlobalManagerFlags::LinkLocalAccess;
	}
	else if (nmType == NM_STATE_CONNECTED_SITE) {
		ret |= TDENetworkGlobalManagerFlags::Connected;
		ret |= TDENetworkGlobalManagerFlags::SiteLocalAccess;
	}
	else if (nmType == NM_STATE_CONNECTED_GLOBAL) {
		ret |= TDENetworkGlobalManagerFlags::Connected;
		ret |= TDENetworkGlobalManagerFlags::GlobalAccess;
	}

	return ret;
}

TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags nmVPNStateToTDEGlobalState(TQ_UINT32 nmType) {
	TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags ret = TDENetworkGlobalManagerFlags::Unknown;

	if (nmType == NM_VPN_STATE_UNKNOWN) {
		ret |= TDENetworkGlobalManagerFlags::VPNUnknown;
	}
	else if (nmType == NM_VPN_STATE_PREPARE) {
		ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
		ret |= TDENetworkGlobalManagerFlags::VPNEstablishingLink;
	}
	else if (nmType == NM_VPN_STATE_NEED_AUTH) {
		ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
		ret |= TDENetworkGlobalManagerFlags::VPNNeedAuthorization;
	}
	else if (nmType == NM_VPN_STATE_CONNECT) {
		ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
		ret |= TDENetworkGlobalManagerFlags::VPNConfiguringProtocols;
	}
	else if (nmType == NM_VPN_STATE_IP_CONFIG_GET) {
		ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
		ret |= TDENetworkGlobalManagerFlags::VPNVerifyingProtocols;
	}
	else if (nmType == NM_VPN_STATE_ACTIVATED) {
		ret |= TDENetworkGlobalManagerFlags::VPNConnected;
	}
	else if (nmType == NM_VPN_STATE_FAILED) {
		ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
		ret |= TDENetworkGlobalManagerFlags::VPNFailed;
	}
	else if (nmType == NM_VPN_STATE_DISCONNECTED) {
		ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
	}

	return ret;
}

TDENetworkConnectionStatus::TDENetworkConnectionStatus nmDeviceStateToTDEDeviceState(TQ_UINT32 nmType) {
	TDENetworkConnectionStatus::TDENetworkConnectionStatus ret = TDENetworkConnectionStatus::None;

	if (nmType == NM_DEVICE_STATE_UNKNOWN) {
		ret |= TDENetworkConnectionStatus::Invalid;
	}
	else if (nmType == NM_DEVICE_STATE_UNMANAGED) {
		ret |= TDENetworkConnectionStatus::UnManaged;
	}
	else if (nmType == NM_DEVICE_STATE_UNAVAILABLE) {
		ret |= TDENetworkConnectionStatus::Disconnected;
		ret |= TDENetworkConnectionStatus::LinkUnavailable;
	}
	else if (nmType == NM_DEVICE_STATE_DISCONNECTED) {
		ret |= TDENetworkConnectionStatus::Disconnected;
	}
	else if (nmType == NM_DEVICE_STATE_PREPARE) {
		ret |= TDENetworkConnectionStatus::Disconnected;
		ret |= TDENetworkConnectionStatus::EstablishingLink;
	}
	else if (nmType == NM_DEVICE_STATE_CONFIG) {
		ret |= TDENetworkConnectionStatus::Disconnected;
		ret |= TDENetworkConnectionStatus::EstablishingLink;
	}
	else if (nmType == NM_DEVICE_STATE_NEED_AUTH) {
		ret |= TDENetworkConnectionStatus::Disconnected;
		ret |= TDENetworkConnectionStatus::NeedAuthorization;
	}
	else if (nmType == NM_DEVICE_STATE_IP_CONFIG) {
		ret |= TDENetworkConnectionStatus::Disconnected;
		ret |= TDENetworkConnectionStatus::ConfiguringProtocols;
	}
	else if (nmType == NM_DEVICE_STATE_IP_CHECK) {
		ret |= TDENetworkConnectionStatus::Disconnected;
		ret |= TDENetworkConnectionStatus::VerifyingProtocols;
	}
	else if (nmType == NM_DEVICE_STATE_SECONDARIES) {
		ret |= TDENetworkConnectionStatus::Disconnected;
		ret |= TDENetworkConnectionStatus::DependencyWait;
	}
	else if (nmType == NM_DEVICE_STATE_ACTIVATED) {
		ret |= TDENetworkConnectionStatus::Connected;
	}
	else if (nmType == NM_DEVICE_STATE_DEACTIVATING) {
		ret |= TDENetworkConnectionStatus::Connected;
		ret |= TDENetworkConnectionStatus::DeactivatingLink;
	}
	else if (nmType == NM_DEVICE_STATE_FAILED) {
		ret |= TDENetworkConnectionStatus::Disconnected;
		ret |= TDENetworkConnectionStatus::Failed;
	}

	return ret;
}

TDENetworkDeviceType::TDENetworkDeviceType TDENetworkConnectionManager_BackendNM::nmDeviceTypeToTDEDeviceType(TQ_UINT32 nmType) {
	TDENetworkDeviceType::TDENetworkDeviceType ret = TDENetworkDeviceType::Other;

	if (nmType == NM_DEVICE_TYPE_UNKNOWN) {
		ret = TDENetworkDeviceType::Other;
	}
	else if (nmType == NM_DEVICE_TYPE_ETHERNET) {
		ret = TDENetworkDeviceType::WiredEthernet;
	}
	else if (nmType == NM_DEVICE_TYPE_WIFI) {
		ret = TDENetworkDeviceType::WiFi;
	}
	else if (nmType == NM_DEVICE_TYPE_UNUSED1) {
	}
	else if (nmType == NM_DEVICE_TYPE_UNUSED2) {
	}
	else if (nmType == NM_DEVICE_TYPE_BT) {
		ret = TDENetworkDeviceType::Bluetooth;
	}
	else if (nmType == NM_DEVICE_TYPE_OLPC_MESH) {
		ret = TDENetworkDeviceType::OLPCMesh;
	}
	else if (nmType == NM_DEVICE_TYPE_WIMAX) {
		ret = TDENetworkDeviceType::WiMax;
	}
	else if (nmType == NM_DEVICE_TYPE_MODEM) {
		ret = TDENetworkDeviceType::Modem;
	}
	else if (nmType == NM_DEVICE_TYPE_INFINIBAND) {
		ret = TDENetworkDeviceType::Infiniband;
	}
	else if (nmType == NM_DEVICE_TYPE_BOND) {
		ret = TDENetworkDeviceType::Bond;
	}
	else if (nmType == NM_DEVICE_TYPE_VLAN) {
		ret = TDENetworkDeviceType::VLAN;
	}
	else if (nmType == NM_DEVICE_TYPE_ADSL) {
		ret = TDENetworkDeviceType::ADSL;
	}

	return ret;
}

TDENetworkConnectionType::TDENetworkConnectionType nmConnectionTypeToTDEConnectionType(TQString nm) {
	TDENetworkConnectionType::TDENetworkConnectionType ret = TDENetworkConnectionType::Other;

	if (nm.lower() == "802-3-ethernet") {
		ret = TDENetworkConnectionType::WiredEthernet;
	}
	else if (nm.lower() == "infiniband") {
		ret = TDENetworkConnectionType::Infiniband;
	}
	else if (nm.lower() == "802-11-wireless") {
		ret = TDENetworkConnectionType::WiFi;
	}
	else if (nm.lower() == "vpn") {
		ret = TDENetworkConnectionType::VPN;
	}
	else if (nm.lower() == "wimax") {
		ret = TDENetworkConnectionType::WiMax;
	}
	else if (nm.lower() == "vlan") {
		ret = TDENetworkConnectionType::VLAN;
	}
	else if (nm.lower() == "802-11-olpc-mesh") {
		ret = TDENetworkConnectionType::OLPCMesh;
	}
	else if (nm.lower() == "bluetooth") {
		ret = TDENetworkConnectionType::Bluetooth;
	}
	else if (nm.lower() == "cdma") {
		ret = TDENetworkConnectionType::Modem;
	}
	else if (nm.lower() == "gsm") {
		ret = TDENetworkConnectionType::Modem;
	}

	return ret;
}

TQString tdeConnectionTypeToNMConnectionType(TDENetworkConnectionType::TDENetworkConnectionType type, TDEModemConnectionType::TDEModemConnectionType modemType=TDEModemConnectionType::Other) {
	TQString ret;

	if (type == TDENetworkConnectionType::WiredEthernet) {
		ret = "802-3-ethernet";
	}
	else if (type == TDENetworkConnectionType::Infiniband) {
		ret = "infiniband";
	}
	else if (type == TDENetworkConnectionType::WiFi) {
		ret = "802-11-wireless";
	}
	else if (type == TDENetworkConnectionType::VPN) {
		ret = "vpn";
	}
	else if (type == TDENetworkConnectionType::WiMax) {
		ret = "wimax";
	}
	else if (type == TDENetworkConnectionType::VLAN) {
		ret = "vlan";
	}
	else if (type == TDENetworkConnectionType::OLPCMesh) {
		ret = "802-11-olpc-mesh";
	}
	else if (type == TDENetworkConnectionType::Bluetooth) {
		ret = "bluetooth";
	}
	else if (type == TDENetworkConnectionType::Modem) {
		if (modemType == TDEModemConnectionType::CDMA) {
			ret = "cdma";
		}
		else if (modemType == TDEModemConnectionType::GSM) {
			ret = "gsm";
		}
	}

	return ret;
}

TDENetworkIEEE8021xType::TDENetworkIEEE8021xType nmEAPTypeToTDEEAPType(TQString nm) {
	TDENetworkIEEE8021xType::TDENetworkIEEE8021xType ret = TDENetworkIEEE8021xType::None;

	if (nm.lower() == "") {
		ret = TDENetworkIEEE8021xType::None;
	}
	else if (nm.lower() == "leap") {
		ret = TDENetworkIEEE8021xType::LEAP;
	}
	else if (nm.lower() == "md5") {
		ret = TDENetworkIEEE8021xType::MD5;
	}
	else if (nm.lower() == "pap") {
		ret = TDENetworkIEEE8021xType::PAP;
	}
	else if (nm.lower() == "chap") {
		ret = TDENetworkIEEE8021xType::CHAP;
	}
	else if (nm.lower() == "mschap") {
		ret = TDENetworkIEEE8021xType::MSCHAP;
	}
	else if (nm.lower() == "mschapv2") {
		ret = TDENetworkIEEE8021xType::MSCHAPV2;
	}
	else if (nm.lower() == "fast") {
		ret = TDENetworkIEEE8021xType::Fast;
	}
	else if (nm.lower() == "psk") {
		ret = TDENetworkIEEE8021xType::PSK;
	}
	else if (nm.lower() == "pax") {
		ret = TDENetworkIEEE8021xType::PAX;
	}
	else if (nm.lower() == "sake") {
		ret = TDENetworkIEEE8021xType::SAKE;
	}
	else if (nm.lower() == "gpsk") {
		ret = TDENetworkIEEE8021xType::GPSK;
	}
	else if (nm.lower() == "tls") {
		ret = TDENetworkIEEE8021xType::TLS;
	}
	else if (nm.lower() == "peap") {
		ret = TDENetworkIEEE8021xType::PEAP;
	}
	else if (nm.lower() == "ttls") {
		ret = TDENetworkIEEE8021xType::TTLS;
	}
	else if (nm.lower() == "sim") {
		ret = TDENetworkIEEE8021xType::SIM;
	}
	else if (nm.lower() == "gtc") {
		ret = TDENetworkIEEE8021xType::GTC;
	}
	else if (nm.lower() == "otp") {
		ret = TDENetworkIEEE8021xType::OTP;
	}
	else {
		PRINT_ERROR(TQString("unknown EAP type %s requested in existing connection").arg(nm.lower()))
	}

	return ret;
}

TQString tdeEAPTypeToNMEAPType(TDENetworkIEEE8021xType::TDENetworkIEEE8021xType eaptype) {
	TQString ret = "";

	if (eaptype == TDENetworkIEEE8021xType::None) {
		ret = "";
	}
	else if (eaptype == TDENetworkIEEE8021xType::LEAP) {
		ret = "leap";
	}
	else if (eaptype == TDENetworkIEEE8021xType::MD5) {
		ret = "md5";
	}
	else if (eaptype == TDENetworkIEEE8021xType::PAP) {
		ret = "pap";
	}
	else if (eaptype == TDENetworkIEEE8021xType::CHAP) {
		ret = "chap";
	}
	else if (eaptype == TDENetworkIEEE8021xType::MSCHAP) {
		ret = "mschap";
	}
	else if (eaptype == TDENetworkIEEE8021xType::MSCHAPV2) {
		ret = "mschapv2";
	}
	else if (eaptype == TDENetworkIEEE8021xType::Fast) {
		ret = "fast";
	}
	else if (eaptype == TDENetworkIEEE8021xType::PSK) {
		ret = "psk";
	}
	else if (eaptype == TDENetworkIEEE8021xType::PAX) {
		ret = "pax";
	}
	else if (eaptype == TDENetworkIEEE8021xType::SAKE) {
		ret = "sake";
	}
	else if (eaptype == TDENetworkIEEE8021xType::GPSK) {
		ret = "gpsk";
	}
	else if (eaptype == TDENetworkIEEE8021xType::TLS) {
		ret = "tls";
	}
	else if (eaptype == TDENetworkIEEE8021xType::PEAP) {
		ret = "peap";
	}
	else if (eaptype == TDENetworkIEEE8021xType::TTLS) {
		ret = "ttls";
	}
	else if (eaptype == TDENetworkIEEE8021xType::SIM) {
		ret = "sim";
	}
	else if (eaptype == TDENetworkIEEE8021xType::GTC) {
		ret = "gtc";
	}
	else if (eaptype == TDENetworkIEEE8021xType::OTP) {
		ret = "otp";
	}
	else {
		PRINT_ERROR(TQString("unknown TDE EAP type %d requested in new or updated connection").arg(eaptype))
	}

	return ret;
}

TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags nmEAPFastFlagsToTDEEAPFastFlags(TQString nm) {
	TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags ret = TDENetworkIEEE8021xFastFlags::AllowUnauthenticated | TDENetworkIEEE8021xFastFlags::AllowAuthenticated;

	unsigned int nm_int = nm.toUInt();
	if (nm_int == NM_EAP_FAST_PROVISIONING_DISABLED) {
		ret = TDENetworkIEEE8021xFastFlags::None;
	}
	else if (nm_int == NM_EAP_FAST_PROVISIONING_UNAUTHONLY) {
		ret = TDENetworkIEEE8021xFastFlags::AllowUnauthenticated;
	}
	else if (nm_int == NM_EAP_FAST_PROVISIONING_AUTHONLY) {
		ret = TDENetworkIEEE8021xFastFlags::AllowAuthenticated;
	}
	else if (nm_int == NM_EAP_FAST_PROVISIONING_BOTH) {
		ret = TDENetworkIEEE8021xFastFlags::AllowUnauthenticated | TDENetworkIEEE8021xFastFlags::AllowAuthenticated;
	}
	else {
		PRINT_ERROR(TQString("unknown EAP fast flag %s requested in existing connection").arg(nm.lower()))
	}

	return ret;
}

TQString tdeEAPFastFlagsToNMEAPFastFlags(TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags eaptype) {
	TQString ret = "";

	if ((eaptype & TDENetworkIEEE8021xFastFlags::AllowUnauthenticated) && (eaptype & TDENetworkIEEE8021xFastFlags::AllowAuthenticated)) {
		ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_BOTH);
	}
	else if (eaptype & TDENetworkIEEE8021xFastFlags::AllowAuthenticated) {
		ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_AUTHONLY);
	}
	else if (eaptype & TDENetworkIEEE8021xFastFlags::AllowUnauthenticated) {
		ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_UNAUTHONLY);
	}
	else {
		ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_DISABLED);
	}

	return ret;
}

TDEWiFiMode::TDEWiFiMode nmWiFiModeToTDEWiFiMode(TQString nm) {
	TDEWiFiMode::TDEWiFiMode ret = TDEWiFiMode::Infrastructure;

	if (nm.lower() == "infrastructure") {
		ret = TDEWiFiMode::Infrastructure;
	}
	else if (nm.lower() == "adhoc") {
		ret = TDEWiFiMode::AdHoc;
	}

	return ret;
}

TQString tdeWiFiModeToNMWiFiMode(TDEWiFiMode::TDEWiFiMode mode) {
	TQString ret;

	if (mode == TDEWiFiMode::Infrastructure) {
		ret = "infrastructure";
	}
	else if (mode == TDEWiFiMode::AdHoc) {
		ret = "adhoc";
	}

	return ret;
}

TDEWiFiMode::TDEWiFiMode nmWiFiModeToTDEWiFiMode(TQ_UINT32 nm) {
	TDEWiFiMode::TDEWiFiMode ret = TDEWiFiMode::Infrastructure;

	if (nm == NM_802_11_MODE_INFRASTRUCTURE) {
		ret = TDEWiFiMode::Infrastructure;
	}
	else if (nm == NM_802_11_MODE_ADHOC) {
		ret = TDEWiFiMode::AdHoc;
	}

	return ret;
}

TDENetworkWiFiClientFlags::TDENetworkWiFiClientFlags tdeWiFiFlagsToNMWiFiFlags(TQ_UINT32 nm) {
	TDENetworkWiFiClientFlags::TDENetworkWiFiClientFlags ret = TDENetworkWiFiClientFlags::None;

	if (nm & NM_802_11_DEVICE_CAP_CIPHER_WEP40) {
		ret | TDENetworkWiFiClientFlags::CipherWEP40;
	}
	if (nm & NM_802_11_DEVICE_CAP_CIPHER_WEP104) {
		ret | TDENetworkWiFiClientFlags::CipherWEP104;
	}
	if (nm & NM_802_11_DEVICE_CAP_CIPHER_TKIP) {
		ret | TDENetworkWiFiClientFlags::CipherTKIP;
	}
	if (nm & NM_802_11_DEVICE_CAP_CIPHER_CCMP) {
		ret | TDENetworkWiFiClientFlags::CipherCCMP;
	}
	if (nm & NM_802_11_DEVICE_CAP_WPA) {
		ret | TDENetworkWiFiClientFlags::CipherWPA;
	}
	if (nm & NM_802_11_DEVICE_CAP_RSN) {
		ret | TDENetworkWiFiClientFlags::CipherRSN;
	}

	return ret;
}

TDEBluetoothConnectionType::TDEBluetoothConnectionType nmBluetoothModeToTDEBluetoothMode(TQString nm) {
	TDEBluetoothConnectionType::TDEBluetoothConnectionType ret = TDEBluetoothConnectionType::PAN;

	if (nm.lower() == "dun") {
		ret = TDEBluetoothConnectionType::DUN;
	}
	else if (nm.lower() == "panu") {
		ret = TDEBluetoothConnectionType::PAN;
	}

	return ret;
}

TQString tdeBluetoothModeToNMBluetoothMode(TDEBluetoothConnectionType::TDEBluetoothConnectionType type) {
	TQString ret;

	if (type == TDEBluetoothConnectionType::DUN) {
		ret = "dun";
	}
	else if (type == TDEBluetoothConnectionType::PAN) {
		ret = "panu";
	}

	return ret;
}

TDEGSMNetworkType::TDEGSMNetworkType nmGSMModeToTDEGSMMode(TQ_INT32 nm) {
	TDEGSMNetworkType::TDEGSMNetworkType ret = TDEGSMNetworkType::Any;

	if (nm == NM_GSM_3G_ONLY) {
		ret = TDEGSMNetworkType::Only3G;
	}
	else if (nm == NM_GSM_GPRS_EDGE_ONLY) {
		ret = TDEGSMNetworkType::GPRSEdge;
	}
	else if (nm == NM_GSM_PREFER_3G) {
		ret = TDEGSMNetworkType::Prefer3G;
	}
	else if (nm == NM_GSM_PREFER_2G) {
		ret = TDEGSMNetworkType::Prefer2G;
	}

	return ret;
}

TQ_INT32 tdeGSMModeToNMGSMMode(TDEGSMNetworkType::TDEGSMNetworkType type) {
	TQ_INT32 ret = -1;

	if (type == TDEGSMNetworkType::Only3G) {
		ret = NM_GSM_3G_ONLY;
	}
	else if (type == TDEGSMNetworkType::GPRSEdge) {
		ret = NM_GSM_GPRS_EDGE_ONLY;
	}
	else if (type == TDEGSMNetworkType::Prefer3G) {
		ret = NM_GSM_PREFER_3G;
	}
	else if (type == TDEGSMNetworkType::Prefer2G) {
		ret = NM_GSM_PREFER_2G;
	}

	return ret;
}

TDEWiFiFrequencyBand::TDEWiFiFrequencyBand nmWiFiFrequencyBandToTDEWiFiFrequencyBand(TQString nm) {
	TDEWiFiFrequencyBand::TDEWiFiFrequencyBand ret = TDEWiFiFrequencyBand::Other;

	if (nm.lower() == "") {
		ret = TDEWiFiFrequencyBand::None;
	}
	else if (nm.lower() == "bg") {
		ret = TDEWiFiFrequencyBand::Band2_4GHz;
	}
	else if (nm.lower() == "a") {
		ret = TDEWiFiFrequencyBand::Band5GHz;
	}

	return ret;
}

TQString tdeWiFiFrequencyBandToNMWiFiFrequencyBand(TDEWiFiFrequencyBand::TDEWiFiFrequencyBand mode) {
	TQString ret;

	if (mode == TDEWiFiFrequencyBand::None) {
		ret = TQString::null;
	}
	else if (mode == TDEWiFiFrequencyBand::Band2_4GHz) {
		ret = "bg";
	}
	else if (mode == TDEWiFiFrequencyBand::Band5GHz) {
		ret = "a";
	}

	return ret;
}

TDENetworkWiFiKeyType::TDENetworkWiFiKeyType nmWiFiKeyTypeToTDEWiFiKeyType(TQString nm) {
	TDENetworkWiFiKeyType::TDENetworkWiFiKeyType ret = TDENetworkWiFiKeyType::Other;

	if (nm.lower() == "none") {
		ret = TDENetworkWiFiKeyType::WEP;
	}
	else if (nm.lower() == "ieee8021x") {
		ret = TDENetworkWiFiKeyType::DynamicWEP;
	}
	else if (nm.lower() == "wpa-none") {
		ret = TDENetworkWiFiKeyType::WPAAdHoc;
	}
	else if (nm.lower() == "wpa-psk") {
		ret = TDENetworkWiFiKeyType::WPAInfrastructure;
	}
	else if (nm.lower() == "wpa-eap") {
		ret = TDENetworkWiFiKeyType::WPAEnterprise;
	}

	return ret;
}

TQString tdeWiFiKeyTypeToNMWiFiKeyType(TDENetworkWiFiKeyType::TDENetworkWiFiKeyType type) {
	TQString ret;

	if (type == TDENetworkWiFiKeyType::WEP) {
		return "none";
	}
	else if (type == TDENetworkWiFiKeyType::DynamicWEP) {
		return "ieee8021x";
	}
	else if (type == TDENetworkWiFiKeyType::WPAAdHoc) {
		return "wpa-none";
	}
	else if (type == TDENetworkWiFiKeyType::WPAInfrastructure) {
		return "wpa-psk";
	}
	else if (type == TDENetworkWiFiKeyType::WPAEnterprise) {
		return "wpa-eap";
	}

	return ret;
}

TDENetworkWiFiAuthType::TDENetworkWiFiAuthType nmWiFiAuthTypeToTDEWiFiAuthType(TQString nm) {
	TDENetworkWiFiAuthType::TDENetworkWiFiAuthType ret = TDENetworkWiFiAuthType::Other;

	if (nm.lower() == "open") {
		ret = TDENetworkWiFiAuthType::Open;
	}
	else if (nm.lower() == "shared") {
		ret = TDENetworkWiFiAuthType::Shared;
	}
	else if (nm.lower() == "leap") {
		ret = TDENetworkWiFiAuthType::LEAP;
	}

	return ret;
}

TQString tdeWiFiAuthTypeToNMWiFiAuthType(TDENetworkWiFiAuthType::TDENetworkWiFiAuthType type) {
	TQString ret;

	if (type == TDENetworkWiFiAuthType::Open) {
		return "open";
	}
	else if (type == TDENetworkWiFiAuthType::Shared) {
		return "shared";
	}
	else if (type == TDENetworkWiFiAuthType::LEAP) {
		return "leap";
	}

	return ret;
}

TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags nmWiFiWPAVersionToTDEWiFiWPAVersion(TQStringList nm) {
	TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags ret = TDENetworkWiFiWPAVersionFlags::None;

	if ((nm.contains("wpa") && nm.contains("rsn")) || (nm.count() < 1)) {
		ret |= TDENetworkWiFiWPAVersionFlags::Any;
	}
	else if (nm.contains("wpa")) {
		ret |= TDENetworkWiFiWPAVersionFlags::WPA;
	}
	else if (nm.contains("rsn")) {
		ret |= TDENetworkWiFiWPAVersionFlags::RSN;
	}

	return ret;
}

TQStringList tdeWiFiWPAVersionToNMWiFiWPAVersion(TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags type) {
	TQStringList ret;

	if (type & TDENetworkWiFiWPAVersionFlags::WPA) {
		ret.append("wpa");
	}
	if (type & TDENetworkWiFiWPAVersionFlags::RSN) {
		ret.append("rsn");
	}

	return ret;
}

TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher nmWiFiCipherToTDEWiFiCipher(TQString nm) {
	TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher ret = TDENetworkWiFiConnectionCipher::None;

	if (nm.lower() == "wep40") {
		ret = TDENetworkWiFiConnectionCipher::CipherWEP40;
	}
	else if (nm.lower() == "wep104") {
		ret = TDENetworkWiFiConnectionCipher::CipherWEP104;
	}
	else if (nm.lower() == "tkip") {
		ret = TDENetworkWiFiConnectionCipher::CipherTKIP;
	}
	else if (nm.lower() == "ccmp") {
		ret = TDENetworkWiFiConnectionCipher::CipherCCMP;
	}

	return ret;
}

TQString tdeWiFiCipherToNMWiFiCipher(TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher cipher) {
	TQString ret;

	if (cipher == TDENetworkWiFiConnectionCipher::CipherWEP40) {
		ret = "wep40";
	}
	else if (cipher == TDENetworkWiFiConnectionCipher::CipherWEP104) {
		ret = "wep104";
	}
	else if (cipher == TDENetworkWiFiConnectionCipher::CipherTKIP) {
		ret = "tkip";
	}
	else if (cipher == TDENetworkWiFiConnectionCipher::CipherCCMP) {
		ret = "ccmp";
	}

	return ret;
}

TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType nmSlaveTypeToTDESlaveType(TQString nm) {
	TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType ret = TDENetworkSlaveDeviceType::None;

	if (nm.lower() == "bond") {
		ret = TDENetworkSlaveDeviceType::Bond;
	}

	return ret;
}

TQString tdeSlaveTypeToNMSlaveType(TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType slavetype) {
	TQString ret;

	if (slavetype == TDENetworkSlaveDeviceType::Bond) {
		ret = "bond";
	}

	return ret;
}

TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags nmPasswordFlagsToTDEPasswordFlags(unsigned int nm) {
	TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags ret = TDENetworkPasswordHandlingFlags::None;

	if (nm & NM_PASSWORD_SECRET_AGENTOWNED) {
		ret |= TDENetworkPasswordHandlingFlags::ExternalStorage;
	}
	if (nm & NM_PASSWORD_SECRET_NOTSAVED) {
		ret |= TDENetworkPasswordHandlingFlags::NoSave;
	}
	if (nm & NM_PASSWORD_SECRET_NOTREQUIRED) {
		ret |= TDENetworkPasswordHandlingFlags::NoPrompt;
	}

	return ret;
}

unsigned int tdePasswordFlagsToNMPasswordFlags(TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags flags) {
	unsigned int ret = 0;

	if (flags & TDENetworkPasswordHandlingFlags::ExternalStorage) {
		ret |= NM_PASSWORD_SECRET_AGENTOWNED;
	}
	if (flags & TDENetworkPasswordHandlingFlags::NoSave) {
		ret |= NM_PASSWORD_SECRET_NOTSAVED;
	}
	if (flags & TDENetworkPasswordHandlingFlags::NoPrompt) {
		ret |= NM_PASSWORD_SECRET_NOTREQUIRED;
	}

	return ret;
}

TDENetworkVLANFlags::TDENetworkVLANFlags nmVLANFlagsToTDEVLANFlags(unsigned int nm) {
	TDENetworkVLANFlags::TDENetworkVLANFlags ret = TDENetworkVLANFlags::None;

	if (nm & NM_VLAN_REORDER_PACKET_HEADERS) {
		ret |= TDENetworkVLANFlags::ReorderPacketHeaders;
	}
	if (nm & NM_VLAN_USE_GVRP) {
		ret |= TDENetworkVLANFlags::UseGVRP;
	}
	if (nm & NM_VLAN_LOOSE_BINDING) {
		ret |= TDENetworkVLANFlags::LooseBinding;
	}

	return ret;
}

unsigned int tdeVLANFlagsToNMVLANFlags(TDENetworkVLANFlags::TDENetworkVLANFlags flags) {
	unsigned int ret = 0;

	if (flags & TDENetworkVLANFlags::ReorderPacketHeaders) {
		ret |= NM_VLAN_REORDER_PACKET_HEADERS;
	}
	if (flags & TDENetworkVLANFlags::UseGVRP) {
		ret |= NM_VLAN_USE_GVRP;
	}
	if (flags & TDENetworkVLANFlags::LooseBinding) {
		ret |= NM_VLAN_LOOSE_BINDING;
	}

	return ret;
}

TDENetworkParity::TDENetworkParity nmParityToTDEParity(char nm) {
	TDENetworkParity::TDENetworkParity ret = TDENetworkParity::None;

	if (nm == 'E') {
		ret = TDENetworkParity::Even;
	}
	else if (nm == 'o') {
		ret = TDENetworkParity::Odd;
	}

	return ret;
}

char tdeParityToNMParity(TDENetworkParity::TDENetworkParity parity) {
	char ret = 'n';

	if (parity == TDENetworkParity::Even) {
		ret = 'E';
	}
	else if (parity == TDENetworkParity::Odd) {
		ret = 'o';
	}

	return ret;
}

TDENetworkWepKeyType::TDENetworkWepKeyType nmWepKeyTypeToTDEWepKeyType(unsigned int nm, TQString key=TQString::null) {
	TDENetworkWepKeyType::TDENetworkWepKeyType ret = TDENetworkWepKeyType::Hexadecimal;

	if (nm == NM_WEP_TYPE_HEXADECIMAL) {
		if (key.isNull()) {
			ret = TDENetworkWepKeyType::Hexadecimal;
		}
		else {
			if ((key.length() == 10) || (key.length() == 26)) {
				ret = TDENetworkWepKeyType::Hexadecimal;
			}
			else {
				ret = TDENetworkWepKeyType::Ascii;
			}
		}
	}
	else if (nm == NM_WEP_TYPE_PASSPHRASE) {
		ret = TDENetworkWepKeyType::Passphrase;
	}

	return ret;
}

unsigned int tdeWepKeyTypeToNMWepKeyType(TDENetworkWepKeyType::TDENetworkWepKeyType type) {
	unsigned int ret = 0;

	if (type == TDENetworkWepKeyType::Hexadecimal) {
		ret = NM_WEP_TYPE_HEXADECIMAL;
	}
	else if (type == TDENetworkWepKeyType::Ascii) {
		ret = NM_WEP_TYPE_HEXADECIMAL;
	}
	else if (type == TDENetworkWepKeyType::Passphrase) {
		ret = NM_WEP_TYPE_PASSPHRASE;
	}

	return ret;
}

TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags nmCapabilityFlagsToTDECapabilityFlags(unsigned int nm) {
	TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags ret = TDENetworkDeviceCapabilityFlags::None;

	if (nm & NM_DEVICE_CAP_NM_SUPPORTED) {
		ret |= TDENetworkDeviceCapabilityFlags::Supported;
	}
	if (nm & NM_DEVICE_CAP_CARRIER_DETECT) {
		ret |= TDENetworkDeviceCapabilityFlags::CanDetectLink;
	}

	return ret;
}

unsigned int tdeCapabilityFlagsToNMCapabilityFlags(TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags flags) {
	unsigned int ret = 0;

	if (flags & TDENetworkDeviceCapabilityFlags::Supported) {
		ret |= NM_DEVICE_CAP_NM_SUPPORTED;
	}
	if (flags & TDENetworkDeviceCapabilityFlags::CanDetectLink) {
		ret |= NM_DEVICE_CAP_CARRIER_DETECT;
	}

	return ret;
}

TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags nmAPSecFlagsToTDEAPSecFlags(unsigned int genflags, unsigned int nm) {
	TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags ret = TDENetworkWiFiAPFlags::None;

	if (genflags & NM_ACCESS_POINT_CAP_PRIVACY) {
		ret |= TDENetworkWiFiAPFlags::PrivacySupport;
	}

	if (nm & NM_ACCESS_POINT_SEC_PAIR_WEP40) {
		ret |= TDENetworkWiFiAPFlags::PairWEP40;
	}
	if (nm & NM_ACCESS_POINT_SEC_PAIR_WEP104) {
		ret |= TDENetworkWiFiAPFlags::PairWEP104;
	}
	if (nm & NM_ACCESS_POINT_SEC_PAIR_TKIP) {
		ret |= TDENetworkWiFiAPFlags::PairTKIP;
	}
	if (nm & NM_ACCESS_POINT_SEC_PAIR_CCMP) {
		ret |= TDENetworkWiFiAPFlags::PairCCMP;
	}
	if (nm & NM_ACCESS_POINT_SEC_GROUP_WEP40) {
		ret |= TDENetworkWiFiAPFlags::GroupWEP40;
	}
	if (nm & NM_ACCESS_POINT_SEC_GROUP_WEP104) {
		ret |= TDENetworkWiFiAPFlags::GroupWEP104;
	}
	if (nm & NM_ACCESS_POINT_SEC_GROUP_TKIP) {
		ret |= TDENetworkWiFiAPFlags::GroupTKIP;
	}
	if (nm & NM_ACCESS_POINT_SEC_GROUP_CCMP) {
		ret |= TDENetworkWiFiAPFlags::GroupCCMP;
	}
	if (nm & NM_ACCESS_POINT_SEC_KEY_MGMT_PSK) {
		ret |= TDENetworkWiFiAPFlags::KeyManagementPSK;
	}
	if (nm & NM_ACCESS_POINT_SEC_KEY_MGMT_802_1X) {
		ret |= TDENetworkWiFiAPFlags::KeyManagement80211;
	}

	return ret;
}

unsigned int tdeAPSecFlagsToNMAPGenSecFlags(TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags flags) {
	unsigned int ret = 0;

	if (flags & TDENetworkWiFiAPFlags::PrivacySupport) {
		ret |= NM_ACCESS_POINT_CAP_PRIVACY;
	}

	return ret;
}

unsigned int tdeAPSecFlagsToNMAPSecFlags(TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags flags) {
	unsigned int ret = 0;

	if (flags & TDENetworkWiFiAPFlags::PairWEP40) {
		ret |= NM_ACCESS_POINT_SEC_PAIR_WEP40;
	}
	if (flags & TDENetworkWiFiAPFlags::PairWEP104) {
		ret |= NM_ACCESS_POINT_SEC_PAIR_WEP104;
	}
	if (flags & TDENetworkWiFiAPFlags::PairTKIP) {
		ret |= NM_ACCESS_POINT_SEC_PAIR_TKIP;
	}
	if (flags & TDENetworkWiFiAPFlags::PairCCMP) {
		ret |= NM_ACCESS_POINT_SEC_PAIR_CCMP;
	}
	if (flags & TDENetworkWiFiAPFlags::GroupWEP40) {
		ret |= NM_ACCESS_POINT_SEC_GROUP_WEP40;
	}
	if (flags & TDENetworkWiFiAPFlags::GroupWEP104) {
		ret |= NM_ACCESS_POINT_SEC_GROUP_WEP104;
	}
	if (flags & TDENetworkWiFiAPFlags::GroupTKIP) {
		ret |= NM_ACCESS_POINT_SEC_GROUP_TKIP;
	}
	if (flags & TDENetworkWiFiAPFlags::GroupCCMP) {
		ret |= NM_ACCESS_POINT_SEC_GROUP_CCMP;
	}
	if (flags & TDENetworkWiFiAPFlags::KeyManagementPSK) {
		ret |= NM_ACCESS_POINT_SEC_KEY_MGMT_PSK;
	}
	if (flags & TDENetworkWiFiAPFlags::KeyManagement80211) {
		ret |= NM_ACCESS_POINT_SEC_KEY_MGMT_802_1X;
	}

	return ret;
}

TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode nmIBTransportToTDEIBTransport(TQString nm) {
	TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode ret = TDENetworkInfinibandTransportMode::Other;

	if (nm.lower() == "datagram") {
		ret = TDENetworkInfinibandTransportMode::Datagram;
	}
	else if (nm.lower() == "connected") {
		ret = TDENetworkInfinibandTransportMode::Connected;
	}

	return ret;
}

TQString tdeIBTransportToNMIBTransport(TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode mode) {
	TQString ret;

	if (mode == TDENetworkInfinibandTransportMode::Datagram) {
		ret = "datagram";
	}
	else if (mode == TDENetworkInfinibandTransportMode::Connected) {
		ret = "connected";
	}

	return ret;
}

TQString TDENetworkConnectionManager_BackendNM::deviceInterfaceString(TQString deviceNode) {
	if (d->m_networkManagerProxy) {
		TQT_DBusObjectPathList devices;
		TQT_DBusError error;
		bool ret;
		ret = d->m_networkManagerProxy->GetDevices(devices, error);
		if (ret) {
			TQT_DBusObjectPathList::iterator it;
			for (it = devices.begin(); it != devices.end(); ++it) {
				DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, (*it));
				genericDevice.setConnection(TQT_DBusConnection::systemBus());
				TQString deviceInterface = genericDevice.getInterface(error);
				if (error.isValid()) {
					// Error!
					PRINT_ERROR((error.name() + ": " + error.message()))
					break;
				}
				else if (deviceInterface == deviceNode) {
					return (*it);
				}
			}
			return "";
		}
		else {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
			return "";
		}
	}
	else {
		return "";
	}
}

TQString tdeDeviceUUIDForGenericDevice(TQT_DBusObjectPath path) {
	TQT_DBusError error;
	DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, path);
	genericDevice.setConnection(TQT_DBusConnection::systemBus());
	TQString deviceInterface = genericDevice.getInterface(error);
	if (error.isValid()) {
		return TQString::null;
	}

	TDEHardwareDevices *hwdevices = TDEGlobal::hardwareDevices();
	if (!hwdevices) {
		return TQString::null;
	}

	TDEGenericHardwareList devices = hwdevices->listByDeviceClass(TDEGenericDeviceType::Network);
	for (TDEGenericHardwareList::iterator it = devices.begin(); it != devices.end(); ++it) {
		TDENetworkDevice* dev = dynamic_cast<TDENetworkDevice*>(*it);
		if (dev) {
			if (deviceInterface == dev->deviceNode()) {
				return dev->uniqueID();
			}
		}
	}

	return TQString::null;
}

TDENetworkConnectionManager_BackendNM_DBusSignalReceiver::TDENetworkConnectionManager_BackendNM_DBusSignalReceiver(TDENetworkConnectionManager_BackendNMPrivate* parent) : m_parent(parent) {
	//
}

TDENetworkConnectionManager_BackendNM_DBusSignalReceiver::~TDENetworkConnectionManager_BackendNM_DBusSignalReceiver() {
	//
}

void TDENetworkConnectionManager_BackendNM_DBusSignalReceiver::dbusSignal(const TQT_DBusMessage& message) {
	if (message.type() == TQT_DBusMessage::SignalMessage) {
		TQString interface = message.interface();
		TQString sender = message.sender();
		TQString member = message.member();
		TQString path = message.path();

// 		printf("[DEBUG] In dbusSignal: sender: %s, member: %s, interface: %s, path: %s, parent path: %s\n", sender.ascii(), member.ascii(), interface.ascii(), path.ascii(), m_parent->m_dbusDeviceString.ascii()); fflush(stdout);

		if (interface == NM_VPN_DBUS_CONNECTION_SERVICE) {
			if (member == "VpnStateChanged") {
				// Demarshal data
				TQ_UINT32 state = message[0].toUInt32();
				TQ_UINT32 reason = message[1].toUInt32();
				if (state == NM_VPN_STATE_FAILED) {
					m_parent->internalProcessVPNFailure(reason);
				}
			}
		}
		else if (interface == NM_DBUS_DEVICE_SERVICE) {
			if (path == m_parent->m_dbusDeviceString) {
				if (member == "StateChanged") {
					// Demarshal data
					TQ_UINT32 new_state = message[0].toUInt32();
					TQ_UINT32 old_state = message[1].toUInt32();
					TQ_UINT32 reason = message[2].toUInt32();
					m_parent->internalProcessDeviceStateChanged(new_state, old_state, reason);
				}
			}
		}
	}
}

TDENetworkConnectionManager_BackendNM::TDENetworkConnectionManager_BackendNM(TDENetworkDevice* networkDevice) : TDENetworkConnectionManager(networkDevice) {
	d = new TDENetworkConnectionManager_BackendNMPrivate(this);

	// Set up proxy interfaces
	d->m_networkManagerProxy = new DBus::NetworkManagerProxy(NM_DBUS_SERVICE, NM_DBUS_PATH);
	d->m_networkManagerProxy->setConnection(TQT_DBusConnection::systemBus());
	d->m_networkManagerSettings = new DBus::SettingsInterface(NM_DBUS_SERVICE, NM_DBUS_PATH_SETTINGS);
	d->m_networkManagerSettings->setConnection(TQT_DBusConnection::systemBus());
	d->m_vpnProxy = new DBus::VPNPluginProxy(NM_VPN_DBUS_PLUGIN_SERVICE, NM_VPN_DBUS_PLUGIN_PATH);
	d->m_vpnProxy->setConnection(TQT_DBusConnection::systemBus());

	d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
	if (d->m_dbusDeviceString != "") {
		d->m_networkDeviceProxy = new DBus::DeviceProxy(NM_DBUS_SERVICE, d->m_dbusDeviceString);
		d->m_networkDeviceProxy->setConnection(TQT_DBusConnection::systemBus());
		if (deviceType() == TDENetworkDeviceType::WiFi) {
			d->m_wiFiDeviceProxy = new DBus::WiFiDeviceProxy(NM_DBUS_SERVICE, d->m_dbusDeviceString);
			d->m_wiFiDeviceProxy->setConnection(TQT_DBusConnection::systemBus());
		}
	}

	// Connect global signals
	connect(d->m_networkManagerProxy, SIGNAL(StateChanged(TQ_UINT32)), d, SLOT(internalProcessGlobalStateChanged(TQ_UINT32)));

	// Connect VPN signals
	if (d->m_vpnProxy) {
		connect(d->m_vpnProxy, SIGNAL(StateChanged(TQ_UINT32)), d, SLOT(internalProcessVPNStateChanged(TQ_UINT32)));
		connect(d->m_vpnProxy, SIGNAL(LoginBanner(const TQString&)), d, SLOT(internalProcessVPNLoginBanner(const TQString&)));
		connect(d->m_vpnProxy, SIGNAL(Failure(TQ_UINT32)), d, SLOT(internalProcessVPNFailure(TQ_UINT32)));
	}

	// Connect local signals
	if (d->m_networkDeviceProxy) {
		connect(d->m_networkDeviceProxy, SIGNAL(StateChanged(TQ_UINT32, TQ_UINT32, TQ_UINT32)), d, SLOT(internalProcessDeviceStateChanged(TQ_UINT32, TQ_UINT32, TQ_UINT32)));
	}
	if (d->m_wiFiDeviceProxy) {
		connect(d->m_wiFiDeviceProxy, SIGNAL(AccessPointAdded(const TQT_DBusObjectPath&)), d, SLOT(internalProcessWiFiAccessPointAdded(const TQT_DBusObjectPath&)));
		connect(d->m_wiFiDeviceProxy, SIGNAL(AccessPointRemoved(const TQT_DBusObjectPath&)), d, SLOT(internalProcessWiFiAccessPointRemoved(const TQT_DBusObjectPath&)));
		connect(d->m_wiFiDeviceProxy, SIGNAL(PropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)), d, SLOT(internalProcessWiFiPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)));
	}

	// Create public lists
	m_connectionList = new TDENetworkConnectionList;
	m_hwNeighborList = new TDENetworkHWNeighborList;

	// Run site survey to populate neighbor list with initial data
	siteSurvey();
}

TDENetworkConnectionManager_BackendNM::~TDENetworkConnectionManager_BackendNM() {
	// Destroy public lists
	clearTDENetworkConnectionList();
	delete m_connectionList;
	clearTDENetworkHWNeighborList();
	delete m_hwNeighborList;

	// Tear down proxy interfaces
	if (d->m_networkManagerProxy) delete d->m_networkManagerProxy;
	if (d->m_networkManagerSettings) delete d->m_networkManagerSettings;
	if (d->m_networkDeviceProxy) delete d->m_networkDeviceProxy;

	delete d;
}

void TDENetworkConnectionManager_BackendNMPrivate::internalProcessGlobalStateChanged(TQ_UINT32 state) {
	m_parent->internalNetworkConnectionStateChanged(m_parent->backendStatus());
}

void TDENetworkConnectionManager_BackendNMPrivate::internalProcessVPNStateChanged(TQ_UINT32 state) {
	m_parent->internalNetworkConnectionStateChanged(m_parent->backendStatus());
}

void TDENetworkConnectionManager_BackendNMPrivate::internalProcessVPNLoginBanner(const TQString& banner) {
	m_parent->internalVpnEvent(TDENetworkVPNEventType::LoginBanner, banner);
}

void TDENetworkConnectionManager_BackendNMPrivate::internalProcessVPNFailure(TQ_UINT32 reason) {
	// FIXME
	// This should provide a plain-text interpretation of the NetworkManager-specific error code
	m_parent->internalVpnEvent(TDENetworkVPNEventType::Failure, TQString("VPN connection attempt failed!<br>NetworkManager returned error %1.").arg(reason));
}

void TDENetworkConnectionManager_BackendNMPrivate::internalProcessDeviceStateChanged(TQ_UINT32 newState, TQ_UINT32 oldState, TQ_UINT32 reason) {
	Q_UNUSED(oldState)

	if (m_prevDeviceState == newState) return;
	m_prevDeviceState = newState;

	if (newState == NM_DEVICE_STATE_FAILED) {
		TQString errorString;
		if (reason == NM_DEVICE_STATE_REASON_NONE) {
			errorString = TQString("Connection attempt failed!");
		}
		else if (reason == NM_DEVICE_STATE_REASON_UNKNOWN) {
			errorString = TQString("Connection attempt failed!<br>Unknown error detected.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_NOW_MANAGED) {
			errorString = TQString("Connection attempt failed!<br>Network device is now managed.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_NOW_UNMANAGED) {
			errorString = TQString("Connection attempt failed!<br>Network device is now unmanaged.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_CONFIG_FAILED) {
			errorString = TQString("Connection attempt failed!<br>Configuration failed.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE) {
			errorString = TQString("Connection attempt failed!<br>IP configuration unavailable.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_IP_CONFIG_EXPIRED) {
			errorString = TQString("Connection attempt failed!<br>IP configuration expired.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_NO_SECRETS) {
			errorString = i18n("Connection attempt failed!<br>Secrets were required to establish a connection, but no secrets were available.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT) {
			errorString = TQString("Connection attempt failed!<br>The supplicant was disconnected while attempting to establish a wireless connection.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_CONFIG_FAILED) {
			errorString = TQString("Connection attempt failed!<br>Supplicant configuration failed while attempting to establish a wireless connection.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED) {
			errorString = i18n("Connection attempt failed!<br>The supplicant failed while attempting to establish a wireless connection.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_TIMEOUT) {
			errorString = i18n("Connection attempt failed!<br>The supplicant timed out while attempting to establish a wireless connection.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_PPP_START_FAILED) {
			errorString = i18n("Connection attempt failed!<br>The PPP client failed to start.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_PPP_DISCONNECT) {
			errorString = i18n("Connection attempt failed!<br>The PPP client was disconnected.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_PPP_FAILED) {
			errorString = i18n("Connection attempt failed!<br>Unknown PPP failure.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_DHCP_START_FAILED) {
			errorString = i18n("Connection attempt failed!<br>The DHCP client failed to start.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_DHCP_ERROR) {
			errorString = i18n("Connection attempt failed!<br>The DHCP client encountered an error.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_DHCP_FAILED) {
			errorString = i18n("Connection attempt failed!<br>Uknown DHCP failure.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SHARED_START_FAILED) {
			errorString = i18n("Connection attempt failed!<br>The connection sharing service failed to start.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SHARED_FAILED) {
			errorString = i18n("Connection attempt failed!<br>The connection sharing service encountered an error.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_AUTOIP_START_FAILED) {
			errorString = i18n("Connection attempt failed!<br>The AutoIP service failed to start.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_AUTOIP_ERROR) {
			errorString = i18n("Connection attempt failed!<br>The AutoIP service encountered an error.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_AUTOIP_FAILED) {
			errorString = i18n("Connection attempt failed!<br>Unknown AutoIP failure.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_MODEM_BUSY) {
			errorString = i18n("Connection attempt failed!<br>Modem was busy.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_MODEM_NO_DIAL_TONE) {
			errorString = i18n("Connection attempt failed!<br>No dial tone.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER) {
			errorString = i18n("Connection attempt failed!<br>No carrier detected.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT) {
			errorString = i18n("Connection attempt failed!<br>Modem timed out while dialing.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_MODEM_DIAL_FAILED) {
			errorString = i18n("Connection attempt failed!<br>The modem failed to dial.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED) {
			errorString = i18n("Connection attempt failed!<br>Modem initialization failed.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_APN_FAILED) {
			errorString = i18n("Connection attempt failed!<br>GSM APN failure.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING) {
			errorString = i18n("Connection attempt failed!<br>GSM registration failed to search for networks.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED) {
			errorString = i18n("Connection attempt failed!<br>GSM registration attempt was rejected.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_TIMEOUT) {
			errorString = i18n("Connection attempt failed!<br>GSM registration attempt timed out.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_FAILED) {
			errorString = i18n("Connection attempt failed!<br>GSM registration attempt failed.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_PIN_CHECK_FAILED) {
			errorString = i18n("Connection attempt failed!<br>GSM PIN check failed.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_FIRMWARE_MISSING) {
			errorString = i18n("Connection attempt failed!<br>Network device firmware is missing.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_REMOVED) {
			errorString = i18n("Connection attempt failed!<br>Network device was removed.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SLEEPING) {
			errorString = i18n("Connection attempt failed!<br>Network device is sleeping.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_CONNECTION_REMOVED) {
			errorString = i18n("Connection attempt failed!<br>Connection was removed.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_USER_REQUESTED) {
			errorString = i18n("Connection attempt failed!<br>User requested device disconnection.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_CARRIER) {
			errorString = i18n("Connection attempt failed!<br>Carrier or link status changed.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED) {
			errorString = i18n("Connection attempt failed!<br>Device and/or connection already active.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE) {
			errorString = i18n("Connection attempt failed!<br>The supplicant is now available.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_MODEM_NOT_FOUND) {
			errorString = i18n("Connection attempt failed!<br>Requested modem was not found.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_BT_FAILED) {
			errorString = i18n("Connection attempt failed!<br>Bluetooth connection timeout.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED) {
			errorString = i18n("Connection attempt failed!<br>GSM SIM not inserted.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED) {
			errorString = i18n("Connection attempt failed!<br>GSM PIN required.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED) {
			errorString = i18n("Connection attempt failed!<br>GSM PUK required.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_WRONG) {
			errorString = i18n("Connection attempt failed!<br>GSM SIM incorrect.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_INFINIBAND_MODE) {
			errorString = i18n("Connection attempt failed!<br>Incorrect Infiniband mode.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED) {
			errorString = i18n("Connection attempt failed!<br>Dependency failure.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_BR2684_FAILED) {
			errorString = i18n("Connection attempt failed!<br>Unknown bridge failure.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_MODEM_MANAGER_UNAVAILABLE) {
			errorString = i18n("Connection attempt failed!<br>ModemManager not available.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SSID_NOT_FOUND) {
			errorString = i18n("Connection attempt failed!<br>SSID not found.");
		}
		else if (reason == NM_DEVICE_STATE_REASON_SECONDARY_CONNECTION_FAILED) {
			errorString = i18n("Connection attempt failed!<br>Secondary connection failure.");
		}
		else {
			// FIXME
			// This should provide a plain-text interpretation of the NetworkManager-specific error code
			errorString = TQString("Connection attempt failed!<br>NetworkManager returned error %1.").arg(reason);
		}
		m_parent->internalNetworkDeviceEvent(TDENetworkDeviceEventType::Failure, errorString);
	}

	m_parent->internalNetworkDeviceStateChanged(nmDeviceStateToTDEDeviceState(newState), m_parent->deviceNode());
}

void TDENetworkConnectionManager_BackendNMPrivate::internalProcessWiFiAccessPointAdded(const TQT_DBusObjectPath& dbuspath) {
	TDENetworkWiFiAPInfo* apInfo = m_parent->getAccessPointDetails(dbuspath);
	if (apInfo) {
		if (!m_accessPointProxyList.contains(dbuspath)) {
			// Set up monitoring object
			DBus::AccessPointProxy* apProxy = new DBus::AccessPointProxy(NM_DBUS_SERVICE, dbuspath);
			apProxy->setConnection(TQT_DBusConnection::systemBus());
			connect(apProxy, SIGNAL(PropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)), this, SLOT(internalProcessAPPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)));
			m_accessPointProxyList[dbuspath] = (apProxy);

			// Notify client applications
			m_parent->internalAccessPointStatusChanged(apInfo->BSSID, TDENetworkAPEventType::Discovered);
		}
		delete apInfo;
	}
}

void TDENetworkConnectionManager_BackendNMPrivate::internalProcessWiFiAccessPointRemoved(const TQT_DBusObjectPath& dbuspath) {
	TDENetworkWiFiAPInfo* apInfo = m_parent->getAccessPointDetails(dbuspath);
	if (apInfo) {
		// Notify client applications
		m_parent->internalAccessPointStatusChanged(apInfo->BSSID, TDENetworkAPEventType::Lost);
		delete apInfo;

		// Destroy related monitoring object
		DBus::AccessPointProxy* apProxy = m_accessPointProxyList[dbuspath];
		m_accessPointProxyList.remove(dbuspath);
		if (apProxy) {
			delete apProxy;
		}
	}
}

void TDENetworkConnectionManager_BackendNMPrivate::internalProcessWiFiPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>& props) {
	if (m_wiFiDeviceProxy) {
		if (props.contains("ActiveAccessPoint")) {
			TQT_DBusError error;
			TDENetworkWiFiAPInfo* apInfo = m_parent->getAccessPointDetails(m_wiFiDeviceProxy->getActiveAccessPoint(error));
			if (apInfo) {
				m_parent->internalAccessPointStatusChanged(apInfo->BSSID, TDENetworkAPEventType::AccessPointChanged);
			}
		}
		else if (props.contains("Bitrate")) {
			m_parent->internalNetworkDeviceEvent(TDENetworkDeviceEventType::BitRateChanged, TQString::null);
		}
	}
}

void TDENetworkConnectionManager_BackendNMPrivate::internalProcessAPPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>& props) {
	const DBus::AccessPointProxy* apProxy = dynamic_cast<const DBus::AccessPointProxy*>(sender());
	if (apProxy) {
		TQT_DBusError error;
		TDEMACAddress BSSID;
		BSSID.fromString(apProxy->getHwAddress(error));
		if (props.contains("Strength")) {
			m_parent->internalAccessPointStatusChanged(BSSID, TDENetworkAPEventType::SignalStrengthChanged);
		}
	}
}

TDENetworkDeviceType::TDENetworkDeviceType TDENetworkConnectionManager_BackendNM::deviceType() {
	if (!m_networkDevice) {
		return TDENetworkDeviceType::BackendOnly;
	}
	else {
		if (d->m_dbusDeviceString != "") {
			// Query NM for the device type
			TQT_DBusError error;
			d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
			DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, d->m_dbusDeviceString);
			genericDevice.setConnection(TQT_DBusConnection::systemBus());
			TDENetworkDeviceType::TDENetworkDeviceType ret = nmDeviceTypeToTDEDeviceType(genericDevice.getDeviceType(error));
			if (error.isValid()) {
				// Error!
				PRINT_ERROR((error.name() + ": " + error.message()))
				return TDENetworkDeviceType::Other;
			}
			else {
				return ret;
			}
		}
		else {
			// Error!
			PRINT_ERROR(TQString("Invalid DBUS device string '%1'").arg(d->m_dbusDeviceString))
			return TDENetworkDeviceType::Other;
		}
	}
}

TDENetworkConnectionType::TDENetworkConnectionType TDENetworkConnectionManager_BackendNM::connectionType(TQString dbusPath) {
	TDENetworkConnectionType::TDENetworkConnectionType connType = TDENetworkConnectionType::Other;
	TQ_UINT32 ret;
	TQT_DBusError error;

#ifndef USE_ASYNC_DBUS_CALLS
	// Obtain connection settings from the path specified
	DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
	connectionSettings.setConnection(TQT_DBusConnection::systemBus());
	TQT_DBusTQStringDataMap connectionSettingsMap;
	ret = connectionSettings.GetSettings(connectionSettingsMap, error);
	if (ret && error.isValid()) {
		ret = 0;
		PRINT_ERROR((error.name() + ": " + error.message()))
	}
	if (ret) {
#else // USE_ASYNC_DBUS_CALLS
	// Obtain connection settings from the path specified
	DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
	connectionSettings.setConnection(TQT_DBusConnection::systemBus());
	connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
	int asyncCallID;
	ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
	if (ret && error.isValid()) {
		ret = 0;
		PRINT_ERROR((error.name() + ": " + error.message()))
	}
	if (ret) {
		// Wait for the asynchronous call to return...
		d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
		TQTimer nmCallTimeoutTimer;
		nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
		while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
			tqApp->processEvents();
			if (!nmCallTimeoutTimer.isActive()) {
				PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
				break;
			}
		}
		TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
		if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
			PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
			d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
		}
		d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
		if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
			d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
		}
#endif // USE_ASYNC_DBUS_CALLS

		// Parse settings to find connection type
		TQT_DBusTQStringDataMap::const_iterator it2;
		for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
			TQString outerKeyValue = it2.key();
			TQT_DBusData dataValue = it2.data();

			TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
			TQT_DBusTQStringDataMap::const_iterator it3;
			for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
				TQString keyValue = it3.key();
				TQT_DBusData dataValue = it3.data();
				if (dataValue.type() == TQT_DBusData::Variant) {
					TQT_DBusVariant dataValueVariant = dataValue.toVariant();
					TQT_DBusData dataValue2 = dataValueVariant.value;
					if (dataValue2.type() != TQT_DBusData::Variant) {
						if (outerKeyValue.lower() == "connection") {
							if (keyValue.lower() == "type") {
								connType = nmConnectionTypeToTDEConnectionType(dataValue2.toString());
							}
						}
					}
				}
			}
		}
	}

	return connType;
}

TQString TDENetworkConnectionManager_BackendNM::backendName() {
	return i18n("NetworkManager");
}

TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags TDENetworkConnectionManager_BackendNM::backendStatus() {
	if (d->m_networkManagerProxy) {
		TQ_UINT32 ret;
		TQT_DBusError error;
		ret = d->m_networkManagerProxy->getState(error);
		if (error.isValid()) {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
			return TDENetworkGlobalManagerFlags::BackendUnavailable;
		}
		else {
			TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags globalFlags = nmGlobalStateToTDEGlobalState(ret);
			TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags vpnFlags = TDENetworkGlobalManagerFlags::Unknown;
			if (d->m_vpnProxy) {
				ret = d->m_vpnProxy->getState(error);
				if (error.isValid()) {
					// Error!
					bool print_error = true;
					if (error.name() == "org.freedesktop.DBus.Error.ServiceUnknown") {
						if (d->vpn_service_error_notified) {
							print_error = false;
						}
						else {
							d->vpn_service_error_notified = true;
						}
					}
					if (print_error) {
						PRINT_ERROR(TQString("Attempting to access the network-manager VPN service returned: %1").arg(error.name() + ": " + error.message()))
					}
					vpnFlags = TDENetworkGlobalManagerFlags::VPNUnknown;
				}
				else {
					vpnFlags = nmVPNStateToTDEGlobalState(ret);
				}
			}
			return globalFlags | vpnFlags;
		}
	}
	else {
		return TDENetworkGlobalManagerFlags::BackendUnavailable;
	}
}

TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceInformation() {
	TQT_DBusError error;
	TDENetworkDeviceInformation ret;

	if (d->m_networkDeviceProxy) {
		ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
		ret.UUID = d->m_networkDeviceProxy->getUdi(error);
		ret.backendDriver = d->m_networkDeviceProxy->getDriver(error);
		ret.backendDriverVersion = d->m_networkDeviceProxy->getDriverVersion(error);
		ret.firmwareVersion = d->m_networkDeviceProxy->getFirmwareVersion(error);
		ret.capabilityFlags = nmCapabilityFlagsToTDECapabilityFlags(d->m_networkDeviceProxy->getCapabilities(error));
		// ipConfiguration is not filled in, as the TDE HW library provides complementary functionality and is more reliable/easier to use and maintain
		ret.managed = d->m_networkDeviceProxy->getManaged(error);
		ret.autoConnect = d->m_networkDeviceProxy->getAutoconnect(error);
		ret.firmwareMissing = d->m_networkDeviceProxy->getFirmwareMissing(error);
		ret.deviceType = nmDeviceTypeToTDEDeviceType(d->m_networkDeviceProxy->getDeviceType(error));
		if (error.isValid()) {
			// Error!
			bool print_error = true;
			if (error.name() == "org.freedesktop.DBus.Error.AccessDenied") {
				if (error.message().contains("org.freedesktop.NetworkManager.Device")) {
					// Unable to determine if device allows autoconnect
					// Assume true!
					ret.autoConnect = true;
					if (d->device_autoconnect_error_notified) {
						print_error = false;
					}
					else {
						d->device_autoconnect_error_notified = true;
					}
				}
			}
			if (print_error) {
				PRINT_ERROR((error.name() + ": " + error.message()))
			}

			// Reset error object to avoid spurious error messages on the command line
			error = TQT_DBusError();
		}

		// Populate wiFiInfo
		if ((deviceType() == TDENetworkDeviceType::WiFi) && (d->m_wiFiDeviceProxy)) {
			ret.wiFiInfo.valid = true;
			ret.wiFiInfo.hwAddress.fromString(d->m_wiFiDeviceProxy->getHwAddress(error));
			ret.wiFiInfo.permanentHWAddress.fromString(d->m_wiFiDeviceProxy->getPermHwAddress(error));
			ret.wiFiInfo.operatingMode = nmWiFiModeToTDEWiFiMode(d->m_wiFiDeviceProxy->getMode(error));
			ret.wiFiInfo.bitrate = d->m_wiFiDeviceProxy->getBitrate(error);
			TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(d->m_wiFiDeviceProxy->getActiveAccessPoint(error));
			if (error.isValid()) {
				PRINT_ERROR((error.name() + ": " + error.message()))

				// Reset error object to avoid spurious error messages on the command line
				error = TQT_DBusError();
			}
			if (apInfo) {
				ret.wiFiInfo.activeAccessPointBSSID = apInfo->BSSID;
				TDENetworkWiFiAPInfo* neighborListAPInfo = findAccessPointByBSSID(ret.wiFiInfo.activeAccessPointBSSID);
				if (neighborListAPInfo) {
					*neighborListAPInfo = *apInfo;
				}
				delete apInfo;
			}
			else {
				ret.wiFiInfo.activeAccessPointBSSID = TDEMACAddress();
			}
			ret.wiFiInfo.wirelessFlags = tdeWiFiFlagsToNMWiFiFlags(d->m_wiFiDeviceProxy->getWirelessCapabilities(error));
		}
		else {
			ret.wiFiInfo.valid = false;
		}

		// Get active connection UUID
		TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
		if (!error.isValid()) {
			DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
			activeConnection.setConnection(TQT_DBusConnection::systemBus());
			ret.activeConnectionUUID = activeConnection.getUuid(error);
			if (error.isValid()) {
				ret.activeConnectionUUID = TQString::null;
			}
		}

		ret.valid = true;
	}

	return ret;
}

TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceStatus() {
	TQT_DBusError error;
	TDENetworkDeviceInformation ret;

	if (d->m_networkDeviceProxy) {
		ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
		ret.UUID = d->m_networkDeviceProxy->getUdi(error);

		// Get active connection UUID
		TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
		if (!error.isValid()) {
			DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
			activeConnection.setConnection(TQT_DBusConnection::systemBus());
			ret.activeConnectionUUID = activeConnection.getUuid(error);
			if (error.isValid()) {
				ret.activeConnectionUUID = TQString::null;
			}
		}

		ret.valid = true;
	}

	return ret;
}

void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncReply(int asyncCallId, const TQT_DBusDataMap<TQString>& settings) {
	nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
	nmConnectionSettingsAsyncSettingsResponse[asyncCallId] = settings;
}

void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncReply(int asyncCallId) {
	nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
}

void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncReply(int asyncCallId, const TQT_DBusObjectPath& path) {
	nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
	nmAddConnectionAsyncResponse[asyncCallId] = path;
}

void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncError(int asyncCallId, const TQT_DBusError error) {
	nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallId] = error;
}

void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncError(int asyncCallId, const TQT_DBusError error) {
	nmConnectionSettingsUpdateAsyncSettingsErrorResponse[asyncCallId] = error;
}

void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncError(int asyncCallId, const TQT_DBusError error) {
	nmAddConnectionAsyncErrorResponse[asyncCallId] = error;
}

void TDENetworkConnectionManager_BackendNM::loadConnectionInformation() {
	if (d->nonReentrantCallActive) return;

	d->nonReentrantCallActive = true;

	TDEMACAddress deviceMACAddress;
	deviceMACAddress.fromString(this->deviceMACAddress());

	if (d->m_networkManagerSettings) {
		clearTDENetworkConnectionList();
		TQT_DBusObjectPathList connections;
		TQT_DBusError error;
		bool ret;
		int state;
		ret = d->m_networkManagerSettings->ListConnections(connections, error);
		if (ret) {
			TQT_DBusObjectPathList::iterator it;
			for (it = connections.begin(); it != connections.end(); ++it) {
				TDENetworkConnection* connection;
				TDEWiredEthernetConnection* ethernetConnection = NULL;
				TDEWiredInfinibandConnection* infinibandConnection = NULL;
				TDEWiFiConnection* wiFiConnection = NULL;
				TDEVPNConnection* vpnConnection = NULL;
				TDEWiMaxConnection* wiMaxConnection = NULL;
				TDEVLANConnection* vlanConnection = NULL;
				TDEOLPCMeshConnection* olpcMeshConnection = NULL;
				TDEBluetoothConnection* bluetoothConnection = NULL;
				TDEModemConnection* modemConnection = NULL;
				TDENetworkConnectionType::TDENetworkConnectionType connType = connectionType((*it));
				if (connType == TDENetworkConnectionType::WiredEthernet) {
					connection = ethernetConnection = new TDEWiredEthernetConnection;
				}
				else if (connType == TDENetworkConnectionType::Infiniband) {
					connection = infinibandConnection = new TDEWiredInfinibandConnection;
				}
				else if (connType == TDENetworkConnectionType::WiFi) {
					connection = wiFiConnection = new TDEWiFiConnection;
				}
				else if (connType == TDENetworkConnectionType::VPN) {
					connection = vpnConnection = new TDEVPNConnection;
				}
				else if (connType == TDENetworkConnectionType::WiMax) {
					connection = wiMaxConnection = new TDEWiMaxConnection;
				}
				else if (connType == TDENetworkConnectionType::VLAN) {
					connection = vlanConnection = new TDEVLANConnection;
				}
				else if (connType == TDENetworkConnectionType::OLPCMesh) {
					connection = olpcMeshConnection = new TDEOLPCMeshConnection;
				}
				else if (connType == TDENetworkConnectionType::Bluetooth) {
					connection = bluetoothConnection = new TDEBluetoothConnection;
				}
				else if (connType == TDENetworkConnectionType::Modem) {
					connection = modemConnection = new TDEModemConnection;
				}
				else {
					connection = new TDENetworkConnection;
				}
				// Set up defaults
				connection->ipConfig.connectionFlags =	TDENetworkIPConfigurationFlags::IPV4DHCPIP			| \
									TDENetworkIPConfigurationFlags::IPV4DHCPDNS			| \
									TDENetworkIPConfigurationFlags::IPV4DHCPRoutes			| \
									TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute	| \
									TDENetworkIPConfigurationFlags::IPV6DHCPIP			| \
									TDENetworkIPConfigurationFlags::IPV6DHCPDNS			| \
									TDENetworkIPConfigurationFlags::IPV6DHCPRoutes			| \
									TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
				// Set up NM-specific defaults
				// Keep in sync with latest NM default settings!
				// NM 0.9 setting descriptions and default values are available at:
				// http://projects.gnome.org/NetworkManager/developers/api/09/ref-settings.html
				connection->autoConnect = true;

				if (wiFiConnection) {
					wiFiConnection->securitySettings.authType = TDENetworkWiFiAuthType::Open;
				}

#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
				printf("[network-manager comm debug] %s\n", (*it).data()); fflush(stdout);
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS

#ifndef USE_ASYNC_DBUS_CALLS
				// Obtain connection settings from the path specified
				DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
				connectionSettings.setConnection(TQT_DBusConnection::systemBus());
				TQT_DBusTQStringDataMap connectionSettingsMap;
				ret = connectionSettings.GetSettings(connectionSettingsMap, error);
				if (ret && error.isValid()) {
					ret = 0;
					PRINT_ERROR((error.name() + ": " + error.message()))
				}
				if (ret) {
#else // USE_ASYNC_DBUS_CALLS
				// Obtain connection settings from the path specified
				DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
				connectionSettings.setConnection(TQT_DBusConnection::systemBus());
				connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
				connect(&connectionSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processConnectionSettingsAsyncError(int, const TQT_DBusError)));
				int asyncCallID;
				ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
				if (ret && error.isValid()) {
					ret = 0;
					PRINT_ERROR((error.name() + ": " + error.message()))
				}
				if (ret) {
					// Wait for the asynchronous call to return...
					d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
					TQTimer nmCallTimeoutTimer;
					nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
					while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
						tqApp->processEvents();
						if (!nmCallTimeoutTimer.isActive()) {
							PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
							break;
						}
					}
					TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
					if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
						PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
						d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
					}
					d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
					if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
						d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
					}
#endif // USE_ASYNC_DBUS_CALLS

#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
					printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
					printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS

					// Parse settings
					TQT_DBusTQStringDataMap::const_iterator it2;
					for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
						TQString outerKeyValue = it2.key();
						TQT_DBusData dataValue = it2.data();
#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
						printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
						TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
						TQT_DBusTQStringDataMap::const_iterator it3;
						for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
							TQString keyValue = it3.key();
							TQT_DBusData dataValue = it3.data();
							if (dataValue.type() != TQT_DBusData::Variant) {
#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
								printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
								// No NM settings are known which use this style
							}
							else {
								TQT_DBusVariant dataValueVariant = dataValue.toVariant();
								TQT_DBusData dataValue2 = dataValueVariant.value;
								if (dataValue2.type() != TQT_DBusData::Variant) {
#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
									printf("[network-manager comm debug] %s = %s (type %d(%s), signature %s)\n", keyValue.ascii(), dataValue2.toString().ascii(), dataValue2.type(), dataValue2.typeName(), dataValueVariant.signature.ascii()); fflush(stdout);
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
									// Most NM settings use this style
									if (outerKeyValue.lower() == "connection") {
										if (keyValue.lower() == "id") {
											connection->friendlyName = dataValue2.toString();
										}
										else if (keyValue.lower() == "uuid") {
											connection->UUID = dataValue2.toString().lower();
										}
										else if (keyValue.lower() == "permissions") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TQString authString = innerDataValue.toString();
												TQStringList pieces = TQStringList::split(":", authString);
												if (pieces[0].lower() == "user") {
													connection->authorizedUsers.append(pieces[1]);
												}
											}
										}
										else if (keyValue.lower() == "autoconnect") {
											connection->autoConnect = dataValue2.toBool();
										}
										else if (keyValue.lower() == "read-only") {
											connection->readOnly = dataValue2.toBool();
										}
										else if (keyValue.lower() == "master") {
											connection->masterConnectionUUID = dataValue2.toString().lower();
										}
										else if (keyValue.lower() == "slave-type") {
											connection->slaveType = nmSlaveTypeToTDESlaveType(dataValue2.toString());
										}
										else if (keyValue.lower() == "timestamp") {
											connection->lastKnownConnection.setTime_t(dataValue2.toUInt64());
										}
									}
									else if (outerKeyValue.lower() == "802-1x") {
										if (keyValue.lower() == "eap") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											state = 0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												if (state == 0) {
													// EAP type
													connection->eapConfig.type = nmEAPTypeToTDEEAPType(innerDataValue.toString());
												}
												state++;
											}
										}
										else if (keyValue.lower() == "identity") {
											connection->eapConfig.userName = dataValue2.toString();
										}
										else if (keyValue.lower() == "anonymous-identity") {
											connection->eapConfig.anonymousUserName = dataValue2.toString();
										}
										else if (keyValue.lower() == "pac-file") {
											connection->eapConfig.pacFileName = dataValue2.toString();
										}
										else if (keyValue.lower() == "ca-cert") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											int count=0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												count++;
												connection->eapConfig.caCertificate.resize(count+1);
												connection->eapConfig.caCertificate[count] = innerDataValue.toByte();
											}
										}
										else if (keyValue.lower() == "ca-path") {
											connection->eapConfig.additionalCAFilesPath = dataValue2.toString();
										}
										else if (keyValue.lower() == "subject-match") {
											connection->eapConfig.authServerCertSubjectMatch = dataValue2.toString();
										}
										else if (keyValue.lower() == "altsubject-matches") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												connection->eapConfig.alternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
											}
										}
										else if (keyValue.lower() == "client-cert") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											int count=0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												count++;
												connection->eapConfig.clientCertificate.resize(count+1);
												connection->eapConfig.clientCertificate[count] = innerDataValue.toByte();
											}
										}
										else if (keyValue.lower() == "phase1-peapver") {
											connection->eapConfig.forcePEAPVersion = dataValue2.toString();
										}
										else if (keyValue.lower() == "phase1-peaplabel") {
											connection->eapConfig.forcePEAPLabel = dataValue2.toString();
										}
										else if (keyValue.lower() == "phase1-fast-provisioning") {
											connection->eapConfig.fastProvisioningFlags = nmEAPFastFlagsToTDEEAPFastFlags(dataValue2.toString());
										}
										else if (keyValue.lower() == "phase2-auth") {
											connection->eapConfig.phase2NonEAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
										}
										else if (keyValue.lower() == "phase2-autheap") {
											connection->eapConfig.phase2EAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
										}
										else if (keyValue.lower() == "phase2-ca-cert") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											int count=0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												count++;
												connection->eapConfig.phase2CaCertificate.resize(count+1);
												connection->eapConfig.phase2CaCertificate[count] = innerDataValue.toByte();
											}
										}
										else if (keyValue.lower() == "phase2-ca-path") {
											connection->eapConfig.phase2CaFilesPath = dataValue2.toString();
										}
										else if (keyValue.lower() == "phase2-subject-match") {
											connection->eapConfig.phase2AuthServerCertSubjectMatch = dataValue2.toString();
										}
										else if (keyValue.lower() == "phase2-altsubject-matches") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
											}
										}
										else if (keyValue.lower() == "phase2-client-cert") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											int count=0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												count++;
												connection->eapConfig.phase2ClientCertificate.resize(count+1);
												connection->eapConfig.phase2ClientCertificate[count] = innerDataValue.toByte();
											}
										}
										else if (keyValue.lower() == "password-flags") {
											connection->eapConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "password-raw-flags") {
											connection->eapConfig.binaryPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "private-key") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											int count=0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												count++;
												connection->eapConfig.privateKey.resize(count+1);
												connection->eapConfig.privateKey[count] = innerDataValue.toByte();
											}
										}
										else if (keyValue.lower() == "private-key-password-flags") {
											connection->eapConfig.privateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "phase2-private-key") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											int count=0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												count++;
												connection->eapConfig.phase2PrivateKey.resize(count+1);
												connection->eapConfig.phase2PrivateKey[count] = innerDataValue.toByte();
											}
										}
										else if (keyValue.lower() == "phase2-private-key-password-flags") {
											connection->eapConfig.phase2PrivateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "system-ca-certs") {
											connection->eapConfig.forceSystemCaCertificates = dataValue2.toBool();
										}
										connection->eapConfig.valid = true;
									}
									else if (outerKeyValue.lower() == "802-3-ethernet") {
										if (keyValue.lower() == "duplex") {
											connection->fullDuplex = (dataValue2.toString().lower() == "full")?true:false;
										}
										else if (keyValue.lower() == "mac-address") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TDENetworkByteList macAddress;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												macAddress.append(innerDataValue.toByte());
											}
											connection->lockedHWAddress.setAddress(macAddress);
										}
										else if (keyValue.lower() == "cloned-mac-address") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TDENetworkByteList macAddress;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												macAddress.append(innerDataValue.toByte());
											}
											connection->manualHWAddress.setAddress(macAddress);
										}
										else if (keyValue.lower() == "mtu") {
											connection->mtu = dataValue2.toUInt32();
										}
									}
									else if (outerKeyValue.lower() == "infiniband") {
										if (keyValue.lower() == "mac-address") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TDENetworkByteList macAddress;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												macAddress.append(innerDataValue.toByte());
											}
											connection->lockedHWAddress.setAddress(macAddress);
										}
										else if (keyValue.lower() == "mtu") {
											connection->mtu = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "transport-mode") {
											infinibandConnection->transportMode = nmIBTransportToTDEIBTransport(dataValue2.toString());
										}
									}
									else if (outerKeyValue.lower() == "802-11-wireless") {
										if (keyValue.lower() == "ssid") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											int count = 0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												wiFiConnection->SSID.resize(count+1);
												wiFiConnection->SSID[count] = innerDataValue.toByte();
												count++;
											}
										}
										else if (keyValue.lower() == "mac-address") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TDENetworkByteList macAddress;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												macAddress.append(innerDataValue.toByte());
											}
											connection->lockedHWAddress.setAddress(macAddress);
										}
										else if (keyValue.lower() == "cloned-mac-address") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TDENetworkByteList macAddress;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												macAddress.append(innerDataValue.toByte());
											}
											connection->manualHWAddress.setAddress(macAddress);
										}
										else if (keyValue.lower() == "mtu") {
											connection->mtu = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "mode") {
											wiFiConnection->operatingMode = nmWiFiModeToTDEWiFiMode(dataValue2.toString());
										}
										else if (keyValue.lower() == "band") {
											wiFiConnection->bandRestriction = nmWiFiFrequencyBandToTDEWiFiFrequencyBand(dataValue2.toString());
										}
										else if (keyValue.lower() == "channel") {
											wiFiConnection->channelRestriction = dataValue2.toUInt32();
											if (wiFiConnection->channelRestriction == 0) wiFiConnection->channelRestriction = -1;
										}
										else if (keyValue.lower() == "rate") {
											wiFiConnection->bitRateRestriction = dataValue2.toUInt32()*1000;
											if (wiFiConnection->bitRateRestriction == 0) wiFiConnection->bitRateRestriction = -1;
										}
										else if (keyValue.lower() == "tx-power") {
											wiFiConnection->powerRestriction = dataValue2.toUInt32();
											if (wiFiConnection->powerRestriction == 0) wiFiConnection->powerRestriction = -1;
										}
										else if (keyValue.lower() == "bssid") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TDENetworkByteList macAddress;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												macAddress.append(innerDataValue.toByte());
											}
											wiFiConnection->accessPointRestriction.setAddress(macAddress);
										}
										else if (keyValue.lower() == "mac-address-blacklist") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TDEMACAddress hwAddress;
												hwAddress.fromString(innerDataValue.toString());
												wiFiConnection->blacklistedBSSIDs.append(hwAddress);
											}
										}
										else if (keyValue.lower() == "seen-bssids") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TDEMACAddress hwAddress;
												hwAddress.fromString(innerDataValue.toString());
												wiFiConnection->heardBSSIDs.append(hwAddress);
											}
										}
										else if (keyValue.lower() == "security") {
											TQString setting;
											if (setting.lower() == "802-11-wireless-security") {
												wiFiConnection->securityRequired = true;
											}
											else {
												wiFiConnection->securityRequired = false;
											}
										}
										else if (keyValue.lower() == "hidden") {
											wiFiConnection->isHiddenNetwork = dataValue2.toBool();
										}
									}
									else if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
										if (keyValue.lower() == "key-mgmt") {
											wiFiConnection->securitySettings.keyType = nmWiFiKeyTypeToTDEWiFiKeyType(dataValue2.toString());
										}
										else if (keyValue.lower() == "wep-tx-keyidx") {
											wiFiConnection->securitySettings.wepKeyIndex = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "auth-alg") {
											wiFiConnection->securitySettings.authType = nmWiFiAuthTypeToTDEWiFiAuthType(dataValue2.toString());
										}
										else if (keyValue.lower() == "proto") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TQStringList strings;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												strings.append(innerDataValue.toString());
											}
											wiFiConnection->securitySettings.wpaVersion = nmWiFiWPAVersionToTDEWiFiWPAVersion(strings);
										}
										else if (keyValue.lower() == "pairwise") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TQStringList strings;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												wiFiConnection->securitySettings.allowedPairWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
											}
											if ((wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
												|| (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
												|| (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
												|| (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
												wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
											}
										}
										else if (keyValue.lower() == "group") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TQStringList strings;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
											}
											if ((wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
												|| (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
												|| (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
												|| (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
												wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
											}
										}
										else if (keyValue.lower() == "leap-username") {
											wiFiConnection->securitySettings.leapUsername = dataValue2.toString();
										}
										else if (keyValue.lower() == "wep-key-flags") {
											wiFiConnection->securitySettings.wepKeyFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "wep-key-type") {
											wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "psk-flags") {
											wiFiConnection->securitySettings.pskFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "leap-password-flags") {
											wiFiConnection->securitySettings.leapPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										wiFiConnection->securitySettings.valid = true;
									}
									else if (outerKeyValue.lower() == "vpn") {
										if (keyValue.lower() == "service-type") {
											TQString plugin = dataValue2.toString();
											plugin.replace("org.freedesktop.NetworkManager.", "");
											vpnConnection->vpnPluginID = plugin;
										}
										else if (keyValue.lower() == "user-name") {
											vpnConnection->lockedUserName = dataValue2.toString();
										}
										else if (keyValue.lower() == "data") {
											vpnConnection->pluginData.clear();
											TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
											TQT_DBusTQStringDataMap::const_iterator it4;
											for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
												TQString keyValue4 = it4.key();
												TQT_DBusData dataValue4 = it4.data();
												if (dataValue4.type() == TQT_DBusData::String) {
													vpnConnection->pluginData[keyValue4] = dataValue4.toString();
												}
											}
										}
									}
									else if (outerKeyValue.lower() == "wimax") {
										if (keyValue.lower() == "mac-address") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TDENetworkByteList macAddress;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												macAddress.append(innerDataValue.toByte());
											}
											connection->lockedHWAddress.setAddress(macAddress);
										}
										else if (keyValue.lower() == "network-name") {
											wiMaxConnection->networkServiceProvider = dataValue2.toString();
										}
									}
									else if (outerKeyValue.lower() == "vlan") {
										if (keyValue.lower() == "interface-name") {
											vlanConnection->kernelName = dataValue2.toString();
										}
										else if (keyValue.lower() == "parent") {
											vlanConnection->parentConnectionUUID = dataValue2.toString();
										}
										else if (keyValue.lower() == "id") {
											vlanConnection->vlanID = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "flags") {
											vlanConnection->vlanFlags = nmVLANFlagsToTDEVLANFlags(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "ingress-priority-map") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
												vlanConnection->ingressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
											}
										}
										else if (keyValue.lower() == "egress-priority-map") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
												vlanConnection->egressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
											}
										}
									}
									else if (outerKeyValue.lower() == "serial") {
										if (keyValue.lower() == "baud") {
											connection->serialConfig.baudRate = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "bits") {
											connection->serialConfig.byteWidth = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "parity") {
											connection->serialConfig.parity = nmParityToTDEParity(dataValue2.toByte());
										}
										else if (keyValue.lower() == "stopbits") {
											connection->serialConfig.stopBits = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "send-delay") {
											connection->serialConfig.txDelay = dataValue2.toUInt64();
										}
										connection->serialConfig.valid = true;
									}
									else if (outerKeyValue.lower() == "ppp") {
										if (keyValue.lower() == "noauth") {
											connection->pppConfig.requireServerAuthentication = !(dataValue2.toBool());
										}
										else if (keyValue.lower() == "refuse-eap") {
											if (dataValue2.toBool())	connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableEAP;
											else				connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableEAP;
										}
										else if (keyValue.lower() == "refuse-pap") {
											if (dataValue2.toBool())	connection->pppConfig.flags |=  TDENetworkPPPFlags::DisablePAP;
											else				connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisablePAP;
										}
										else if (keyValue.lower() == "refuse-chap") {
											if (dataValue2.toBool())	connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableCHAP;
											else				connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableCHAP;
										}
										else if (keyValue.lower() == "refuse-mschap") {
											if (dataValue2.toBool())	connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableMSCHAP;
											else				connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAP;
										}
										else if (keyValue.lower() == "refuse-mschapv2") {
											if (dataValue2.toBool())	connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableMSCHAPv2;
											else				connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAPv2;
										}
										else if (keyValue.lower() == "nobsdcomp") {
											if (dataValue2.toBool())	connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowBSDCompression;
											else				connection->pppConfig.flags |=  TDENetworkPPPFlags::AllowBSDCompression;
										}
										else if (keyValue.lower() == "nodeflate") {
											if (dataValue2.toBool())	connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowDeflateCompression;
											else				connection->pppConfig.flags |=  TDENetworkPPPFlags::AllowDeflateCompression;
										}
										else if (keyValue.lower() == "no-vj-comp") {
											if (dataValue2.toBool())	connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowVJCompression;
											else				connection->pppConfig.flags |=  TDENetworkPPPFlags::AllowVJCompression;
										}
										else if (keyValue.lower() == "require-mppe") {
											if (dataValue2.toBool())	connection->pppConfig.flags |=  TDENetworkPPPFlags::RequireMPPE;
											else				connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE;
										}
										else if (keyValue.lower() == "require-mppe-128") {
											if (dataValue2.toBool())	connection->pppConfig.flags |=  TDENetworkPPPFlags::RequireMPPE128;
											else				connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE128;
										}
										else if (keyValue.lower() == "mppe-stateful") {
											if (dataValue2.toBool())	connection->pppConfig.flags |=  TDENetworkPPPFlags::StatefulMPPE;
											else				connection->pppConfig.flags &= ~TDENetworkPPPFlags::StatefulMPPE;
										}
										else if (keyValue.lower() == "crtscts") {
											if (dataValue2.toBool())	connection->pppConfig.flags |=  TDENetworkPPPFlags::UseHardwareFlowControl;
											else				connection->pppConfig.flags &= ~TDENetworkPPPFlags::UseHardwareFlowControl;
										}
										else if (keyValue.lower() == "baud") {
											connection->pppConfig.baudRate = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "mru") {
											connection->pppConfig.mru = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "mtu") {
											connection->pppConfig.mtu = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "lcp-echo-interval") {
											connection->pppConfig.lcpEchoPingInterval = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "lcp-echo-failure") {
											connection->pppConfig.lcpEchoFailureThreshold = dataValue2.toUInt32();
										}
										connection->pppConfig.valid = true;
									}
									else if (outerKeyValue.lower() == "pppoe") {
										if (keyValue.lower() == "service") {
											connection->pppoeConfig.networkServiceProvider = dataValue2.toString();
										}
										else if (keyValue.lower() == "username") {
											connection->pppoeConfig.username = dataValue2.toString();
										}
										else if (keyValue.lower() == "password-flags") {
											connection->pppoeConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										connection->pppoeConfig.secretsValid = true;
									}
									else if ((outerKeyValue.lower() == "802-11-olpc-mesh") && (olpcMeshConnection)) {
										if (keyValue.lower() == "ssid") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											int count = 0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												olpcMeshConnection->SSID.resize(count+1);
												olpcMeshConnection->SSID[count] = innerDataValue.toByte();
												count++;
											}
										}
										else if (keyValue.lower() == "channel") {
											olpcMeshConnection->channel = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "dhcp-anycast-address") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											int count = 0;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												olpcMeshConnection->anycastDHCPHWAddress.resize(count+1);
												olpcMeshConnection->anycastDHCPHWAddress[count] = innerDataValue.toByte();
												count++;
											}
										}
									}
									else if ((outerKeyValue.lower() == "bluetooth") && (bluetoothConnection)) {
										if (keyValue.lower() == "bdaddr") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											TDENetworkByteList macAddress;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												macAddress.append(innerDataValue.toByte());
											}
											connection->lockedHWAddress.setAddress(macAddress);
										}
										else if (keyValue.lower() == "type") {
											bluetoothConnection->type = nmBluetoothModeToTDEBluetoothMode(dataValue2.toString());
										}
									}
									else if ((outerKeyValue.lower() == "cdma") && (modemConnection)) {
										if (keyValue.lower() == "number") {
											modemConnection->cdmaConfig.providerDataNumber = dataValue2.toString();
										}
										else if (keyValue.lower() == "username") {
											modemConnection->cdmaConfig.username = dataValue2.toString();
										}
										else if (keyValue.lower() == "password-flags") {
											modemConnection->cdmaConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										modemConnection->type = TDEModemConnectionType::CDMA;
										modemConnection->cdmaConfig.valid = true;
									}
									else if ((outerKeyValue.lower() == "gsm") && (modemConnection)) {
										if (keyValue.lower() == "number") {
											modemConnection->gsmConfig.providerDataNumber = dataValue2.toString();
										}
										else if (keyValue.lower() == "username") {
											modemConnection->gsmConfig.username = dataValue2.toString();
										}
										else if (keyValue.lower() == "password-flags") {
											modemConnection->gsmConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "apn") {
											modemConnection->gsmConfig.accessPointName = dataValue2.toString();
										}
										else if (keyValue.lower() == "network-id") {
											modemConnection->gsmConfig.networkID = dataValue2.toString();
										}
										else if (keyValue.lower() == "network-type") {
											modemConnection->gsmConfig.networkType = nmGSMModeToTDEGSMMode(dataValue2.toInt32());
										}
										else if (keyValue.lower() == "pin-flags") {
											modemConnection->gsmConfig.pinFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
										}
										else if (keyValue.lower() == "allowed-bands") {
											modemConnection->gsmConfig.allowedFrequencyBands = dataValue2.toUInt32();
										}
										else if (keyValue.lower() == "home-only") {
											modemConnection->gsmConfig.allowRoaming = !dataValue2.toBool();
										}
										modemConnection->type = TDEModemConnectionType::GSM;
										modemConnection->gsmConfig.valid = true;
									}
									else if (outerKeyValue.lower() == "ipv4") {
										if (keyValue.lower() == "addresses") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
												TQT_DBusDataValueList::const_iterator it5;
												state = 0;
												TDENetworkSingleIPConfiguration ipConfig;
												for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
													TQT_DBusData innerMostDataValue = *it5;
													if (state == 0) {
														// Address
														ipConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
													}
													else if (state == 1) {
														// Network mask
														ipConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
													}
													else if (state == 2) {
														// Gateway
														ipConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
													}
													state++;
												}
												ipConfig.valid = true;
												connection->ipConfig.ipConfigurations.append(ipConfig);
											}
										}
										else if (keyValue.lower() == "dhcp-client-id") {
											connection->ipConfig.dhcpClientIdentifier = dataValue2.toString();
										}
										else if (keyValue.lower() == "dns") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												connection->ipConfig.resolvers.append(TQHostAddress(reverseIPV4ByteOrder(innerDataValue.toUInt32())));
											}
										}
										else if (keyValue.lower() == "dns-search") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), false));
											}
										}
										else if (keyValue.lower() == "ignore-auto-dns") {
											bool nm_static_dns = dataValue2.toBool();
											if (nm_static_dns) {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
											}
											else {
												connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
											}
										}
										else if (keyValue.lower() == "may-fail") {
											bool nm_may_fail = dataValue2.toBool();
											connection->requireIPV4 = !nm_may_fail;
										}
										else if (keyValue.lower() == "method") {
											TQString nm_method = dataValue2.toString().lower();
											if (nm_method == "auto") {
												connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPIP;
											}
											else if (nm_method == "manual") {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPIP;
											}
											else if (nm_method == "link-local") {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4LocalOnly;
											}
											else if (nm_method == "shared") {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer;
											}
											else if (nm_method == "disabled") {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4Disabled;
											}
										}
										else if (keyValue.lower() == "ignore-auto-routes") {
											bool nm_static_routes = dataValue2.toBool();
											if (nm_static_routes) {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
											}
											else {
												connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
											}
										}
										else if (keyValue.lower() == "never-default") {
											bool nm_can_default_route = !dataValue2.toBool();
											if (nm_can_default_route) {
												connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
											}
											else {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
											}
										}
										else if (keyValue.lower() == "routes") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
												TQT_DBusDataValueList::const_iterator it5;
												state = 0;
												TDENetworkSingleRouteConfiguration routeConfig;
												for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
													TQT_DBusData innerMostDataValue = *it5;
													if (state == 0) {
														// Address
														routeConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
													}
													else if (state == 1) {
														// Network mask
														routeConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
													}
													else if (state == 2) {
														// Gateway
														routeConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
													}
													else if (state == 3) {
														// Metric
														routeConfig.metric = innerMostDataValue.toUInt32();
													}
													state++;
												}
												routeConfig.valid = true;
												connection->ipConfig.routeConfigurations.append(routeConfig);
											}
										}
										connection->ipConfig.valid = true;
									}
									else if (outerKeyValue.lower() == "ipv6") {
										if (keyValue.lower() == "addresses") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
												TQT_DBusDataValueList::const_iterator it5;
												TDENetworkSingleIPConfiguration ipConfig;
												// Address
												TQT_DBusDataValueList innerMostValueList;
												innerMostValueList = innerValueList[0].toTQValueList();
												TQ_UINT8 nm_v6address[16];
												unsigned char nm_addr_ptr = 0;
												memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
												for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
													TQT_DBusData innerMostDataValue = *it5;
													if (nm_addr_ptr < 16) {
														nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
														nm_addr_ptr++;
													}
												}
												ipConfig.ipAddress = TQHostAddress(nm_v6address);

												// Netmask
												ipConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);

												// Gateway
												memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
												for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
													TQT_DBusData innerMostDataValue = *it5;
													if (nm_addr_ptr < 16) {
														nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
														nm_addr_ptr++;
													}
												}
												ipConfig.gateway = TQHostAddress(nm_v6address);

												ipConfig.valid = true;
												connection->ipConfig.ipConfigurations.append(ipConfig);
											}
										}
										else if (keyValue.lower() == "dns") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
												TQT_DBusDataValueList::const_iterator it5;
												TQ_UINT8 nm_v6address[16];
												unsigned char nm_addr_ptr = 0;
												memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
												for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
													TQT_DBusData innerMostDataValue = *it5;
													if (nm_addr_ptr < 16) {
														nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
														nm_addr_ptr++;
													}
												}
												connection->ipConfig.resolvers.append(TQHostAddress(nm_v6address));
											}
										}
										else if (keyValue.lower() == "dns-search") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
												TQT_DBusDataValueList::const_iterator it5;
												connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), true));
											}
										}
										else if (keyValue.lower() == "ignore-auto-dns") {
											bool nm_static_dns = dataValue2.toBool();
											if (nm_static_dns) {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
											}
											else {
												connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
											}
										}
										else if (keyValue.lower() == "may-fail") {
											bool nm_may_fail = dataValue2.toBool();
											connection->requireIPV6 = !nm_may_fail;
										}
										else if (keyValue.lower() == "method") {
											TQString nm_method = dataValue2.toString().lower();
											if (nm_method == "auto") {
												connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPIP;
											}
											else if (nm_method == "manual") {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPIP;
											}
											else if (nm_method == "link-local") {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6LocalOnly;
											}
											else if (nm_method == "shared") {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer;
											}
											else if (nm_method == "ignore") {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6Disabled;
											}
										}
										else if (keyValue.lower() == "ignore-auto-routes") {
											bool nm_static_routes = dataValue2.toBool();
											if (nm_static_routes) {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
											}
											else {
												connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
											}
										}
										else if (keyValue.lower() == "never-default") {
											bool nm_can_default_route = !dataValue2.toBool();
											if (nm_can_default_route) {
												connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
											}
											else {
												connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
											}
										}
										else if (keyValue.lower() == "routes") {
											TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
											TQT_DBusDataValueList::const_iterator it4;
											for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
												TQT_DBusData innerDataValue = *it4;
												TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
												TQT_DBusDataValueList::const_iterator it5;
												TDENetworkSingleRouteConfiguration routeConfig;
												// Address
												TQT_DBusDataValueList innerMostValueList;
												innerMostValueList = innerValueList[0].toTQValueList();
												TQ_UINT8 nm_v6address[16];
												unsigned char nm_addr_ptr = 0;
												memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
												for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
													TQT_DBusData innerMostDataValue = *it5;
													if (nm_addr_ptr < 16) {
														nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
														nm_addr_ptr++;
													}
												}
												routeConfig.ipAddress = TQHostAddress(nm_v6address);

												// Netmask
												routeConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);

												// Gateway
												innerMostValueList = innerValueList[2].toTQValueList();
												nm_addr_ptr = 0;
												memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
												for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
													TQT_DBusData innerMostDataValue = *it5;
													if (nm_addr_ptr < 16) {
														nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
														nm_addr_ptr++;
													}
												}
												routeConfig.gateway = TQHostAddress(nm_v6address);

												// Metric
												routeConfig.metric = innerValueList[3].toUInt32();

												routeConfig.valid = true;
												connection->ipConfig.routeConfigurations.append(routeConfig);
											}
										}
										connection->ipConfig.valid = true;
									}
								}
								else {
									// FIXME
									// There are several advanced properties which appear to use string maps
									// For example, s390-options
									// Support should eventually be added for these, e.g. in a backend-specific Advanced tab somewhere
								}
							}
						}
					}

					// If the connection's MAC matches my MAC, or if the connection is not locked to any MAC address,
					// or if this manager object is not locked to a device, then add this connection to the list
					if ((deviceMACAddress == connection->lockedHWAddress) || (!connection->lockedHWAddress.isValid()) || (!deviceMACAddress.isValid())) {
						loadConnectionAllowedValues(connection);
						m_connectionList->append(connection);
					}
				}
				else {
					// Error!
					PRINT_ERROR((error.name() + ": " + error.message()))
				}
			}
		}
		else {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
		}
		internalNetworkManagementEvent(TDENetworkGlobalEventType::ConnectionListChanged);
	}

	d->nonReentrantCallActive = false;
}

void TDENetworkConnectionManager_BackendNM::loadConnectionAllowedValues(TDENetworkConnection* connection) {
	if (connection) {
		// Insert all allowed EAP phase 2 methods
		connection->eapConfig.allowedPhase2NonEAPMethods.clear();
		connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MD5);
		connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
		connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::OTP);
		connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::GTC);
		connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::TLS);

		connection->eapConfig.allowedPhase2EAPMethods.clear();
		connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::PAP);
		connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::CHAP);
		connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAP);
		connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
		connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::OTP);
		connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::GTC);
		connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::TLS);

		connection->eapConfig.allowedValid = true;
	}
}

// NOTE
// While this separate separate routine is needed to get the secrets, note that secrets must
// be saved using the same connection map save routine that all other settings use above.
bool TDENetworkConnectionManager_BackendNM::loadConnectionSecrets(TQString uuid) {
	TDENetworkConnection* connection = findConnectionByUUID(uuid);
	if (!connection) {
		PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database.  Did you run loadConnectionInformation() first?"));
		return FALSE;
	}
	//TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
	//TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
	TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
	TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
	//TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
	//TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
	//TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
	//TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
	TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);

	bool ret = TRUE;
	ret = ret && loadConnectionSecretsForGroup(uuid, "802-1x");
	if (wiFiConnection) {
		ret = ret && loadConnectionSecretsForGroup(uuid, "802-11-wireless-security");
	}
	if (vpnConnection) {
		ret = ret && loadConnectionSecretsForGroup(uuid, "vpn");
	}
	ret = ret && loadConnectionSecretsForGroup(uuid, "pppoe");
	if (modemConnection) {
		ret = ret && loadConnectionSecretsForGroup(uuid, "cdma");
		ret = ret && loadConnectionSecretsForGroup(uuid, "gsm");
	}
	return ret;
}

bool TDENetworkConnectionManager_BackendNM::loadConnectionSecretsForGroup(TQString uuid, TQString group) {
	TDENetworkConnection* connection = findConnectionByUUID(uuid);
	if (!connection) {
		PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database.  Did you run loadConnectionInformation() first?"));
		return FALSE;
	}
	//TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
	//TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
	TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
	TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
	//TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
	//TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
	//TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
	//TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
	TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
	TQT_DBusObjectPath existingConnection;
	TQT_DBusError error;
	bool ret;
	TQT_DBusTQStringDataMap connectionSecretsMap(TQT_DBusData::String);
	ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
	if (ret) {
#ifndef USE_ASYNC_DBUS_CALLS
		// Obtain connection settings from the path specified
		DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
		connectionSettings.setConnection(TQT_DBusConnection::systemBus());
		ret = connectionSettings.GetSecrets(group, connectionSecretsMap, error);
		if (ret && error.isValid()) {
			ret = 0;
			PRINT_ERROR((error.name() + ": " + error.message()))
		}
		if (ret) {
#else // USE_ASYNC_DBUS_CALLS
		// Obtain connection secrets from the path specified
		DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
		connectionSettings.setConnection(TQT_DBusConnection::systemBus());
		connect(&connectionSettings, SIGNAL(GetSecretsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
		int asyncCallID;
		ret = connectionSettings.GetSecretsAsync(asyncCallID, group, error);
		if (ret && error.isValid()) {
			ret = 0;
			PRINT_ERROR((error.name() + ": " + error.message()))
		}
		if (ret) {
			// Wait for the asynchronous call to return...
			d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
			TQTimer nmCallTimeoutTimer;
			nmCallTimeoutTimer.start(NM_ASYNC_SECRETS_INTERACTION_TIMEOUT_MS, TRUE);
			while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
				tqApp->processEvents();
				if (!nmCallTimeoutTimer.isActive()) {
					PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
					break;
				}
			}
			connectionSecretsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
			if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
				PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
				d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
			}
			d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
			if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
				d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
			}
#endif // USE_ASYNC_DBUS_CALLS

#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
			printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
			printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSecretsMap));
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS

			// Parse settings
			TQT_DBusTQStringDataMap::const_iterator it2;
			for (it2 = connectionSecretsMap.begin(); it2 != connectionSecretsMap.end(); ++it2) {
				TQString outerKeyValue = it2.key();
				TQT_DBusData dataValue = it2.data();
#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
				printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
				TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
				TQT_DBusTQStringDataMap::const_iterator it3;
				for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
					TQString keyValue = it3.key();
					TQT_DBusData dataValue = it3.data();
					if (dataValue.type() != TQT_DBusData::Variant) {
#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
						printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
						// No NM settings are known which use this style
					}
					else {
						TQT_DBusVariant dataValueVariant = dataValue.toVariant();
						TQT_DBusData dataValue2 = dataValueVariant.value;
						if (dataValue2.type() != TQT_DBusData::Variant) {
#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
							printf("[network-manager comm debug] %s = %s (type %d(%s), signature %s)\n", keyValue.ascii(), dataValue2.toString().ascii(), dataValue2.type(), dataValue2.typeName(), dataValueVariant.signature.ascii()); fflush(stdout);
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
							// Most NM settings use this style
							if (outerKeyValue.lower() == "802-1x") {
								if (keyValue.lower() == "password") {
									connection->eapConfig.password = dataValue2.toString();
								}
								else if (keyValue.lower() == "password-raw") {
									TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
									TQT_DBusDataValueList::const_iterator it4;
									int count=0;
									for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
										TQT_DBusData innerDataValue = *it4;
										count++;
										connection->eapConfig.binaryPassword.resize(count+1);
										connection->eapConfig.binaryPassword[count] = innerDataValue.toByte();
									}
								}
								else if (keyValue.lower() == "private-key-password") {
									connection->eapConfig.privateKeyPassword = dataValue2.toString();
								}
								else if (keyValue.lower() == "phase2-private-key-password") {
									connection->eapConfig.phase2PrivateKeyPassword = dataValue2.toString();
								}
								connection->eapConfig.secretsValid = true;
							}
							if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
								if (keyValue.lower() == "wep-key0") {
									wiFiConnection->securitySettings.wepKey0 = dataValue2.toString();
									wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey0);
								}
								else if (keyValue.lower() == "wep-key1") {
									wiFiConnection->securitySettings.wepKey1 = dataValue2.toString();
									wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey1);
								}
								else if (keyValue.lower() == "wep-key2") {
									wiFiConnection->securitySettings.wepKey2 = dataValue2.toString();
									wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey2);
								}
								else if (keyValue.lower() == "wep-key3") {
									wiFiConnection->securitySettings.wepKey3 = dataValue2.toString();
									wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey3);
								}
								else if (keyValue.lower() == "psk") {
									wiFiConnection->securitySettings.psk = dataValue2.toString();
								}
								else if (keyValue.lower() == "eap-password") {
									wiFiConnection->securitySettings.leapPassword = dataValue2.toString();
								}
							}
							if ((outerKeyValue.lower() == "vpn") && (vpnConnection)) {
								if (keyValue.lower() == "secrets") {
									TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
									TQT_DBusTQStringDataMap::const_iterator it4;
									for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
										vpnConnection->pluginSecrets.clear();
										TQString keyValue4 = it4.key();
										TQT_DBusData dataValue4 = it4.data();
										if (dataValue4.type() == TQT_DBusData::String) {
											vpnConnection->pluginSecrets[keyValue4] = dataValue4.toString();
										}
									}
									vpnConnection->secretsValid = true;
								}
							}
							if (outerKeyValue.lower() == "pppoe") {
								if (keyValue.lower() == "password") {
									connection->pppoeConfig.password = dataValue2.toString();
								}
								connection->pppoeConfig.secretsValid = true;
							}
							if (outerKeyValue.lower() == "cdma") {
								if (keyValue.lower() == "password") {
									modemConnection->cdmaConfig.password = dataValue2.toString();
								}
								modemConnection->cdmaConfig.secretsValid = true;
							}
							if (outerKeyValue.lower() == "gsm") {
								if (keyValue.lower() == "password") {
									modemConnection->gsmConfig.password = dataValue2.toString();
								}
								else if (keyValue.lower() == "pin") {
									modemConnection->gsmConfig.pin = dataValue2.toString();
								}
								modemConnection->gsmConfig.secretsValid = true;
							}
						}
					}
				}
			}
			return TRUE;
		}
		else {
			PRINT_ERROR(TQString("Unable to load secrets for connection with uuid '%1'").arg(uuid))
			return FALSE;
		}
	}
	else {
		PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
		return FALSE;
	}
}

bool TDENetworkConnectionManager_BackendNM::saveConnection(TDENetworkConnection* connection) {
	bool timed_out = FALSE;
	bool command_failed = FALSE;

	if (!connection) {
		PRINT_ERROR(TQString("connection cannot be NULL!"));
		return FALSE;
	}

	// If the UUID is blank, generate a new UUID for this connection and also guarantee that it it truly unique
	if (connection->UUID == "") {
		bool unique = false;
		while (!unique) {
			connection->UUID = TQUuid::createUuid().toString();
			connection->UUID.replace("{", "");
			connection->UUID.replace("}", "");
			if (!findConnectionByUUID(connection->UUID)) {
				unique = true;
			}
		}
	}

	// Find path for connection with specified UUID, if it exists
	// This is so that any settings that we are not aware of can be loaded now and preserved through the update operation
	TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
	TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
	TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
	TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
	TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
	TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
	TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEOLPCMeshConnection*>(connection);
	TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
	TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
	TQT_DBusObjectPath existingConnection;
	TQT_DBusError error;
	bool ret;
	bool existing;
	TQT_DBusTQStringDataMap connectionSettingsMap(TQT_DBusData::String);
	existing = false;
	ret = d->m_networkManagerSettings->GetConnectionByUuid(connection->UUID, existingConnection, error);
	if (ret) {
#ifndef USE_ASYNC_DBUS_CALLS
		// Obtain connection settings from the path specified
		DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
		connectionSettings.setConnection(TQT_DBusConnection::systemBus());
		ret = connectionSettings.GetSettings(connectionSettingsMap, error);
		if (ret && error.isValid()) {
			ret = 0;
			PRINT_ERROR((error.name() + ": " + error.message()))
		}
		if (ret) {
#else // USE_ASYNC_DBUS_CALLS
		// Obtain connection settings from the path specified
		DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
		connectionSettings.setConnection(TQT_DBusConnection::systemBus());
		connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
		int asyncCallID;
		ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
		if (ret && error.isValid()) {
			ret = 0;
			PRINT_ERROR((error.name() + ": " + error.message()))
		}
		if (ret) {
			// Wait for the asynchronous call to return...
			d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
			TQTimer nmCallTimeoutTimer;
			nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
			while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
				tqApp->processEvents();
				if (!nmCallTimeoutTimer.isActive()) {
					PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
					timed_out = true;
					break;
				}
			}
			connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
			if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
				PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
				d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
			}
			d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
			if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
				d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
			}
#endif // USE_ASYNC_DBUS_CALLS
			existing = true;
		}
	}

	// Create and/or update settings map from provided connection information
	// We start at the outermost layer and work our way inwards, in a structure which should match the parser in loadConnectionInformation() very closely
	bool groupValid;
	TQT_DBusData dbusData;
	TQT_DBusData innerDbusData;
	TQMap<TQString, TQT_DBusData> outerMap = connectionSettingsMap.toTQMap();
	{
		groupValid = false;
		dbusData = outerMap["connection"];
		{
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				settingsMap["id"] = (TQT_DBusData::fromString(connection->friendlyName)).getAsVariantData();
				{
					TQString type;
					if (ethernetConnection) type = "802-3-ethernet";
					else if (infinibandConnection) type = "infiniband";
					else if (wiFiConnection) type = "802-11-wireless";
					else if (vpnConnection) type = "vpn";
					else if (wiMaxConnection) type = "wimax";
					else if (vlanConnection) type = "vlan";
					else if (olpcMeshConnection) type = "802-11-olpc-mesh";
					else if (bluetoothConnection) type = "bluetooth";
					else if (modemConnection) {
						if (modemConnection->type == TDEModemConnectionType::CDMA) {
							type = "cdma";
						}
						else if (modemConnection->type == TDEModemConnectionType::GSM) {
							type = "gsm";
						}
					}
					if (!type.isNull()) settingsMap["type"] = (TQT_DBusData::fromString(type)).getAsVariantData();
				}
				settingsMap["uuid"] = (TQT_DBusData::fromString(connection->UUID)).getAsVariantData();
				{
					TQT_DBusDataValueList valueList;
					{
						for (TQStringList::Iterator it = connection->authorizedUsers.begin(); it != connection->authorizedUsers.end(); ++it) {
							TQString assembledString = TQString("user:%1:").arg(*it);
							valueList.append(TQT_DBusData::fromString(assembledString));
						}
					}
					if (valueList.count() > 0) settingsMap["permissions"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("permissions");
				}
				settingsMap["autoconnect"] = (TQT_DBusData::fromBool(connection->autoConnect)).getAsVariantData();
				settingsMap["read-only"] = (TQT_DBusData::fromBool(connection->readOnly)).getAsVariantData();
				UPDATE_STRING_SETTING_IF_VALID(connection->masterConnectionUUID, "master", settingsMap)
				{
					TQString slaveType = tdeSlaveTypeToNMSlaveType(connection->slaveType);
					if (slaveType != "") settingsMap["slave-type"] = (TQT_DBusData::fromString(slaveType)).getAsVariantData();
					else settingsMap.remove("slave-type");
				}
				// settingsMap["timestamp"] = (TQT_DBusData::fromUInt64(connection->lastKnownConnection.toTime_t())).getAsVariantData();	// Probably read-only to us
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("connection", dbusData, TRUE); else outerMap.remove("connection");

		groupValid = false;
		dbusData = outerMap["802-1x"];
		{
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						// WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
						// EAP type
						valueList.append(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.type)));
					}
					settingsMap["eap"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
				else {
					settingsMap.remove("eap");
				}
				if (connection->eapConfig.valid) {
					UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.userName, "identity", settingsMap)
					UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.anonymousUserName, "anonymous-identity", settingsMap)
					UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.pacFileName, "pac-file", settingsMap)
				}
				else {
					settingsMap.remove("identity");
					settingsMap.remove("anonymous-identity");
					settingsMap.remove("pac-file");
				}
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						unsigned int count;
						for (count=0; count<connection->eapConfig.caCertificate.count(); count++) {
							valueList.append(TQT_DBusData::fromByte(connection->eapConfig.caCertificate[count]));
						}
					}
					if (valueList.count() > 0) settingsMap["ca-cert"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("ca-cert");
				}
				else {
					settingsMap.remove("ca-cert");
				}
				if (connection->eapConfig.valid) {
					UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.additionalCAFilesPath, "ca-path", settingsMap)
					UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.authServerCertSubjectMatch, "subject-match", settingsMap)
				}
				else {
					settingsMap.remove("ca-path");
					settingsMap.remove("subject-match");
				}
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						for (TQStringList::Iterator it = connection->eapConfig.alternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.alternateAuthServerCertSubjectMatch.end(); ++it) {
							valueList.append(TQT_DBusData::fromString(*it));
						}
					}
					if (valueList.count() > 0) settingsMap["altsubject-matches"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("altsubject-matches");
				}
				else {
					settingsMap.remove("altsubject-matches");
				}
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						unsigned int count;
						for (count=0; count<connection->eapConfig.clientCertificate.count(); count++) {
							valueList.append(TQT_DBusData::fromByte(connection->eapConfig.clientCertificate[count]));
						}
					}
					if (valueList.count() > 0) settingsMap["client-cert"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("client-cert");
				}
				else {
					settingsMap.remove("client-cert");
				}
				if (connection->eapConfig.valid) {
					UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPVersion, "phase1-peapver", settingsMap)
					UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPLabel, "phase1-peaplabel", settingsMap)
					UPDATE_STRING_SETTING_IF_VALID(tdeEAPFastFlagsToNMEAPFastFlags(connection->eapConfig.fastProvisioningFlags), "phase1-fast-provisioning", settingsMap)
				}
				else {
					settingsMap.remove("phase1-peapver");
					settingsMap.remove("phase1-peaplabel");
					settingsMap.remove("phase1-fast-provisioning");
				}
				if (connection->eapConfig.valid) {
					settingsMap["phase2-auth"] = (TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2NonEAPAuthMethod))).getAsVariantData();
					settingsMap["phase2-autheap"] = (TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2EAPAuthMethod))).getAsVariantData();
				}
				else {
					settingsMap.remove("phase2-auth");
					settingsMap.remove("phase2-autheap");
				}
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						unsigned int count;
						for (count=0; count<connection->eapConfig.phase2CaCertificate.count(); count++) {
							valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2CaCertificate[count]));
						}
					}
					if (valueList.count() > 0) settingsMap["phase2-ca-cert"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("phase2-ca-cert");
				}
				else {
					settingsMap.remove("phase2-ca-cert");
				}
				if (connection->eapConfig.valid) {
					UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2CaFilesPath, "phase2-ca-path", settingsMap)
					UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2AuthServerCertSubjectMatch, "phase2-subject-match", settingsMap)
				}
				else {
					settingsMap.remove("phase2-ca-path");
					settingsMap.remove("phase2-subject-match");
				}
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						for (TQStringList::Iterator it = connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.end(); ++it) {
							valueList.append(TQT_DBusData::fromString(*it));
						}
					}
					if (valueList.count() > 0) settingsMap["phase2-altsubject-matches"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("phase2-altsubject-matches");
				}
				else {
					settingsMap.remove("phase2-altsubject-matches");
				}
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						unsigned int count;
						for (count=0; count<connection->eapConfig.phase2ClientCertificate.count(); count++) {
							valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2ClientCertificate[count]));
						}
					}
					if (valueList.count() > 0) settingsMap["phase2-client-cert"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("phase2-client-cert");
				}
				else {
					settingsMap.remove("phase2-client-cert");
				}
				if (connection->eapConfig.valid) {
					settingsMap["password-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.passwordFlags))).getAsVariantData();
					settingsMap["password-raw-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.binaryPasswordFlags))).getAsVariantData();
				}
				else {
					settingsMap.remove("password-flags");
					settingsMap.remove("password-raw-flags");
				}
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						unsigned int count;
						for (count=0; count<connection->eapConfig.privateKey.count(); count++) {
							valueList.append(TQT_DBusData::fromByte(connection->eapConfig.privateKey[count]));
						}
					}
					if (valueList.count() > 0) settingsMap["private-key"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("private-key");
				}
				else {
					settingsMap.remove("private-key");
				}
				if (connection->eapConfig.valid) {
					settingsMap["private-key-password-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.privateKeyPasswordFlags))).getAsVariantData();
				}
				else {
					settingsMap.remove("private-key-password-flags");
				}
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						unsigned int count;
						for (count=0; count<connection->eapConfig.phase2PrivateKey.count(); count++) {
							valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2PrivateKey[count]));
						}
					}
					if (valueList.count() > 0) settingsMap["phase2-private-key"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("phase2-private-key");
				}
				else {
					settingsMap.remove("phase2-private-key");
				}
				if (connection->eapConfig.valid) {
					settingsMap["phase2-private-key-password-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.phase2PrivateKeyPasswordFlags))).getAsVariantData();
				}
				else {
					settingsMap.remove("phase2-private-key-password-flags");
				}
				if (connection->eapConfig.valid) {
					settingsMap["system-ca-certs"] = (TQT_DBusData::fromBool(connection->eapConfig.forceSystemCaCertificates)).getAsVariantData();
				}
				else {
					settingsMap.remove("system-ca-certs");
				}
				if (connection->eapConfig.secretsValid) {
					settingsMap["password"] = (TQT_DBusData::fromString(connection->eapConfig.password)).getAsVariantData();
				}
				else {
					settingsMap.remove("password");
				}
				if (connection->eapConfig.valid) {
					TQT_DBusDataValueList valueList;
					{
						unsigned int count;
						for (count=0; count<connection->eapConfig.binaryPassword.count(); count++) {
							valueList.append(TQT_DBusData::fromByte(connection->eapConfig.binaryPassword[count]));
						}
					}
					if (valueList.count() > 0) settingsMap["password-raw"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					else settingsMap.remove("password-raw");
				}
				else {
					settingsMap.remove("password-raw");
				}
				if (connection->eapConfig.secretsValid) {
					settingsMap["private-key-password"] = (TQT_DBusData::fromString(connection->eapConfig.privateKeyPassword)).getAsVariantData();
					settingsMap["phase2-private-key-password"] = (TQT_DBusData::fromString(connection->eapConfig.phase2PrivateKeyPassword)).getAsVariantData();
				}
				else {
					settingsMap.remove("private-key-password");
					settingsMap.remove("phase2-private-key-password");
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("802-1x", dbusData, TRUE); else outerMap.remove("802-1x");

		groupValid = false;
		dbusData = outerMap["802-3-ethernet"];
		if (ethernetConnection) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				settingsMap["duplex"] = (TQT_DBusData::fromString((connection->fullDuplex)?"full":"half")).getAsVariantData();
				if (connection->lockedHWAddress.isValid()) {
					TDENetworkByteList address = connection->lockedHWAddress.address();
					TQT_DBusDataValueList valueList;
					TDENetworkByteList::iterator it;
					for (it = address.begin(); it != address.end(); ++it) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
						valueList.append(innerDataValue);
					}
					TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
					settingsMap["mac-address"] = (nmHWAddress).getAsVariantData();
				}
				else {
					settingsMap.remove("mac-address");
				}
				if (connection->manualHWAddress.isValid()) {
					TDENetworkByteList address = connection->manualHWAddress.address();
					TQT_DBusDataValueList valueList;
					TDENetworkByteList::iterator it;
					for (it = address.begin(); it != address.end(); ++it) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
						valueList.append(innerDataValue);
					}
					TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
					settingsMap["cloned-mac-address"] = (nmHWAddress).getAsVariantData();
				}
				else {
					settingsMap.remove("cloned-mac-address");
				}
				if (connection->mtu > 0) {
					settingsMap["mtu"] = (TQT_DBusData::fromUInt32(connection->mtu)).getAsVariantData();
				}
				else {
					settingsMap.remove("mtu");
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("802-3-ethernet", dbusData, TRUE); else outerMap.remove("802-3-ethernet");

		groupValid = false;
		dbusData = outerMap["infiniband"];
		if (infinibandConnection) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				if (connection->lockedHWAddress.isValid()) {
					TDENetworkByteList address = connection->lockedHWAddress.address();
					TQT_DBusDataValueList valueList;
					TDENetworkByteList::iterator it;
					for (it = address.begin(); it != address.end(); ++it) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
						valueList.append(innerDataValue);
					}
					TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
					settingsMap["mac-address"] = (nmHWAddress).getAsVariantData();
				}
				else {
					settingsMap.remove("mac-address");
				}
				if (connection->mtu > 0) {
					settingsMap["mtu"] = (TQT_DBusData::fromUInt32(connection->mtu)).getAsVariantData();
				}
				else {
					settingsMap.remove("mtu");
				}
				UPDATE_STRING_SETTING_IF_VALID(tdeIBTransportToNMIBTransport(infinibandConnection->transportMode), "transport-mode", settingsMap)
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("infiniband", dbusData, TRUE); else outerMap.remove("infiniband");

		groupValid = false;
		dbusData = outerMap["802-11-wireless"];
		if (wiFiConnection) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				{
					unsigned int i;
					TQT_DBusDataValueList valueList;
					for (i=0; i<wiFiConnection->SSID.count(); i++) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(wiFiConnection->SSID[i]);
						valueList.append(innerDataValue);
					}
					settingsMap["ssid"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
				if (connection->lockedHWAddress.isValid()) {
					TDENetworkByteList address = connection->lockedHWAddress.address();
					TQT_DBusDataValueList valueList;
					TDENetworkByteList::iterator it;
					for (it = address.begin(); it != address.end(); ++it) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
						valueList.append(innerDataValue);
					}
					TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
					settingsMap["mac-address"] = (nmHWAddress).getAsVariantData();
				}
				else {
					settingsMap.remove("mac-address");
				}
				if (connection->manualHWAddress.isValid()) {
					TDENetworkByteList address = connection->manualHWAddress.address();
					TQT_DBusDataValueList valueList;
					TDENetworkByteList::iterator it;
					for (it = address.begin(); it != address.end(); ++it) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
						valueList.append(innerDataValue);
					}
					TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
					settingsMap["cloned-mac-address"] = (nmHWAddress).getAsVariantData();
				}
				else {
					settingsMap.remove("cloned-mac-address");
				}
				if (connection->mtu > 0) {
					settingsMap["mtu"] = (TQT_DBusData::fromUInt32(connection->mtu)).getAsVariantData();
				}
				else {
					settingsMap.remove("mtu");
				}
				UPDATE_STRING_SETTING_IF_VALID(tdeWiFiModeToNMWiFiMode(wiFiConnection->operatingMode), "mode", settingsMap)
				UPDATE_STRING_SETTING_IF_VALID(tdeWiFiFrequencyBandToNMWiFiFrequencyBand(wiFiConnection->bandRestriction), "band", settingsMap)
				if (wiFiConnection->channelRestriction > 0) {
					settingsMap["channel"] = (TQT_DBusData::fromUInt32(wiFiConnection->channelRestriction)).getAsVariantData();
				}
				else {
					settingsMap.remove("channel");
				}
				if (wiFiConnection->bitRateRestriction > 0) {
					settingsMap["rate"] = (TQT_DBusData::fromUInt32(wiFiConnection->bitRateRestriction/1000)).getAsVariantData();
				}
				else {
					settingsMap.remove("rate");
				}
				if (wiFiConnection->powerRestriction > 0) {
					settingsMap["tx-power"] = (TQT_DBusData::fromUInt32(wiFiConnection->powerRestriction)).getAsVariantData();
				}
				else {
					settingsMap.remove("tx-power");
				}
				if (wiFiConnection->accessPointRestriction.isValid()) {
					TDENetworkByteList address = wiFiConnection->accessPointRestriction.address();
					TQT_DBusDataValueList valueList;
					TDENetworkByteList::iterator it;
					for (it = address.begin(); it != address.end(); ++it) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
						valueList.append(innerDataValue);
					}
					TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
					settingsMap["bssid"] = (nmHWAddress).getAsVariantData();
				}
				else {
					settingsMap.remove("bssid");
				}
				{
					TQT_DBusDataValueList valueList;
					TDEMACAddressList::iterator it;
					for (it = wiFiConnection->blacklistedBSSIDs.begin(); it != wiFiConnection->blacklistedBSSIDs.end(); ++it) {
						valueList.append(TQT_DBusData::fromString((*it).toString()));
					}
					if (valueList.count() > 0) settingsMap["mac-address-blacklist"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
				{
					TQT_DBusDataValueList valueList;
					TDEMACAddressList::iterator it;
					for (it = wiFiConnection->heardBSSIDs.begin(); it != wiFiConnection->heardBSSIDs.end(); ++it) {
						valueList.append(TQT_DBusData::fromString((*it).toString()));
					}
					if (valueList.count() > 0) settingsMap["seen-bssids"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
				{
					if (wiFiConnection->securityRequired) {
						settingsMap["security"] = (TQT_DBusData::fromString("802-11-wireless-security")).getAsVariantData();
					}
					else {
						settingsMap.remove("security");
					}
				}
				{
					if (wiFiConnection->isHiddenNetwork) {
						settingsMap["hidden"] = (TQT_DBusData::fromBool(true)).getAsVariantData();
					}
					else {
						settingsMap.remove("hidden");
					}
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("802-11-wireless", dbusData, TRUE); else outerMap.remove("802-11-wireless");

		groupValid = false;
		dbusData = outerMap["802-11-wireless-security"];
		if (wiFiConnection) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				if (wiFiConnection->securityRequired) {
					if (wiFiConnection->securityRequired) {
						settingsMap["key-mgmt"] = (TQT_DBusData::fromString(tdeWiFiKeyTypeToNMWiFiKeyType(wiFiConnection->securitySettings.keyType))).getAsVariantData();
					}
					if (wiFiConnection->securitySettings.wepKeyIndex > 0) {
						settingsMap["wep-tx-keyidx"] = (TQT_DBusData::fromUInt32(wiFiConnection->securitySettings.wepKeyIndex)).getAsVariantData();
					}
					else {
						settingsMap.remove("wep-tx-keyidx");
					}
					UPDATE_STRING_SETTING_IF_VALID(tdeWiFiAuthTypeToNMWiFiAuthType(wiFiConnection->securitySettings.authType), "auth-alg", settingsMap)
					{
						TQT_DBusDataValueList valueList;
						{
							TQStringList strings = tdeWiFiWPAVersionToNMWiFiWPAVersion(wiFiConnection->securitySettings.wpaVersion);
							for (TQStringList::Iterator it = strings.begin(); it != strings.end(); ++it) {
								valueList.append(TQT_DBusData::fromString(*it));
							}
						}
						if (valueList.count() > 0) settingsMap["proto"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
						else settingsMap.remove("proto");
					}
					{
						TQT_DBusDataValueList valueList;
						{
							if (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
								if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
								if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
								if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
								if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
							}
							for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedPairWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedPairWiseCiphers.end(); ++it) {
								valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
							}
						}
						if (valueList.count() > 0) settingsMap["pairwise"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
						else settingsMap.remove("pairwise");
					}
					{
						TQT_DBusDataValueList valueList;
						{
							if (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
								if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
								if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
								if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
								if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
							}
							for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedGroupWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedGroupWiseCiphers.end(); ++it) {
								valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
							}
						}
						if (valueList.count() > 0) settingsMap["group"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
						else settingsMap.remove("group");
					}
					UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapUsername, "leap-username", settingsMap)
					settingsMap["wep-key-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.wepKeyFlags))).getAsVariantData();
					settingsMap["wep-key-type"] = (TQT_DBusData::fromUInt32(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType))).getAsVariantData();
					settingsMap["psk-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.pskFlags))).getAsVariantData();
					settingsMap["leap-password-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.leapPasswordFlags))).getAsVariantData();
					if (wiFiConnection->securitySettings.secretsValid) {
						UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey0, "wep-key0", settingsMap)
						UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey1, "wep-key1", settingsMap)
						UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey2, "wep-key2", settingsMap)
						UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey3, "wep-key3", settingsMap)
						UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.psk, "psk", settingsMap)
						UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapPassword, "leap-password", settingsMap)
					}
					else {
						settingsMap.remove("wep-key0");
						settingsMap.remove("wep-key1");
						settingsMap.remove("wep-key2");
						settingsMap.remove("wep-key3");
						settingsMap.remove("psk");
						settingsMap.remove("leap-password");
					}
				}
				else {
					settingsMap.remove("key-mgmt");
					settingsMap.remove("wep-tx-keyidx");
					settingsMap.remove("auth-alg");
					settingsMap.remove("proto");
					settingsMap.remove("pairwise");
					settingsMap.remove("group");
					settingsMap.remove("leap-username");
					settingsMap.remove("wep-key-flags");
					settingsMap.remove("wep-key-type");
					settingsMap.remove("psk-flags");
					settingsMap.remove("leap-password-flags");
					settingsMap.remove("wep-key0");
					settingsMap.remove("wep-key1");
					settingsMap.remove("wep-key2");
					settingsMap.remove("wep-key3");
					settingsMap.remove("psk");
					settingsMap.remove("leap-password");
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("802-11-wireless-security", dbusData, TRUE); else outerMap.remove("802-11-wireless-security");

		groupValid = false;
		dbusData = outerMap["vpn"];
		if (vpnConnection) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				{
					TQString pluginService = vpnConnection->vpnPluginID;
					if (pluginService != "") {
						pluginService = "org.freedesktop.NetworkManager." + pluginService;
					}
					UPDATE_STRING_SETTING_IF_VALID(pluginService, "service-type", settingsMap)
				}
				UPDATE_STRING_SETTING_IF_VALID(vpnConnection->lockedUserName, "user-name", settingsMap)
				{
					TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
					TDENetworkSettingsMap::const_iterator it;
					for (it = vpnConnection->pluginData.begin(); it != vpnConnection->pluginData.end(); ++it) {
						nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
					}
					if (nestedConnectionSettingsMap.count() > 0) settingsMap["data"] = (TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap))).getAsVariantData();
					else settingsMap.remove("data");
				}
				if (vpnConnection->secretsValid) {
					TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
					TDENetworkSettingsMap::const_iterator it;
					for (it = vpnConnection->pluginSecrets.begin(); it != vpnConnection->pluginSecrets.end(); ++it) {
						nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
					}
					if (nestedConnectionSettingsMap.count() > 0) settingsMap["secrets"] = (TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap))).getAsVariantData();
					else settingsMap.remove("secrets");
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("vpn", dbusData, TRUE); else outerMap.remove("vpn");

		groupValid = false;
		dbusData = outerMap["wimax"];
		if (wiMaxConnection) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				if (connection->lockedHWAddress.isValid()) {
					TDENetworkByteList address = connection->lockedHWAddress.address();
					TQT_DBusDataValueList valueList;
					TDENetworkByteList::iterator it;
					for (it = address.begin(); it != address.end(); ++it) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
						valueList.append(innerDataValue);
					}
					TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
					settingsMap["mac-address"] = (nmHWAddress).getAsVariantData();
				}
				else {
					settingsMap.remove("mac-address");
				}
				UPDATE_STRING_SETTING_IF_VALID(wiMaxConnection->networkServiceProvider, "network-name", settingsMap)
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("wimax", dbusData, TRUE); else outerMap.remove("wimax");

		groupValid = false;
		dbusData = outerMap["vlan"];
		if (vlanConnection) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				UPDATE_STRING_SETTING_IF_VALID(vlanConnection->kernelName, "interface-name", settingsMap)
				UPDATE_STRING_SETTING_IF_VALID(vlanConnection->parentConnectionUUID, "parent", settingsMap)
				settingsMap["id"] = (TQT_DBusData::fromUInt32(vlanConnection->vlanID)).getAsVariantData();
				settingsMap["flags"] = (TQT_DBusData::fromUInt32(tdeVLANFlagsToNMVLANFlags(vlanConnection->vlanFlags))).getAsVariantData();
				{
					TQT_DBusDataValueList valueList;
					TDENetworkPriorityMap::const_iterator it;
					for (it = vlanConnection->ingressPriorityMap.begin(); it != vlanConnection->ingressPriorityMap.end(); ++it) {
						valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
					}
					if (valueList.count() > 0) settingsMap["ingress-priority-map"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
				{
					TQT_DBusDataValueList valueList;
					TDENetworkPriorityMap::const_iterator it;
					for (it = vlanConnection->egressPriorityMap.begin(); it != vlanConnection->egressPriorityMap.end(); ++it) {
						valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
					}
					if (valueList.count() > 0) settingsMap["egress-priority-map"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("vlan", dbusData, TRUE); else outerMap.remove("vlan");

		groupValid = false;
		dbusData = outerMap["serial"];
		if (connection->serialConfig.valid) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				settingsMap["baud"] = (TQT_DBusData::fromUInt32(connection->serialConfig.baudRate)).getAsVariantData();
				settingsMap["bits"] = (TQT_DBusData::fromUInt32(connection->serialConfig.byteWidth)).getAsVariantData();
				settingsMap["parity"] = (TQT_DBusData::fromByte(tdeParityToNMParity(connection->serialConfig.parity))).getAsVariantData();
				settingsMap["stopbits"] = (TQT_DBusData::fromUInt32(connection->serialConfig.stopBits)).getAsVariantData();
				settingsMap["send-delay"] = (TQT_DBusData::fromUInt64(connection->serialConfig.txDelay)).getAsVariantData();
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("serial", dbusData, TRUE); else outerMap.remove("serial");

		groupValid = false;
		dbusData = outerMap["ppp"];
		if (connection->pppConfig.valid) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				settingsMap["noauth"] = (TQT_DBusData::fromBool(!(connection->pppConfig.requireServerAuthentication))).getAsVariantData();
				settingsMap["refuse-eap"] = (TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableEAP)).getAsVariantData();
				settingsMap["refuse-pap"] = (TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisablePAP)).getAsVariantData();
				settingsMap["refuse-chap"] = (TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableCHAP)).getAsVariantData();
				settingsMap["refuse-mschap"] = (TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAP)).getAsVariantData();
				settingsMap["refuse-mschapv2"] = (TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAPv2)).getAsVariantData();
				settingsMap["nobsdcomp"] = (TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowBSDCompression))).getAsVariantData();
				settingsMap["nodeflate"] = (TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowDeflateCompression))).getAsVariantData();
				settingsMap["no-vj-comp"] = (TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowVJCompression))).getAsVariantData();
				settingsMap["require-mppe"] = (TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE)).getAsVariantData();
				settingsMap["require-mppe-128"] = (TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE128)).getAsVariantData();
				settingsMap["mppe-stateful"] = (TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::StatefulMPPE)).getAsVariantData();
				settingsMap["crtscts"] = (TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::UseHardwareFlowControl)).getAsVariantData();
				settingsMap["baud"] = (TQT_DBusData::fromUInt32(connection->pppConfig.baudRate)).getAsVariantData();
				if (connection->pppConfig.mru > 0) {
					settingsMap["mru"] = (TQT_DBusData::fromUInt32(connection->pppConfig.mru)).getAsVariantData();
				}
				else {
					settingsMap.remove("mru");
				}
				if (connection->pppConfig.mtu > 0) {
					settingsMap["mtu"] = (TQT_DBusData::fromUInt32(connection->pppConfig.mtu)).getAsVariantData();
				}
				else {
					settingsMap.remove("mtu");
				}
				if (connection->pppConfig.mtu > 0) {
					settingsMap["lcp-echo-interval"] = (TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoPingInterval)).getAsVariantData();
				}
				else {
					settingsMap.remove("lcp-echo-interval");
				}
				if (connection->pppConfig.mtu > 0) {
					settingsMap["lcp-echo-failure"] = (TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoFailureThreshold)).getAsVariantData();
				}
				else {
					settingsMap.remove("lcp-echo-failure");
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("ppp", dbusData, TRUE); else outerMap.remove("ppp");

		groupValid = false;
		dbusData = outerMap["pppoe"];
		if (connection->pppoeConfig.valid) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.networkServiceProvider, "service", settingsMap)
				UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.username, "username", settingsMap)
				if (connection->pppoeConfig.secretsValid) {
					UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.password, "password", settingsMap)
				}
				settingsMap["password-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->pppoeConfig.passwordFlags))).getAsVariantData();
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("pppoe", dbusData, TRUE); else outerMap.remove("pppoe");

		groupValid = false;
		dbusData = outerMap["802-11-olpc-mesh"];
		if (olpcMeshConnection) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				{
					unsigned int i;
					TQT_DBusDataValueList valueList;
					for (i=0; i<olpcMeshConnection->SSID.count(); i++) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->SSID[i]);
						valueList.append(innerDataValue);
					}
					settingsMap["ssid"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
				settingsMap["channel"] = (TQT_DBusData::fromUInt32(olpcMeshConnection->channel)).getAsVariantData();
				{
					unsigned int i;
					TQT_DBusDataValueList valueList;
					for (i=0; i<olpcMeshConnection->anycastDHCPHWAddress.count(); i++) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->anycastDHCPHWAddress[i]);
						valueList.append(innerDataValue);
					}
					settingsMap["dhcp-anycast-address"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("802-11-olpc-mesh", dbusData, TRUE); else outerMap.remove("802-11-olpc-mesh");

		groupValid = false;
		dbusData = outerMap["bluetooth"];
		if (bluetoothConnection) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				if (connection->lockedHWAddress.isValid()) {
					TDENetworkByteList address = connection->lockedHWAddress.address();
					TQT_DBusDataValueList valueList;
					TDENetworkByteList::iterator it;
					for (it = address.begin(); it != address.end(); ++it) {
						TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
						valueList.append(innerDataValue);
					}
					TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
					settingsMap["bdaddr"] = (nmHWAddress).getAsVariantData();
				}
				else {
					settingsMap.remove("bdaddr");
				}
				UPDATE_STRING_SETTING_IF_VALID(tdeBluetoothModeToNMBluetoothMode(bluetoothConnection->type), "type", settingsMap)
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("bluetooth", dbusData, TRUE); else outerMap.remove("bluetooth");

		groupValid = false;
		dbusData = outerMap["cdma"];
		if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::CDMA)) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.providerDataNumber, "number", settingsMap)
				UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.username, "username", settingsMap)
				if (connection->pppoeConfig.secretsValid) {
					UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.password, "password", settingsMap)
				}
				settingsMap["password-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->cdmaConfig.passwordFlags))).getAsVariantData();
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("cdma", dbusData, TRUE); else outerMap.remove("cdma");

		groupValid = false;
		dbusData = outerMap["gsm"];
		if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::GSM)) {
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.providerDataNumber, "number", settingsMap)
				UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.username, "username", settingsMap)
				if (connection->pppoeConfig.secretsValid) {
					UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.password, "password", settingsMap)
				}
				settingsMap["password-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.passwordFlags))).getAsVariantData();
				UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.accessPointName, "apn", settingsMap)
				UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.networkID, "network-id", settingsMap)
				settingsMap["network-type"] = (TQT_DBusData::fromInt32(tdeGSMModeToNMGSMMode(modemConnection->gsmConfig.networkType))).getAsVariantData();
				if (connection->pppoeConfig.secretsValid) {
					UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.pin, "pin", settingsMap)
				}
				settingsMap["pin-flags"] = (TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.pinFlags))).getAsVariantData();
				settingsMap["allowed-bands"] = (TQT_DBusData::fromUInt32(modemConnection->gsmConfig.allowedFrequencyBands)).getAsVariantData();
				settingsMap["home-only"] = (TQT_DBusData::fromBool(!(modemConnection->gsmConfig.allowRoaming))).getAsVariantData();
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("gsm", dbusData, TRUE); else outerMap.remove("gsm");

		groupValid = false;
		dbusData = outerMap["ipv4"];
		{
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				{
					TQT_DBusDataValueList valueList;
					TDENetworkSingleIPConfigurationList::iterator it;
					for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
						if ((*it).isIPv4()) {
							TQT_DBusDataValueList innerValueList;
							// WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
							// Address
							innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
							// Netmask
							innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
							// Gateway
							innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
							valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
						}
					}
					if (valueList.count() <= 0) {
						// Create an empty list with the correct DBUS type structure
						TQT_DBusData valueList;
						valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
						settingsMap["addresses"] = (TQT_DBusData::fromList(TQT_DBusDataList(valueList))).getAsVariantData();
					}
					else {
						settingsMap["addresses"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					}
				}
				{
					if (!connection->ipConfig.dhcpClientIdentifier.isNull()) {
						settingsMap["dhcp-client-id"] = (TQT_DBusData::fromString(connection->ipConfig.dhcpClientIdentifier)).getAsVariantData();
					}
				}
				{
					TQT_DBusDataValueList valueList;
					TDENetworkAddressList::iterator it;
					for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
						if ((*it).isIPv4Address()) {
							valueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).toIPv4Address())));
						}
					}
					if (valueList.count() <= 0) {
						// Create an empty list with the correct DBUS type structure
						settingsMap["dns"] = (TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32))).getAsVariantData();
					}
					else {
						settingsMap["dns"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					}
				}
				{
					TQT_DBusDataValueList valueList;
					TDENetworkSearchDomainList::iterator it;
					for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
						if ((*it).isIPv4()) {
							valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
						}
					}
					if (valueList.count() > 0) settingsMap["dns-search"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
				{
					settingsMap["ignore-auto-dns"] = (TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS))).getAsVariantData();
				}
				{
					settingsMap["may-fail"] = (TQT_DBusData::fromBool(!connection->requireIPV4)).getAsVariantData();
				}
				{
					TQString method;
					if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP) {
						method = "auto";
					}
					else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4LocalOnly) {
						method = "link-local";
					}
					else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer) {
						method = "shared";
					}
					else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4Disabled) {
						method = "disabled";
					}
					else {
						method = "manual";
					}
					if (!method.isNull())
						settingsMap["method"] = (TQT_DBusData::fromString(method)).getAsVariantData();
				}
				{
					settingsMap["ignore-auto-routes"] = (TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPRoutes))).getAsVariantData();
				}
				{
					settingsMap["never-default"] = (TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute))).getAsVariantData();
				}
				{
					TQT_DBusDataValueList valueList;
					TDENetworkSingleRouteConfigurationList::iterator it;
					for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
						if ((*it).isIPv4()) {
							TQT_DBusDataValueList innerValueList;
							// WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
							// Address
							innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
							// Netmask
							innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
							// Gateway
							innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
							// Metric
							innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
							valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
						}
					}
					if (valueList.count() <= 0) {
						// Create an empty list with the correct DBUS type structure
						TQT_DBusData valueList;
						valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
						settingsMap["routes"] = (TQT_DBusData::fromList(TQT_DBusDataList(valueList))).getAsVariantData();
					}
					else {
						settingsMap["routes"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					}
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("ipv4", dbusData, TRUE); else outerMap.remove("ipv4");

		groupValid = false;
		dbusData = outerMap["ipv6"];
		{
			TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
			{
				{
					TQT_DBusDataValueList valueList;
					TDENetworkSingleIPConfigurationList::iterator it;
					for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
						if ((*it).isIPv6()) {
							int i;
							Q_IPV6ADDR v6address;
							TQT_DBusDataValueList innerValueList;
							TQT_DBusDataValueList innerMostValueList;
							// WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
							// Address
							innerMostValueList.clear();
							v6address = (*it).ipAddress.toIPv6Address();
							for (i=0; i<16; i++) {
								innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
							}
							innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
							// Netmask
							innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
							// Gateway
							innerMostValueList.clear();
							v6address = (*it).gateway.toIPv6Address();
							for (i=0; i<16; i++) {
								innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
							}
							innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
							valueList.append(TQT_DBusData::fromStruct(innerValueList));
						}
					}
					if (valueList.count() <= 0) {
						// Create an empty list with the correct DBUS type structure
						TQT_DBusDataValueList innerValueList;
						TQT_DBusDataValueList innerMostValueList;
						// WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
						// Address
						innerMostValueList.clear();
						innerMostValueList.append(TQT_DBusData::fromByte(0));
						innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
						// Netmask
						innerValueList.append(TQT_DBusData::fromUInt32(0));
						// Gateway
						innerMostValueList.clear();
						innerMostValueList.append(TQT_DBusData::fromByte(0));
						innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
						settingsMap["addresses"] = (TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList)))).getAsVariantData();
					}
					else {
						settingsMap["addresses"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					}
				}
				{
					TQT_DBusDataValueList valueList;
					TDENetworkAddressList::iterator it;
					for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
						if ((*it).isIPv6Address()) {
							int i;
							Q_IPV6ADDR v6address;
							TQT_DBusDataValueList innerValueList;
							v6address = (*it).toIPv6Address();
							for (i=0; i<16; i++) {
								innerValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
							}
							valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
						}
					}
					if (valueList.count() <= 0) {
						// Create an empty list with the correct DBUS type structure
						TQT_DBusData valueList;
						valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::Byte));
						settingsMap["dns"] = (TQT_DBusData::fromList(TQT_DBusDataList(valueList))).getAsVariantData();
					}
					else {
						settingsMap["dns"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					}
				}
				{
					TQT_DBusDataValueList valueList;
					TDENetworkSearchDomainList::iterator it;
					for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
						if ((*it).isIPv6()) {
							valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
						}
					}
					if (valueList.count() > 0) settingsMap["dns-search"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
				}
				{
					settingsMap["ignore-auto-dns"] = (TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS))).getAsVariantData();
				}
				{
					settingsMap["may-fail"] = (TQT_DBusData::fromBool(!connection->requireIPV6)).getAsVariantData();
				}
				{
					TQString method;
					if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP) {
						method = "auto";
					}
					else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6LocalOnly) {
						method = "link-local";
					}
					else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer) {
						method = "shared";
					}
					else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6Disabled) {
						method = "ignore";
					}
					else {
						method = "manual";
					}
					if (!method.isNull())
						settingsMap["method"] = (TQT_DBusData::fromString(method)).getAsVariantData();
				}
				{
					settingsMap["ignore-auto-routes"] = (TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPRoutes))).getAsVariantData();
				}
				{
					settingsMap["never-default"] = (TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute))).getAsVariantData();
				}
				{
					TQT_DBusDataValueList valueList;
					TDENetworkSingleRouteConfigurationList::iterator it;
					for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
						if ((*it).isIPv6()) {
							int i;
							Q_IPV6ADDR v6address;
							TQT_DBusDataValueList innerValueList;
							TQT_DBusDataValueList innerMostValueList;
							// WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
							// Address
							innerMostValueList.clear();
							v6address = (*it).ipAddress.toIPv6Address();
							for (i=0; i<16; i++) {
								innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
							}
							innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
							// Netmask
							innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
							// Gateway
							innerMostValueList.clear();
							v6address = (*it).gateway.toIPv6Address();
							for (i=0; i<16; i++) {
								innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
							}
							innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
							// Metric
							innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
							valueList.append(TQT_DBusData::fromStruct(innerValueList));
						}
					}
					if (valueList.count() <= 0) {
						// Create an empty list with the correct DBUS type structure
						TQT_DBusDataValueList innerValueList;
						TQT_DBusDataValueList innerMostValueList;
						// WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
						// Address
						innerMostValueList.clear();
						innerMostValueList.append(TQT_DBusData::fromByte(0));
						innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
						// Netmask
						innerValueList.append(TQT_DBusData::fromUInt32(0));
						// Gateway
						innerMostValueList.clear();
						innerMostValueList.append(TQT_DBusData::fromByte(0));
						innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
						// Metric
						innerValueList.append(TQT_DBusData::fromUInt32(0));
						settingsMap["routes"] = (TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList)))).getAsVariantData();
					}
					else {
						settingsMap["routes"] = (TQT_DBusData::fromTQValueList(valueList)).getAsVariantData();
					}
				}
			}
			dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
			groupValid = (settingsMap.count() > 0);
		}
		if (groupValid) outerMap.insert("ipv6", dbusData, TRUE); else outerMap.remove("ipv6");
	}
	connectionSettingsMap = TQT_DBusDataMap<TQString>(outerMap);

	// If existing==true, a connection already existed and simply needs to be updated
	// If existing==false, a new connection must be created
	// To update: Use 'DBus::ConnectionSettingsInterface' with the connection path 'existingConnection' and call 'virtual bool UpdateAsync(int& asyncCallId, const TQT_DBusDataMap<TQString>& properties, TQT_DBusError& error);'
	// To create new: Use 'd->m_networkManagerSettings' and call 'virtual bool AddConnectionAsync(int& asyncCallId, const TQT_DBusDataMap<TQString>& connection, TQT_DBusError& error);'

#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
	printf("[network-manager comm debug] uploaded DBUS object structure map follows:\n"); fflush(stdout);
	printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS

	if (existing) {
#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
		printf("[network-manager comm debug] Updating existing connection\n"); fflush(stdout);
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
		// Save connection settings to the path specified
		DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
		connectionSettings.setConnection(TQT_DBusConnection::systemBus());
		connect(&connectionSettings, SIGNAL(UpdateAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
		int asyncCallID;
		ret = connectionSettings.UpdateAsync(asyncCallID, connectionSettingsMap, error);
		if (ret && error.isValid()) {
			ret = 0;
			PRINT_ERROR((error.name() + ": " + error.message()))
		}
		if (ret) {
			// Wait for the asynchronous call to return...
			d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
			TQTimer nmCallTimeoutTimer;
			nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
			while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
				tqApp->processEvents();
				if (!nmCallTimeoutTimer.isActive()) {
					PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
					timed_out = true;
					break;
				}
			}
			d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
			return !timed_out;
		}
		else {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
			return FALSE;
		}
	}
	else {
#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
		printf("[network-manager comm debug] Creating new connection\n"); fflush(stdout);
#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
		// Create new connection
		connect(d->m_networkManagerSettings, SIGNAL(AddConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
		connect(d->m_networkManagerSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
		int asyncCallID;
		ret = d->m_networkManagerSettings->AddConnectionAsync(asyncCallID, connectionSettingsMap, error);
		if (ret && error.isValid()) {
			ret = 0;
			PRINT_ERROR((error.name() + ": " + error.message()))
		}
		if (ret) {
			// Wait for the asynchronous call to return...
			d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
			TQTimer nmCallTimeoutTimer;
			nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
			while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
				if (!nmCallTimeoutTimer.isActive()) {
					PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
					timed_out = true;
					break;
				}
				tqApp->processEvents();
			}
			if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
				PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
				d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
			}
			if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
				PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
				command_failed = true;
			}
			d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
			if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
				d->nmAddConnectionAsyncResponse.remove(asyncCallID);
			}
			return ((!timed_out) && (!command_failed));
		}
		else {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
			return FALSE;
		}
	}
}

bool TDENetworkConnectionManager_BackendNM::deleteConnection(TQString uuid) {
	TQT_DBusObjectPath existingConnection;
	TQT_DBusError error;
	bool timed_out = false;
	bool ret;
	if (d->m_networkManagerSettings) {
		ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
		if (ret) {
			// Obtain connection secrets from the path specified
			DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
			connectionSettings.setConnection(TQT_DBusConnection::systemBus());
			connect(&connectionSettings, SIGNAL(DeleteAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
			int asyncCallID;
			ret = connectionSettings.DeleteAsync(asyncCallID, error);
			if (ret && error.isValid()) {
				ret = 0;
				PRINT_ERROR((error.name() + ": " + error.message()))
			}
			if (ret) {
				// Wait for the asynchronous call to return...
				d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
				TQTimer nmCallTimeoutTimer;
				nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
				while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
					tqApp->processEvents();
					if (!nmCallTimeoutTimer.isActive()) {
						PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
						timed_out = true;
						break;
					}
				}
				d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
				return !timed_out;
			}
			else {
				PRINT_ERROR(TQString("Unable to remove connection with uuid '%1'").arg(uuid))
				return FALSE;
			}
		}
		else {
			PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
			return FALSE;
		}
	}
	else {
		PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
		return FALSE;
	}
}

bool TDENetworkConnectionManager_BackendNM::verifyConnectionSettings(TDENetworkConnection* connection, TDENetworkConnectionErrorFlags::TDENetworkConnectionErrorFlags* type, TDENetworkErrorStringMap* reason) {
	// FIXME
	// This should actually attempt to validate all the settings!

	if (!connection) {
		return false;
	}

	if (connection->friendlyName == "") {
		if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidConnectionSetting] = i18n("Connection name is invalid");
		if (type) *type |= TDENetworkConnectionErrorFlags::InvalidConnectionSetting;
		return false;
	}

	if (connection->ipConfig.valid) {
		// Iterate over all addresses
		TDENetworkSingleIPConfigurationList::iterator it;
		for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
			if ((*it).isIPv4()) {
				if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP)) {
					if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
						if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv4Setting] = i18n("IPv4 address is invalid");
						if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv4Setting;
						return false;
					}
				}
			}
			else if ((*it).isIPv6()) {
				if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP)) {
					if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
						if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv6Setting] = i18n("IPv6 address is invalid");
						if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv6Setting;
						return false;
					}
				}
			}
		}
	}

	TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
	if (wiFiConnection) {
		if (wiFiConnection->SSID.count() < 1) {
			if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessSetting] = i18n("No SSID provided");
			if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessSetting;
			return false;
		}
		if (wiFiConnection->securityRequired) {
			if (wiFiConnection->securitySettings.secretsValid) {
				if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WEP) || ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && ((wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Open) || (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Shared)))) {
					if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Hexadecimal) {
						if (wiFiConnection->securitySettings.wepKey0 != "") {
							if ((wiFiConnection->securitySettings.wepKey0.length() != 10) && (wiFiConnection->securitySettings.wepKey0.length() != 26)) {
								if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
								if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
								return false;
							}
						}
						if (wiFiConnection->securitySettings.wepKey1 != "") {
							if ((wiFiConnection->securitySettings.wepKey1.length() != 10) && (wiFiConnection->securitySettings.wepKey1.length() != 26)) {
								if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
								if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
								return false;
							}
						}
						if (wiFiConnection->securitySettings.wepKey2 != "") {
							if ((wiFiConnection->securitySettings.wepKey2.length() != 10) && (wiFiConnection->securitySettings.wepKey2.length() != 26)) {
								if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
								if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
								return false;
							}
						}
						if (wiFiConnection->securitySettings.wepKey3 != "") {
							if ((wiFiConnection->securitySettings.wepKey3.length() != 10) && (wiFiConnection->securitySettings.wepKey3.length() != 26)) {
								if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
								if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
								return false;
							}
						}
						if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
							if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
							if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
							return false;
						}
					}
					else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
						if (wiFiConnection->securitySettings.wepKey0 != "") {
							if ((wiFiConnection->securitySettings.wepKey0.length() != 5) && (wiFiConnection->securitySettings.wepKey0.length() != 13)) {
								if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
								if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
								return false;
							}
						}
						if (wiFiConnection->securitySettings.wepKey1 != "") {
							if ((wiFiConnection->securitySettings.wepKey1.length() != 5) && (wiFiConnection->securitySettings.wepKey1.length() != 13)) {
								if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
								if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
								return false;
							}
						}
						if (wiFiConnection->securitySettings.wepKey2 != "") {
							if ((wiFiConnection->securitySettings.wepKey2.length() != 5) && (wiFiConnection->securitySettings.wepKey2.length() != 13)) {
								if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
								if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
								return false;
							}
						}
						if (wiFiConnection->securitySettings.wepKey3 != "") {
							if ((wiFiConnection->securitySettings.wepKey3.length() != 5) && (wiFiConnection->securitySettings.wepKey3.length() != 13)) {
								if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
								if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
								return false;
							}
						}
						if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
							if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
							if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
							return false;
						}
					}
					else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
						if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
							if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
							if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
							return false;
						}
					}
				}
				else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::LEAP)) {
					if ((wiFiConnection->securitySettings.leapUsername.length() < 1) || (wiFiConnection->securitySettings.leapPassword.length() < 1)) {
						if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("LEAP username and/or password not provided");
						if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
						return false;
					}
				}
				else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAAdHoc) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAInfrastructure) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAEnterprise)) {
					if (wiFiConnection->securitySettings.psk.length() == 64) {
						// Verify that only hex characters are present in the string
						bool ok;
						wiFiConnection->securitySettings.psk.toULongLong(&ok, 16);
						if (!ok) {
							if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("Hexadecimal length PSK contains non-hexadecimal characters");
							if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
							return false;
						}
					}
					else if ((wiFiConnection->securitySettings.psk.length() < 8) || (wiFiConnection->securitySettings.psk.length() > 63)) {
						if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No PSK provided");
						if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
						return false;
					}
				}
			}
		}
	}

	return TRUE;
}

TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::initiateConnection(TQString uuid) {
	TQT_DBusObjectPath existingConnection;
	TQT_DBusError error;
	bool ret;
	if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
		ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
		if (ret) {
			if (!m_networkDevice) {
				d->m_dbusDeviceString = "/";
			}
			else {
				d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
			}
#ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
			TQT_DBusObjectPath active_connection;
			ret = d->m_networkManagerProxy->ActivateConnection(existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), active_connection, error);
			if (ret && error.isValid()) {
				ret = 0;
				PRINT_ERROR((error.name() + ": " + error.message()))
			}
			return checkConnectionStatus(uuid);
#else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
#ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
			connect(d->m_networkManagerProxy, SIGNAL(ActivateConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
			connect(d->m_networkManagerProxy, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
#endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
			int asyncCallID;
			ret = d->m_networkManagerProxy->ActivateConnectionAsync(asyncCallID, existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), error);
			if (ret && error.isValid()) {
				ret = 0;
				PRINT_ERROR((error.name() + ": " + error.message()))
			}
#ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
			if (ret) {
				// Wait for the asynchronous call to return...
				d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
				TQTimer nmCallTimeoutTimer;
				nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
				while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
					if (!nmCallTimeoutTimer.isActive()) {
						PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
						break;
					}
					tqApp->processEvents();
				}
				d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
				if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
					PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
					d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
				}
				if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
					PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
				}
				if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
					d->nmAddConnectionAsyncResponse.remove(asyncCallID);
				}
				return checkConnectionStatus(uuid);
			}
			else {
				// Error!
				PRINT_ERROR((error.name() + ": " + error.message()))
				return checkConnectionStatus(uuid);
			}
#else
			return checkConnectionStatus(uuid);
#endif
#endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
		}
		else {
			PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
			return TDENetworkConnectionStatus::Invalid;
		}
	}
	else {
		PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
		return TDENetworkConnectionStatus::Invalid;
	}
}

TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::checkConnectionStatus(TQString uuid) {
	TQT_DBusObjectPath existingConnection;
	TQT_DBusError error;
	if (d->m_networkManagerProxy) {
		TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
		TQT_DBusObjectPathList::iterator it;
		for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
			DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
			activeConnection.setConnection(TQT_DBusConnection::systemBus());
			if (activeConnection.getUuid(error) == uuid) {
				return nmDeviceStateToTDEDeviceState(activeConnection.getState(error));
			}
		}
		PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
		return TDENetworkConnectionStatus::Invalid;
	}
	else {
		PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
		return TDENetworkConnectionStatus::Invalid;
	}
}

TQCString TDENetworkConnectionManager_BackendNM::getActiveConnectionPath(TQString uuid) {
	TQT_DBusObjectPath existingConnection;
	TQT_DBusError error;
	if (d->m_networkManagerProxy) {
		TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
		TQT_DBusObjectPathList::iterator it;
		for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
			DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
			activeConnection.setConnection(TQT_DBusConnection::systemBus());
			if (activeConnection.getUuid(error) == uuid) {
				return (*it);
			}
		}
		PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
		return TQT_DBusObjectPath();
	}
	else {
		PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
		return TQT_DBusObjectPath();
	}
}

TQStringList TDENetworkConnectionManager_BackendNM::connectionPhysicalDeviceUUIDs(TQString uuid) {
	if (deviceType() == TDENetworkDeviceType::BackendOnly) {
		return TQStringList();
	}

	TQT_DBusObjectPath existingConnection;
	TQT_DBusError error;
	if (d->m_networkManagerProxy) {
		TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
		TQT_DBusObjectPathList::iterator it;
		TQStringList ret;
		for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
			DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
			activeConnection.setConnection(TQT_DBusConnection::systemBus());
			if (activeConnection.getUuid(error) == uuid) {
				TQValueList<TQT_DBusObjectPath> deviceList = activeConnection.getDevices(error);
				TQT_DBusObjectPathList::iterator it2;
				for (it2 = deviceList.begin(); it2 != deviceList.end(); ++it2) {
					TQString devUUID = tdeDeviceUUIDForGenericDevice(*it2);
					if (devUUID != "") {
						ret.append(devUUID);
					}
				}
			}
		}
		return ret;
	}
	else {
		PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
		return TQStringList();
	}
}

TDENetworkVPNTypeList TDENetworkConnectionManager_BackendNM::availableVPNTypes() {
	TDENetworkVPNTypeList ret;

	// Query NetworkManager to verify plugin availability before claiming support for a VPN type
	TQDir serviceDir(NM_PLUGIN_SERVICE_DIR, TQString(), TQDir::Name|TQDir::IgnoreCase, TQDir::Files);
	TQStringList services = serviceDir.entryList ().grep (".name", true);

	if (services.count () > 0) {
		// read in all available Services
		for (TQStringList::Iterator i = services.begin (); i != services.end (); ++i) {
			TQString service = NM_PLUGIN_SERVICE_DIR + TQString ("/") + *i;
			TDEConfig* tdeconfig = new TDEConfig (service, true, true, "config");
			tdeconfig->setGroup ("VPN Connection");

			TQString serviceName = tdeconfig->readEntry("name", TQString());
			serviceName = serviceName.lower();

			if (serviceName == "openvpn") {
				ret.append(TDENetworkVPNType::OpenVPN);
			}
			if (serviceName == "pptp") {
				ret.append(TDENetworkVPNType::PPTP);
			}
			if (serviceName == "strongswan") {
				ret.append(TDENetworkVPNType::StrongSwan);
			}
			if (serviceName == "vpnc") {
				ret.append(TDENetworkVPNType::VPNC);
			}

			delete tdeconfig;
		}
	}

	return ret;
}

TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::deactivateConnection(TQString uuid) {
	TQT_DBusObjectPath existingConnection;
	TQT_DBusError error;
	bool ret;
	if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
		existingConnection = getActiveConnectionPath(uuid);
		if (existingConnection.isValid()) {
			if (!m_networkDevice) {
				d->m_dbusDeviceString = "/";
			}
			else {
				d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
			}
#ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
			ret = d->m_networkManagerProxy->DeactivateConnection(existingConnection, error);
			if (ret && error.isValid()) {
				ret = 0;
				PRINT_ERROR((error.name() + ": " + error.message()))
			}
			return checkConnectionStatus(uuid);
#else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
#ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
			connect(d->m_networkManagerProxy, SIGNAL(DeactivateConnectionAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
#endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
			int asyncCallID;
			ret = d->m_networkManagerProxy->DeactivateConnectionAsync(asyncCallID, existingConnection, error);
			if (ret && error.isValid()) {
				ret = 0;
				PRINT_ERROR((error.name() + ": " + error.message()))
			}
#ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
			if (ret) {
				// Wait for the asynchronous call to return...
				d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
				TQTimer nmCallTimeoutTimer;
				nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
				while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
					if (!nmCallTimeoutTimer.isActive()) {
						PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
						break;
					}
					tqApp->processEvents();
				}
				d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
				return checkConnectionStatus(uuid);
			}
			else {
				// Error!
				PRINT_ERROR((error.name() + ": " + error.message()))
				return checkConnectionStatus(uuid);
			}
#else
			return checkConnectionStatus(uuid);
#endif
#endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
		}
		else {
			PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
			return TDENetworkConnectionStatus::Invalid;
		}
	}
	else {
		PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
		return TDENetworkConnectionStatus::Invalid;
	}
}

TQStringList TDENetworkConnectionManager_BackendNM::validSettings() {
	TQStringList ret;

	ret.append("TDENetworkSingleIPConfiguration::ipAddress");
	ret.append("TDENetworkSingleIPConfiguration::networkMask");
	ret.append("TDENetworkSingleIPConfiguration::gateway");

	ret.append("TDENetworkSingleRouteConfiguration::ipAddress");
	ret.append("TDENetworkSingleRouteConfiguration::networkMask");
	ret.append("TDENetworkSingleRouteConfiguration::gateway");

	ret.append("TDENetworkIEEE8021xConfiguration::valid");
	ret.append("TDENetworkIEEE8021xConfiguration::allowedValid");
	ret.append("TDENetworkIEEE8021xConfiguration::secretsValid");
	ret.append("TDENetworkIEEE8021xConfiguration::type");
	ret.append("TDENetworkIEEE8021xConfiguration::userName");
	ret.append("TDENetworkIEEE8021xConfiguration::anonymousUserName");
	ret.append("TDENetworkIEEE8021xConfiguration::pacFileName");
	ret.append("TDENetworkIEEE8021xConfiguration::caCertificate");
	ret.append("TDENetworkIEEE8021xConfiguration::additionalCAFilesPath");
	ret.append("TDENetworkIEEE8021xConfiguration::authServerCertSubjectMatch");
	ret.append("TDENetworkIEEE8021xConfiguration::alternateAuthServerCertSubjectMatch");
	ret.append("TDENetworkIEEE8021xConfiguration::clientCertificate");
	ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPVersion");
	ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPLabel");
	ret.append("TDENetworkIEEE8021xConfiguration::fastProvisioningFlags");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2NonEAPAuthMethod");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2EAPAuthMethod");
	ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2NonEAPMethods");
	ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2EAPMethods");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2CaCertificate");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2CaFilesPath");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2AuthServerCertSubjectMatch");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2AlternateAuthServerCertSubjectMatch");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2ClientCertificate");
	ret.append("TDENetworkIEEE8021xConfiguration::password");
	ret.append("TDENetworkIEEE8021xConfiguration::passwordFlags");
	ret.append("TDENetworkIEEE8021xConfiguration::binaryPassword");
	ret.append("TDENetworkIEEE8021xConfiguration::binaryPasswordFlags");
	ret.append("TDENetworkIEEE8021xConfiguration::privateKey");
	ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPassword");
	ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPasswordFlags");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKey");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPassword");
	ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPasswordFlags");
	ret.append("TDENetworkIEEE8021xConfiguration::forceSystemCaCertificates");

	ret.append("TDENetworkPPPConfiguration::valid");
	ret.append("TDENetworkPPPConfiguration::requireServerAuthentication");
	ret.append("TDENetworkPPPConfiguration::flags");
	ret.append("TDENetworkPPPConfiguration::baudRate");
	ret.append("TDENetworkPPPConfiguration::mru");
	ret.append("TDENetworkPPPConfiguration::mtu");
	ret.append("TDENetworkPPPConfiguration::lcpEchoPingInterval");
	ret.append("TDENetworkPPPConfiguration::lcpEchoFailureThreshold");

	ret.append("TDENetworkPPPOEConfiguration::valid");
	ret.append("TDENetworkPPPOEConfiguration::secretsValid");
	ret.append("TDENetworkPPPOEConfiguration::networkServiceProvider");
	ret.append("TDENetworkPPPOEConfiguration::username");
	ret.append("TDENetworkPPPOEConfiguration::password");
	ret.append("TDENetworkPPPOEConfiguration::passwordFlags");

	ret.append("TDENetworkSerialConfiguration::valid");
	ret.append("TDENetworkSerialConfiguration::baudRate");
	ret.append("TDENetworkSerialConfiguration::byteWidth");
	ret.append("TDENetworkSerialConfiguration::parity");
	ret.append("TDENetworkSerialConfiguration::stopBits");
	ret.append("TDENetworkSerialConfiguration::txDelay");

	ret.append("TDENetworkCDMAConfiguration::valid");
	ret.append("TDENetworkCDMAConfiguration::secretsValid");
	ret.append("TDENetworkCDMAConfiguration::providerDataNumber");
	ret.append("TDENetworkCDMAConfiguration::username");
	ret.append("TDENetworkCDMAConfiguration::password");
	ret.append("TDENetworkCDMAConfiguration::passwordFlags");

	ret.append("TDENetworkGSMConfiguration::valid");
	ret.append("TDENetworkGSMConfiguration::secretsValid");
	ret.append("TDENetworkGSMConfiguration::providerDataNumber");
	ret.append("TDENetworkGSMConfiguration::username");
	ret.append("TDENetworkGSMConfiguration::password");
	ret.append("TDENetworkGSMConfiguration::passwordFlags");
	ret.append("TDENetworkGSMConfiguration::accessPointName");
	ret.append("TDENetworkGSMConfiguration::networkID");
	ret.append("TDENetworkGSMConfiguration::networkType");
	ret.append("TDENetworkGSMConfiguration::pin");
	ret.append("TDENetworkGSMConfiguration::pinFlags");
	ret.append("TDENetworkGSMConfiguration::allowedFrequencyBands");
	ret.append("TDENetworkGSMConfiguration::allowRoaming");

	ret.append("TDENetworkWiFiSecurityConfiguration::valid");
	ret.append("TDENetworkWiFiSecurityConfiguration::secretsValid");
	ret.append("TDENetworkWiFiSecurityConfiguration::keyType");
	ret.append("TDENetworkWiFiSecurityConfiguration::authType");
	ret.append("TDENetworkWiFiSecurityConfiguration::wpaVersion");
	ret.append("TDENetworkWiFiSecurityConfiguration::cipher");
	ret.append("TDENetworkWiFiSecurityConfiguration::wepKey0");
	ret.append("TDENetworkWiFiSecurityConfiguration::wepKey1");
	ret.append("TDENetworkWiFiSecurityConfiguration::wepKey2");
	ret.append("TDENetworkWiFiSecurityConfiguration::wepKey3");
	ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyFlags");
	ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyIndex");
	ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyType");
	ret.append("TDENetworkWiFiSecurityConfiguration::allowedPairWiseCiphers");
	ret.append("TDENetworkWiFiSecurityConfiguration::allowedGroupWiseCiphers");
	ret.append("TDENetworkWiFiSecurityConfiguration::psk");
	ret.append("TDENetworkWiFiSecurityConfiguration::pskFlags");
	ret.append("TDENetworkWiFiSecurityConfiguration::leapUsername");
	ret.append("TDENetworkWiFiSecurityConfiguration::leapPassword");
	ret.append("TDENetworkWiFiSecurityConfiguration::leapPasswordFlags");

	ret.append("TDENetworkIPConfiguration::valid");
	ret.append("TDENetworkIPConfiguration::connectionFlags");
	ret.append("TDENetworkIPConfiguration::ipConfigurations");
	ret.append("TDENetworkIPConfiguration::routeConfigurations");
	ret.append("TDENetworkIPConfiguration::broadcast");
	ret.append("TDENetworkIPConfiguration::destination");
	ret.append("TDENetworkIPConfiguration::resolvers");
	ret.append("TDENetworkIPConfiguration::searchDomains");
	ret.append("TDENetworkIPConfiguration::dhcpClientIdentifier");

	ret.append("TDENetworkConnection::UUID");
	ret.append("TDENetworkConnection::friendlyName");
	ret.append("TDENetworkConnection::ipConfig");
	ret.append("TDENetworkConnection::lockedHWAddress");
	ret.append("TDENetworkConnection::manualHWAddress");
	ret.append("TDENetworkConnection::readOnly");
	ret.append("TDENetworkConnection::autoConnect");
	ret.append("TDENetworkConnection::fullDuplex");
	ret.append("TDENetworkConnection::requireIPV4");
	ret.append("TDENetworkConnection::requireIPV6");
	ret.append("TDENetworkConnection::mtu");
	ret.append("TDENetworkConnection::eapConfig");
	ret.append("TDENetworkConnection::pppConfig");
	ret.append("TDENetworkConnection::pppoeConfig");
	ret.append("TDENetworkConnection::serialConfig");
	ret.append("TDENetworkConnection::authorizedUsers");
	ret.append("TDENetworkConnection::masterConnectionUUID");
	ret.append("TDENetworkConnection::slaveType");
	ret.append("TDENetworkConnection::lastKnownConnection");

	ret.append("TDEWiFiConnection::SSID");
	ret.append("TDEWiFiConnection::operatingMode");
	ret.append("TDEWiFiConnection::bandRestriction");
	ret.append("TDEWiFiConnection::channelRestriction");
	ret.append("TDEWiFiConnection::bitRateRestriction");
	ret.append("TDEWiFiConnection::powerRestriction");
	ret.append("TDEWiFiConnection::accessPointRestriction");
	ret.append("TDEWiFiConnection::blacklistedBSSIDs");
	ret.append("TDEWiFiConnection::heardBSSIDs");
	ret.append("TDEWiFiConnection::isHiddenNetwork");
	ret.append("TDEWiFiConnection::securityRequired");
	ret.append("TDEWiFiConnection::securitySettings");

	ret.append("TDEWiredInfinibandConnection::transportMode");

	ret.append("TDEVPNConnection::vpnPluginID");
	ret.append("TDEVPNConnection::lockedUserName");
	ret.append("TDEVPNConnection::pluginData");
	ret.append("TDEVPNConnection::secretsValid");
	ret.append("TDEVPNConnection::pluginSecrets");

	ret.append("TDEWiMaxConnection::networkServiceProvider");

	ret.append("TDEVLANConnection::kernelName");
	ret.append("TDEVLANConnection::parentConnectionUUID");
	ret.append("TDEVLANConnection::vlanID");
	ret.append("TDEVLANConnection::vlanFlags");
	ret.append("TDEVLANConnection::ingressPriorityMap");
	ret.append("TDEVLANConnection::egressPriorityMap");

	ret.append("TDEOLPCMeshConnection::SSID");
	ret.append("TDEOLPCMeshConnection::channel");
	ret.append("TDEOLPCMeshConnection::anycastDHCPHWAddress");

	ret.append("TDEBluetoothConnection::type");

	ret.append("TDEModemConnection::type");
	ret.append("TDEModemConnection::cdmaConfig");
	ret.append("TDEModemConnection::gsmConfig");

	ret.append("TDEWiredInfinibandConnection::transportMode");

	return ret;
}

TDENetworkWiFiAPInfo* TDENetworkConnectionManager_BackendNM::getAccessPointDetails(TQString dbusPath) {
	if (dbusPath == "") {
		return NULL;
	}

	TDENetworkWiFiAPInfo* apInfo = new TDENetworkWiFiAPInfo;
	TQT_DBusError error;
	unsigned int index;
	DBus::AccessPointProxy accessPoint(NM_DBUS_SERVICE, dbusPath);
	accessPoint.setConnection(TQT_DBusConnection::systemBus());

	TQValueList<TQ_UINT8> nmSSID = accessPoint.getSsid(error);
	if (error.isValid()) {
		delete apInfo;
		return NULL;
	}
	TQValueList<TQ_UINT8>::iterator it;
	index = 0;
	for (it = nmSSID.begin(); it != nmSSID.end(); ++it) {
		apInfo->SSID.resize(index+1);
		apInfo->SSID[index] = (*it);
		index++;
	}

	apInfo->wpaFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getWpaFlags(error));
	apInfo->rsnFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getRsnFlags(error));
	apInfo->frequency = accessPoint.getFrequency(error);
	apInfo->BSSID.fromString(accessPoint.getHwAddress(error));
	apInfo->maxBitrate = accessPoint.getMaxBitrate(error);
	apInfo->signalQuality = (accessPoint.getStrength(error)/100.0);

	apInfo->valid = true;

	return apInfo;
}

TDENetworkHWNeighborList* TDENetworkConnectionManager_BackendNM::siteSurvey() {
	TQT_DBusError error;
	bool ret;

	TDENetworkDeviceType::TDENetworkDeviceType myDeviceType = deviceType();
	d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
	clearTDENetworkHWNeighborList();

	if (myDeviceType == TDENetworkDeviceType::WiFi) {
		DBus::WiFiDeviceProxy wiFiDevice(NM_DBUS_SERVICE, d->m_dbusDeviceString);
		wiFiDevice.setConnection(TQT_DBusConnection::systemBus());
		// FIXME
		// Should call wiFiDevice.RequestScanAsync first to rescan all access points
		TQT_DBusObjectPathList accessPoints;
		ret = wiFiDevice.GetAccessPoints(accessPoints, error);
		if (ret) {
			TQT_DBusObjectPathList::iterator it;
			for (it = accessPoints.begin(); it != accessPoints.end(); ++it) {
				TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(TQString(*it));
				if (apInfo) {
					m_hwNeighborList->append(apInfo);
					// Ensure that this AP is monitored for changes
					d->internalProcessWiFiAccessPointAdded(*it);
				}
			}
		}
	}

	return m_hwNeighborList;
}

bool TDENetworkConnectionManager_BackendNM::networkingEnabled() {
	if (d->m_networkManagerProxy) {
		bool ret;
		TQT_DBusError error;
		ret = d->m_networkManagerProxy->getNetworkingEnabled(error);
		if (error.isValid()) {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
			return FALSE;
		}
		else {
			return ret;
		}
	}
	else {
		return FALSE;
	}
}

bool TDENetworkConnectionManager_BackendNM::wiFiHardwareEnabled() {
	if (d->m_networkManagerProxy) {
		bool ret;
		TQT_DBusError error;
		ret = d->m_networkManagerProxy->getWirelessHardwareEnabled(error);
		if (error.isValid()) {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
			return FALSE;
		}
		else {
			return ret;
		}
	}
	else {
		return FALSE;
	}
}

bool TDENetworkConnectionManager_BackendNM::enableNetworking(bool enable) {
	// FIXME
	// Yes, this abuses the Sleep command
	// Is there a better way to do it?
	if (d->m_networkManagerProxy) {
		int asynccallid;
		TQT_DBusError error;
		d->m_networkManagerProxy->SleepAsync(asynccallid, !enable, error);
		if (error.isValid()) {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
			return FALSE;
		}
		else {
			// FIXME
			// Wait for async reply before returning...
			return TRUE;
		}
	}
	else {
		return FALSE;
	}
}

bool TDENetworkConnectionManager_BackendNM::enableWiFi(bool enable) {
	if (d->m_networkManagerProxy) {
		TQT_DBusError error;
		d->m_networkManagerProxy->setWirelessEnabled(enable, error);
		if (error.isValid()) {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
			return FALSE;
		}
		else {
			return TRUE;
		}
	}
	else {
		return FALSE;
	}
}

bool TDENetworkConnectionManager_BackendNM::wiFiEnabled() {
	if (d->m_networkManagerProxy) {
		bool ret;
		TQT_DBusError error;
		ret = d->m_networkManagerProxy->getWirelessEnabled(error);
		if (error.isValid()) {
			// Error!
			PRINT_ERROR((error.name() + ": " + error.message()))
			return FALSE;
		}
		else {
			return ret;
		}
	}
	else {
		return FALSE;
	}
}

TQStringList TDENetworkConnectionManager_BackendNM::defaultNetworkDevices() {
	// Cycle through all available connections and see which one is default, then find all devices for that connection...
	TQStringList ret;

	TQT_DBusObjectPath existingConnection;
	TQT_DBusError error;
	if (d->m_networkManagerProxy) {
		TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
		TQT_DBusObjectPathList::iterator it;
		for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
			DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
			activeConnection.setConnection(TQT_DBusConnection::systemBus());
			if (activeConnection.getDefault(error)) {
				// This is the default ipv4 connection
				TQString uuid = activeConnection.getUuid(error);
				TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
				for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
					ret.append(*it);
				}
			}
			else if (activeConnection.getDefault6(error)) {
				// This is the default ipv6 connection
				TQString uuid = activeConnection.getUuid(error);
				TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
				for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
					ret.append(*it);
				}
			}
		}
		return ret;
	}
	else {
		PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
		return TQStringList();
	}
}

TDENetworkConnectionManager_BackendNMPrivate::TDENetworkConnectionManager_BackendNMPrivate(TDENetworkConnectionManager_BackendNM* parent) : m_networkManagerProxy(NULL), m_networkManagerSettings(NULL), m_networkDeviceProxy(NULL), m_wiFiDeviceProxy(NULL), m_vpnProxy(NULL), nonReentrantCallActive(false), vpn_service_error_notified(false), device_autoconnect_error_notified(false), m_parent(parent), m_prevDeviceState(-1) {
	// Set up global signal handler
	m_dbusSignalConnection = new TQT_DBusConnection(TQT_DBusConnection::systemBus());
	m_dbusSignalReceiver = new TDENetworkConnectionManager_BackendNM_DBusSignalReceiver(this);
	m_dbusSignalConnection->connect(m_dbusSignalReceiver, TQT_SLOT(dbusSignal(const TQT_DBusMessage&)));
}

TDENetworkConnectionManager_BackendNMPrivate::~TDENetworkConnectionManager_BackendNMPrivate() {
	// Destroy global signal handler
	if (m_dbusSignalConnection) delete m_dbusSignalConnection;
	if (m_dbusSignalReceiver) delete m_dbusSignalReceiver;

	// Destroy proxy objects
	TQMap<TQString, DBus::AccessPointProxy*>::iterator it;
	for (it = m_accessPointProxyList.begin(); it != m_accessPointProxyList.end(); ++it) {
		DBus::AccessPointProxy *apProxy = it.data();
		if (apProxy) {
			delete apProxy;
		}
	}
	m_accessPointProxyList.clear();
}

#include "network-manager.moc"
#include "network-manager_p.moc"