diff options
Diffstat (limited to 'tdecore')
| -rw-r--r-- | tdecore/CMakeLists.txt | 11 | ||||
| -rw-r--r-- | tdecore/networkbackends/network-manager/dbus/CMakeLists.txt | 7 | ||||
| -rw-r--r-- | tdecore/networkbackends/network-manager/network-manager.cpp | 2482 | ||||
| -rw-r--r-- | tdecore/networkbackends/network-manager/network-manager.h | 106 | ||||
| -rw-r--r-- | tdecore/networkbackends/network-manager/network-manager_p.h | 83 | ||||
| -rw-r--r-- | tdecore/tdehardwaredevices.cpp | 13 | ||||
| -rw-r--r-- | tdecore/tdenetworkconnections.cpp | 351 | ||||
| -rw-r--r-- | tdecore/tdenetworkconnections.h | 395 |
8 files changed, 3363 insertions, 85 deletions
diff --git a/tdecore/CMakeLists.txt b/tdecore/CMakeLists.txt index a684dc59c..2e00d6afa 100644 --- a/tdecore/CMakeLists.txt +++ b/tdecore/CMakeLists.txt @@ -22,7 +22,15 @@ endif( WITH_LIBART ) if( WITH_NETWORK_MANAGER_BACKEND ) add_subdirectory( networkbackends/network-manager/dbus ) - set ( TDENM_LIBRARIES tdenm_dbus-static ) + set ( TDENM_INCLUDE_DIRECTORIES + ${DBUS_TQT_INCLUDE_DIRS} + ${NM_UTIL_INCLUDE_DIRS} + "${CMAKE_BINARY_DIR}/tdecore/networkbackends/network-manager/dbus" + ) + set ( TDENM_LIBRARIES + tdenm_dbus-static + ${DBUS_TQT_LIBRARIES} + ) set ( TDENM_BACKEND_SOURCES networkbackends/network-manager/network-manager.cpp ) endif( WITH_NETWORK_MANAGER_BACKEND ) @@ -41,6 +49,7 @@ include_directories( ${LIBART_INCLUDE_DIRS} ${LIBIDN_INCLUDE_DIRS} ${GAMIN_INCLUDEDIR} + ${TDENM_INCLUDE_DIRECTORIES} ) link_directories( diff --git a/tdecore/networkbackends/network-manager/dbus/CMakeLists.txt b/tdecore/networkbackends/network-manager/dbus/CMakeLists.txt index e179dad3e..0739a85d8 100644 --- a/tdecore/networkbackends/network-manager/dbus/CMakeLists.txt +++ b/tdecore/networkbackends/network-manager/dbus/CMakeLists.txt @@ -46,14 +46,15 @@ add_dbus_xml( p accesspointproxy AccessPointProxy DBus nm-access-point.xml ) add_dbus_xml( p activeconnectionproxy ActiveConnectionProxy DBus nm-active-connection.xml ) add_dbus_xml( p vpnconnectionproxy VPNConnectionProxy DBus nm-vpn-connection.xml ) add_dbus_xml( p vpnpluginproxy VPNPluginProxy DBus nm-vpn-plugin.xml ) -add_dbus_xml( i networkmanagersettings SettingsInterface DBus nm-settings.xml ) -add_dbus_xml( i connectionsettings ConnectionSettingsInterface DBus nm-settings-connection.xml ) +add_dbus_xml( p networkmanagersettings SettingsInterface DBus nm-settings.xml ) +add_dbus_xml( p connectionsettings ConnectionSettingsInterface DBus nm-settings-connection.xml ) # generate moc files set( MOCHEADERS accesspointproxy.h deviceproxy.h networkmanagerproxy.h networkmanagerpppproxy.h ethernetproxy.h - infinibandproxy.h wifiproxy.h wimaxproxy.h activeconnectionproxy.h vpnconnectionproxy.h vpnpluginproxy.h modemproxy.h ) + infinibandproxy.h wifiproxy.h wimaxproxy.h activeconnectionproxy.h vpnconnectionproxy.h vpnpluginproxy.h modemproxy.h + networkmanagersettings.h connectionsettings.h ) foreach( _header_file ${MOCHEADERS} ) get_filename_component( _basename "${_header_file}" NAME_WE ) diff --git a/tdecore/networkbackends/network-manager/network-manager.cpp b/tdecore/networkbackends/network-manager/network-manager.cpp index fcd2f8abc..80225c1a7 100644 --- a/tdecore/networkbackends/network-manager/network-manager.cpp +++ b/tdecore/networkbackends/network-manager/network-manager.cpp @@ -17,57 +17,2505 @@ */ #include "network-manager.h" +#include "network-manager_p.h" + +#define PRINT_ERROR(x) printf("[TDE NM Backend ERROR] %s\n\r", x.ascii()); +#define UPDATE_STRING_SETTING_IF_VALID(string, key, settingsMap) if (!string.isNull()) settingsMap[key] = convertDBUSDataToVariantData(TQT_DBusData::fromString(string)); \ + else settingsMap.remove(key); + +#define NM_ASYNC_TIMEOUT_MS 1000 + +#define DEBUG_NETWORK_MANAGER_COMMUNICATIONS + +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; +} + +TQT_DBusData convertDBUSDataToVariantData(TQT_DBusData object) { + TQT_DBusVariant variant; + variant.value = object; + variant.signature = variant.value.buildDBusSignature(); + return TQT_DBusData::fromVariant(variant); +} + +void printDBUSObjectStructure(TQT_DBusData object, int level=0) { + int i; + TQString levelIndent = ""; + for (i=0; i<level; i++) { + levelIndent = levelIndent + " "; + } + TQCString signature = object.buildDBusSignature(); + printf("%s%s\n\r", 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); + } + } + 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); + } +} + +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; +} + +TDENetworkConnectionStatus::TDENetworkConnectionStatus nmDeviceStateToTDEDeviceState(TQ_UINT32 nmType) { + TDENetworkConnectionStatus::TDENetworkConnectionStatus ret = TDENetworkConnectionStatus::Invalid; + + 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; +} + +TDENetworkConnectionType::TDENetworkConnectionType TDENetworkConnectionManager_BackendNM::nmDeviceTypeToTDEDeviceType(TQ_UINT32 nmType) { + TDENetworkConnectionType::TDENetworkConnectionType ret = TDENetworkConnectionType::Other; + + if (nmType == NM_DEVICE_TYPE_UNKNOWN) { + ret = TDENetworkConnectionType::Other; + } + else if (nmType == NM_DEVICE_TYPE_ETHERNET) { + ret = TDENetworkConnectionType::WiredEthernet; + } + else if (nmType == NM_DEVICE_TYPE_WIFI) { + ret = TDENetworkConnectionType::WiFi; + } + else if (nmType == NM_DEVICE_TYPE_UNUSED1) { + } + else if (nmType == NM_DEVICE_TYPE_UNUSED2) { + } + else if (nmType == NM_DEVICE_TYPE_BT) { + ret = TDENetworkConnectionType::Bluetooth; + } + else if (nmType == NM_DEVICE_TYPE_OLPC_MESH) { + ret = TDENetworkConnectionType::OLPCMesh; + } + else if (nmType == NM_DEVICE_TYPE_WIMAX) { + ret = TDENetworkConnectionType::WiMax; + } + else if (nmType == NM_DEVICE_TYPE_MODEM) { + ret = TDENetworkConnectionType::Modem; + } + else if (nmType == NM_DEVICE_TYPE_INFINIBAND) { + ret = TDENetworkConnectionType::Infiniband; + } + else if (nmType == NM_DEVICE_TYPE_BOND) { + ret = TDENetworkConnectionType::Bond; + } + else if (nmType == NM_DEVICE_TYPE_VLAN) { + ret = TDENetworkConnectionType::VLAN; + } + else if (nmType == NM_DEVICE_TYPE_ADSL) { + ret = TDENetworkConnectionType::ADSL; + } + + 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; +} + +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; +} + +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; +} + +TQString TDENetworkConnectionManager_BackendNM::deviceInterfaceString(TQString macAddress) { + 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()); + TDENetworkConnectionType::TDENetworkConnectionType deviceType = nmDeviceTypeToTDEDeviceType(genericDevice.getDeviceType(error)); + if (error.isValid()) { + // Error! + PRINT_ERROR(error.name()) + break; + } + else if (deviceType == TDENetworkConnectionType::WiredEthernet) { + DBus::EthernetDeviceProxy ethernetDevice(NM_DBUS_SERVICE, (*it)); + ethernetDevice.setConnection(TQT_DBusConnection::systemBus()); + TQString candidateMACAddress = ethernetDevice.getPermHwAddress(error); + if (!error.isValid()) { + if (candidateMACAddress.lower() == macAddress.lower()) { + return (*it); + } + } + } + else if (deviceType == TDENetworkConnectionType::WiFi) { + DBus::WiFiDeviceProxy wiFiDevice(NM_DBUS_SERVICE, (*it)); + wiFiDevice.setConnection(TQT_DBusConnection::systemBus()); + TQString candidateMACAddress = wiFiDevice.getPermHwAddress(error); + if (!error.isValid()) { + if (candidateMACAddress.lower() == macAddress.lower()) { + return (*it); + } + } + } + // FIXME + // Add other supported device types here + } + return ""; + } + else { + // Error! + PRINT_ERROR(error.name()) + return ""; + } + } + else { + return ""; + } +} TDENetworkConnectionManager_BackendNM::TDENetworkConnectionManager_BackendNM(TQString macAddress) : TDENetworkConnectionManager(macAddress) { - // + d = new TDENetworkConnectionManager_BackendNMPrivate(); + + // 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()); + + TQString dbusDeviceString = deviceInterfaceString(macAddress); + if (dbusDeviceString != "") { + d->m_networkDeviceProxy = new DBus::DeviceProxy(NM_DBUS_SERVICE, dbusDeviceString); + d->m_networkDeviceProxy->setConnection(TQT_DBusConnection::systemBus()); + } + + // Connect global signals + connect(d->m_networkManagerProxy, SIGNAL(StateChanged(TQ_UINT32)), this, SLOT(internalProcessGlobalStateChanged(TQ_UINT32))); + + // Connect local signals + if (d->m_networkDeviceProxy) { + connect(d->m_networkDeviceProxy, SIGNAL(StateChanged(TQ_UINT32, TQ_UINT32, TQ_UINT32)), this, SLOT(internalProcessDeviceStateChanged(TQ_UINT32, TQ_UINT32, TQ_UINT32))); + } + + // Create public lists + m_connectionList = new TDENetworkConnectionList; + m_hwNeighborList = new TDENetworkHWNeighborList; } 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_BackendNM::internalProcessGlobalStateChanged(TQ_UINT32 state) { + internalNetworkConnectionStateChanged(nmGlobalStateToTDEGlobalState(state)); +} + +void TDENetworkConnectionManager_BackendNM::internalProcessDeviceStateChanged(TQ_UINT32 newState, TQ_UINT32 oldState, TQ_UINT32 reason) { + Q_UNUSED(oldState) + Q_UNUSED(reason) + internalNetworkDeviceStateChanged(nmDeviceStateToTDEDeviceState(newState), m_macAddress); } TDENetworkConnectionType::TDENetworkConnectionType TDENetworkConnectionManager_BackendNM::connectionType() { - // + if (m_macAddress == "") { + return TDENetworkConnectionType::BackendOnly; + } + else { + // Query NM for the device type + TQT_DBusError error; + TQString dbusDeviceString = deviceInterfaceString(m_macAddress); + DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, dbusDeviceString); + genericDevice.setConnection(TQT_DBusConnection::systemBus()); + TDENetworkConnectionType::TDENetworkConnectionType ret = nmDeviceTypeToTDEDeviceType(genericDevice.getDeviceType(error)); + if (error.isValid()) { + // Error! + PRINT_ERROR(error.name()) + return TDENetworkConnectionType::Other; + } + else { + return ret; + } + } } 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()) + return TDENetworkGlobalManagerFlags::Unknown; + } + else { + return nmGlobalStateToTDEGlobalState(ret); + } + } + else { + return TDENetworkGlobalManagerFlags::Unknown; + } } 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)); + // FIXME wiFiInfo is not filled in + 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_BackendNM::loadConnectionInformation() { - // + TDEMACAddress deviceMACAddress; + deviceMACAddress.fromString(m_macAddress); + + 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; + TDEWiFiConnection* wiFiConnection = NULL; + TDENetworkConnectionType::TDENetworkConnectionType connType = connectionType(); + if (connType == TDENetworkConnectionType::WiredEthernet) { + connection = ethernetConnection = new TDEWiredEthernetConnection; + } + if (connType == TDENetworkConnectionType::WiFi) { + connection = wiFiConnection = new TDEWiFiConnection; + } + 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; + +#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS + printf("[network-manager comm debug] %s\n\r", (*it).data()); fflush(stdout); +#endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS + + // 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>&))); + int asyncCallID; + ret = connectionSettings.GetSettingsAsync(asyncCallID, error); + if (ret && error.isValid()) { + ret = 0; + PRINT_ERROR(error.name()) + } + 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]; + d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID); + d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID); + +#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS + printf("[network-manager comm debug] received DBUS object structure map follows:\n\r"); 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\r", 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\r", 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\r", 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 (outerKeyValue.lower() == "802-1x") { + // FIXME + // Implement load+save of the remaining settings in this group! + 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() == "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; + TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList(); + TQT_DBusDataValueList::const_iterator it5; + 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; + TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList(); + TQT_DBusDataValueList::const_iterator it5; + 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; + } + } + 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); + } + } + } + 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; + } + } + 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); + } + } + } + } + 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())) { + connection->ipConfig.valid = true; + m_connectionList->append(connection); + } + } + else { + // Error! + PRINT_ERROR(error.name()) + } + } + } + else { + // Error! + PRINT_ERROR(error.name()) + } + } } -bool TDENetworkConnectionManager_BackendNM::saveConnection(TDENetworkConnection connection) { - // +// 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) { + bool ret = TRUE; + ret = ret && loadConnectionSecretsForGroup(uuid, "802-1x"); + return ret; } -bool TDENetworkConnectionManager_BackendNM::deleteConnection(TQString uuid) { - // +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; + } + TQT_DBusObjectPath existingConnection; + TQT_DBusError error; + bool ret; + TQT_DBusTQStringDataMap connectionSecretsMap(TQT_DBusData::String); + 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(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()) + } + 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; + } + } + connectionSecretsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID]; + d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID); + d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID); + +#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS + printf("[network-manager comm debug] received DBUS object structure map follows:\n\r"); 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\r", 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\r", 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\r", 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; + } + } + } + } + } + return TRUE; + } + else { + PRINT_ERROR(TQString("Unable to load secrets for connection with uuid '%1'").arg(uuid)) + return FALSE; + } + } + else { + PRINT_ERROR(TQString("connection for provided uuid '%1' was not found").arg(uuid)); + return FALSE; + } } -TDENetworkConnectionList* TDENetworkConnectionManager_BackendNM::connections() { - // +bool TDENetworkConnectionManager_BackendNM::saveConnection(TDENetworkConnection* connection) { + // 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 + if (!connection) { + PRINT_ERROR(TQString("connection cannot be NULL!")); + return FALSE; + } + 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) { + // 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()) + } + 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; + } + } + connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID]; + existing = true; + d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID); + d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID); + } + } + + // 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(); + { + dbusData = outerMap["connection"]; + { + TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap(); + { + settingsMap["id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->friendlyName)); + { + TQString type; + if (dynamic_cast<TDEWiredEthernetConnection*>(connection)) type = "802-3-ethernet"; + else if (dynamic_cast<TDEWiFiConnection*>(connection)) type = "802-11-wireless"; + if (!type.isNull()) settingsMap["type"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(type)); + } + settingsMap["uuid"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->UUID)); + } + dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap)); + groupValid = (settingsMap.count() > 0); + } + if (groupValid) outerMap.insert("connection", dbusData, TRUE); else outerMap.remove("connection"); + + dbusData = outerMap["802-1x"]; + { + TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap(); + { + if (connection->eapConfig.valid) { + TQT_DBusDataValueList valueList; + TDENetworkSingleIPConfigurationList::iterator it; + { + // 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + } + 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; + TDENetworkSingleIPConfigurationList::iterator it; + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + 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; + TDENetworkSingleIPConfigurationList::iterator it; + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + else settingsMap.remove("altsubject-matches"); + } + else { + settingsMap.remove("altsubject-matches"); + } + if (connection->eapConfig.valid) { + TQT_DBusDataValueList valueList; + TDENetworkSingleIPConfigurationList::iterator it; + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + 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) + UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2NonEAPAuthMethod, "phase2-auth", settingsMap) + UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2EAPAuthMethod, "phase2-autheap", settingsMap) + } + else { + settingsMap.remove("phase1-peapver"); + settingsMap.remove("phase1-peaplabel"); + settingsMap.remove("phase1-fast-provisioning"); + settingsMap.remove("phase2-auth"); + settingsMap.remove("phase2-autheap"); + } + if (connection->eapConfig.valid) { + TQT_DBusDataValueList valueList; + TDENetworkSingleIPConfigurationList::iterator it; + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + 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; + TDENetworkSingleIPConfigurationList::iterator it; + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + else settingsMap.remove("phase2-altsubject-matches"); + } + else { + settingsMap.remove("phase2-altsubject-matches"); + } + if (connection->eapConfig.valid) { + TQT_DBusDataValueList valueList; + TDENetworkSingleIPConfigurationList::iterator it; + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + else settingsMap.remove("phase2-client-cert"); + } + else { + settingsMap.remove("phase2-client-cert"); + } + if (connection->eapConfig.valid) { + settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.passwordFlags))); + settingsMap["password-raw-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.binaryPasswordFlags))); + } + else { + settingsMap.remove("password-flags"); + settingsMap.remove("password-raw-flags"); + } + if (connection->eapConfig.valid) { + TQT_DBusDataValueList valueList; + TDENetworkSingleIPConfigurationList::iterator it; + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + else settingsMap.remove("private-key"); + } + else { + settingsMap.remove("private-key"); + } + if (connection->eapConfig.valid) { + settingsMap["private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.privateKeyPasswordFlags))); + } + else { + settingsMap.remove("private-key-password-flags"); + } + if (connection->eapConfig.valid) { + TQT_DBusDataValueList valueList; + TDENetworkSingleIPConfigurationList::iterator it; + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + else settingsMap.remove("phase2-private-key"); + } + else { + settingsMap.remove("phase2-private-key"); + } + if (connection->eapConfig.valid) { + settingsMap["phase2-private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.phase2PrivateKeyPasswordFlags))); + } + else { + settingsMap.remove("phase2-private-key-password-flags"); + } + if (connection->eapConfig.valid) { + settingsMap["system-ca-certs"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->eapConfig.forceSystemCaCertificates)); + } + else { + settingsMap.remove("system-ca-certs"); + } + if (connection->eapConfig.secretsValid) { + settingsMap["password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.password)); + } + else { + settingsMap.remove("password"); + } + if (connection->eapConfig.valid) { + TQT_DBusDataValueList valueList; + TDENetworkSingleIPConfigurationList::iterator it; + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + else settingsMap.remove("password-raw"); + } + else { + settingsMap.remove("password-raw"); + } + if (connection->eapConfig.secretsValid) { + settingsMap["private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.privateKeyPassword)); + settingsMap["phase2-private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.phase2PrivateKeyPassword)); + } + 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"); + + dbusData = outerMap["802-3-ethernet"]; + { + TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap(); + { + settingsMap["duplex"] = convertDBUSDataToVariantData(TQT_DBusData::fromString((connection->fullDuplex)?"full":"half")); + 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"] = convertDBUSDataToVariantData(nmHWAddress); + } + 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"] = convertDBUSDataToVariantData(nmHWAddress); + } + else { + settingsMap.remove("mac-address"); + } + if (connection->mtu > 0) { + settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu)); + } + 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"); + + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList))); + } + else { + settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + } + } + { + if (!connection->ipConfig.dhcpClientIdentifier.isNull()) { + settingsMap["dhcp-client-id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->ipConfig.dhcpClientIdentifier)); + } + } + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32))); + } + else { + settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + } + } + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + } + { + settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS))); + } + { + settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV4)); + } + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method)); + } + { + settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPRoutes))); + } + { + settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute))); + } + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList))); + } + else { + settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + } + } + } + dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap)); + groupValid = (settingsMap.count() > 0); + } + if (groupValid) outerMap.insert("ipv4", dbusData, TRUE); else outerMap.remove("ipv4"); + + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList)))); + } + else { + settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + } + } + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList))); + } + else { + settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + } + } + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + } + { + settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS))); + } + { + settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV6)); + } + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method)); + } + { + settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPRoutes))); + } + { + settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute))); + } + { + 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"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList)))); + } + else { + settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList)); + } + } + } + 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\r"); 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\r"); 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()) + } + 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; + } + } + d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID); + return TRUE; + } + else { + // Error! + PRINT_ERROR(error.name()) + return FALSE; + } + } + else { +#ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS + printf("[network-manager comm debug] Creating new connection\n\r"); 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&))); + int asyncCallID; + ret = d->m_networkManagerSettings->AddConnectionAsync(asyncCallID, connectionSettingsMap, error); + if (ret && error.isValid()) { + ret = 0; + PRINT_ERROR(error.name()) + } + 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); + d->nmAddConnectionAsyncResponse.remove(asyncCallID); + return TRUE; + } + else { + // Error! + PRINT_ERROR(error.name()) + return FALSE; + } + } +} + +bool TDENetworkConnectionManager_BackendNM::deleteConnection(TQString uuid) { + TQT_DBusObjectPath existingConnection; + TQT_DBusError error; + 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()) + } + 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; + } + } + d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID); + return TRUE; + } + else { + PRINT_ERROR(TQString("Unable to remove connection with uuid '%1'").arg(uuid)) + return FALSE; + } + } + else { + PRINT_ERROR(TQString("connection for provided uuid '%1' was not found").arg(uuid)); + return FALSE; + } + } + else { + PRINT_ERROR(TQString("invalid internal network-manager settings proxy object").arg(uuid)); + return FALSE; + } } 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) { + TQString dbusDeviceString; + if (m_macAddress == "") { + dbusDeviceString = "/"; + } + else { + dbusDeviceString = deviceInterfaceString(m_macAddress); + } + connect(d->m_networkManagerProxy, SIGNAL(ActivateConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&))); + int asyncCallID; + ret = d->m_networkManagerProxy->ActivateConnectionAsync(asyncCallID, existingConnection, TQT_DBusObjectPath(dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), error); + if (ret && error.isValid()) { + ret = 0; + PRINT_ERROR(error.name()) + } + 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); + d->nmAddConnectionAsyncResponse.remove(asyncCallID); + return checkConnectionStatus(uuid); + } + else { + // Error! + PRINT_ERROR(error.name()) + return checkConnectionStatus(uuid); + } + } + else { + PRINT_ERROR(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").arg(uuid)); + 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_ERROR(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").arg(uuid)); + return TDENetworkConnectionStatus::Invalid; + } } TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::deactivateConnection(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) { + TQString dbusDeviceString; + if (m_macAddress == "") { + dbusDeviceString = "/"; + } + else { + dbusDeviceString = deviceInterfaceString(m_macAddress); + } + connect(d->m_networkManagerProxy, SIGNAL(DeactivateConnectionAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int))); + int asyncCallID; + ret = d->m_networkManagerProxy->DeactivateConnectionAsync(asyncCallID, existingConnection, error); + if (ret && error.isValid()) { + ret = 0; + PRINT_ERROR(error.name()) + } + 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()) + return checkConnectionStatus(uuid); + } + } + else { + PRINT_ERROR(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").arg(uuid)); + return TDENetworkConnectionStatus::Invalid; + } +} + +TDENetworkWiFiAPInfo* TDENetworkConnectionManager_BackendNM::getAccessPointDetails(TQString dbusPath) { + 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 = accessPoint.getHwAddress(error); + apInfo->maxBitrate = accessPoint.getMaxBitrate(error); + apInfo->signalQuality = (accessPoint.getStrength(error)/100.0); + + apInfo->valid = true; + + return apInfo; } TDENetworkHWNeighborList* TDENetworkConnectionManager_BackendNM::siteSurvey() { - // + // FIXME + // Implement this! + // WiFiDeviceProxy(const TQString& service, const TQString& path, TQObject* parent = 0, const char* name = 0); + // virtual bool GetAccessPoints(TQValueList<TQT_DBusObjectPath>& access_points, TQT_DBusError& error); + // deviceInterfaceString + + TQT_DBusError error; + bool ret; + + TDENetworkConnectionType::TDENetworkConnectionType deviceType = connectionType(); + TQString dbusDeviceString = deviceInterfaceString(m_macAddress); + clearTDENetworkHWNeighborList(); + + if (deviceType == TDENetworkConnectionType::WiFi) { + DBus::WiFiDeviceProxy wiFiDevice(NM_DBUS_SERVICE, 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); + } + } + } + } + + 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()) + 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()) + return FALSE; + } + else { + return ret; + } + } + 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()) + 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()) + return FALSE; + } + else { + return ret; + } + } + else { + return FALSE; + } } -#include "network-manager.moc"
\ No newline at end of file +#include "network-manager.moc" +#include "network-manager_p.moc"
\ No newline at end of file diff --git a/tdecore/networkbackends/network-manager/network-manager.h b/tdecore/networkbackends/network-manager/network-manager.h index 40dc725d4..f1fe36a8a 100644 --- a/tdecore/networkbackends/network-manager/network-manager.h +++ b/tdecore/networkbackends/network-manager/network-manager.h @@ -20,6 +20,90 @@ #include "tdenetworkconnections.h" +//==================================================================================================== +// General NetworkManager DBUS service paths +//==================================================================================================== +#define NM_DBUS_PATH "/org/freedesktop/NetworkManager" +#define NM_DBUS_PATH_SETTINGS "/org/freedesktop/NetworkManager/Settings" +#define NM_DBUS_PATH_SETTINGS_CONNECTION "/org/freedesktop/NetworkManager/Settings/Connection" + +#define NM_DBUS_SERVICE "org.freedesktop.NetworkManager" +#define NM_DBUS_SETTINGS_SERVICE "org.freedesktop.NetworkManager.Settings" +#define NM_DBUS_SETTINGS_CONNECTION_SERVICE "org.freedesktop.NetworkManager.Settings.Connection" +//==================================================================================================== + +//==================================================================================================== +// These defines MUST be kept in sync with their respective introspection XML files +//==================================================================================================== +#define NM_DEVICE_TYPE_UNKNOWN 0 +#define NM_DEVICE_TYPE_ETHERNET 1 +#define NM_DEVICE_TYPE_WIFI 2 +#define NM_DEVICE_TYPE_UNUSED1 3 +#define NM_DEVICE_TYPE_UNUSED2 4 +#define NM_DEVICE_TYPE_BT 5 +#define NM_DEVICE_TYPE_OLPC_MESH 6 +#define NM_DEVICE_TYPE_WIMAX 7 +#define NM_DEVICE_TYPE_MODEM 8 +#define NM_DEVICE_TYPE_INFINIBAND 9 +#define NM_DEVICE_TYPE_BOND 10 +#define NM_DEVICE_TYPE_VLAN 11 +#define NM_DEVICE_TYPE_ADSL 12 +//==================================================================================================== +#define NM_STATE_UNKNOWN 0 +#define NM_STATE_ASLEEP 10 +#define NM_STATE_DISCONNECTED 20 +#define NM_STATE_DISCONNECTING 30 +#define NM_STATE_CONNECTING 40 +#define NM_STATE_CONNECTED_LOCAL 50 +#define NM_STATE_CONNECTED_SITE 60 +#define NM_STATE_CONNECTED_GLOBAL 70 +//==================================================================================================== +#define NM_DEVICE_STATE_UNKNOWN 0 +#define NM_DEVICE_STATE_UNMANAGED 10 +#define NM_DEVICE_STATE_UNAVAILABLE 20 +#define NM_DEVICE_STATE_DISCONNECTED 30 +#define NM_DEVICE_STATE_PREPARE 40 +#define NM_DEVICE_STATE_CONFIG 50 +#define NM_DEVICE_STATE_NEED_AUTH 60 +#define NM_DEVICE_STATE_IP_CONFIG 70 +#define NM_DEVICE_STATE_IP_CHECK 80 +#define NM_DEVICE_STATE_SECONDARIES 90 +#define NM_DEVICE_STATE_ACTIVATED 100 +#define NM_DEVICE_STATE_DEACTIVATING 110 +#define NM_DEVICE_STATE_FAILED 120 +//==================================================================================================== +#define NM_DEVICE_CAP_NONE 0 +#define NM_DEVICE_CAP_NM_SUPPORTED 1 +#define NM_DEVICE_CAP_CARRIER_DETECT 2 +//==================================================================================================== +#define NM_EAP_FAST_PROVISIONING_DISABLED 0 +#define NM_EAP_FAST_PROVISIONING_UNAUTHONLY 1 +#define NM_EAP_FAST_PROVISIONING_AUTHONLY 2 +#define NM_EAP_FAST_PROVISIONING_BOTH 3 +//==================================================================================================== +#define NM_PASSWORD_SECRET_NONE 0 +#define NM_PASSWORD_SECRET_AGENTOWNED 1 +#define NM_PASSWORD_SECRET_NOTSAVED 2 +#define NM_PASSWORD_SECRET_NOTREQUIRED 4 +//==================================================================================================== +#define NM_ACCESS_POINT_CAP_NONE 0x0 +#define NM_ACCESS_POINT_CAP_PRIVACY 0x1 +//==================================================================================================== +#define NM_ACCESS_POINT_SEC_NONE 0x0 +#define NM_ACCESS_POINT_SEC_PAIR_WEP40 0x1 +#define NM_ACCESS_POINT_SEC_PAIR_WEP104 0x2 +#define NM_ACCESS_POINT_SEC_PAIR_TKIP 0x4 +#define NM_ACCESS_POINT_SEC_PAIR_CCMP 0x8 +#define NM_ACCESS_POINT_SEC_GROUP_WEP40 0x10 +#define NM_ACCESS_POINT_SEC_GROUP_WEP104 0x20 +#define NM_ACCESS_POINT_SEC_GROUP_TKIP 0x40 +#define NM_ACCESS_POINT_SEC_GROUP_CCMP 0x80 +#define NM_ACCESS_POINT_SEC_KEY_MGMT_PSK 0x100 +#define NM_ACCESS_POINT_SEC_KEY_MGMT_802_1X 0x200 +//==================================================================================================== + +class TDENetworkConnectionManager_BackendNMPrivate; + class TDECORE_EXPORT TDENetworkConnectionManager_BackendNM : public TDENetworkConnectionManager { Q_OBJECT @@ -33,16 +117,32 @@ class TDECORE_EXPORT TDENetworkConnectionManager_BackendNM : public TDENetworkCo virtual TDENetworkDeviceInformation deviceInformation(); virtual void loadConnectionInformation(); - virtual bool saveConnection(TDENetworkConnection connection); + virtual bool loadConnectionSecrets(TQString uuid); + virtual bool saveConnection(TDENetworkConnection* connection); virtual bool deleteConnection(TQString uuid); - virtual TDENetworkConnectionList* connections(); - virtual TDENetworkConnectionStatus::TDENetworkConnectionStatus initiateConnection(TQString uuid); virtual TDENetworkConnectionStatus::TDENetworkConnectionStatus checkConnectionStatus(TQString uuid); virtual TDENetworkConnectionStatus::TDENetworkConnectionStatus deactivateConnection(TQString uuid); virtual TDENetworkHWNeighborList* siteSurvey(); + + virtual bool networkingEnabled(); + virtual bool wiFiHardwareEnabled(); + + virtual bool enableWiFi(bool enable); + virtual bool wiFiEnabled(); + + private: + void internalProcessGlobalStateChanged(TQ_UINT32 state); + void internalProcessDeviceStateChanged(TQ_UINT32 newState, TQ_UINT32 oldState, TQ_UINT32 reason); + TDENetworkConnectionType::TDENetworkConnectionType nmDeviceTypeToTDEDeviceType(TQ_UINT32 nmType); + TQString deviceInterfaceString(TQString macAddress); + bool loadConnectionSecretsForGroup(TQString uuid, TQString group); + TDENetworkWiFiAPInfo* getAccessPointDetails(TQString dbusPath); + + private: + TDENetworkConnectionManager_BackendNMPrivate* d; }; #endif // _TDENETWORKBACKEND_NETWORKMANAGER_H
\ No newline at end of file diff --git a/tdecore/networkbackends/network-manager/network-manager_p.h b/tdecore/networkbackends/network-manager/network-manager_p.h new file mode 100644 index 000000000..694e75984 --- /dev/null +++ b/tdecore/networkbackends/network-manager/network-manager_p.h @@ -0,0 +1,83 @@ +/* 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. +*/ + +#ifndef _TDENETWORKBACKEND_NETWORKMANAGER_P_H +#define _TDENETWORKBACKEND_NETWORKMANAGER_P_H + +/* TQt headers */ +#include <tqvaluelist.h> +#include <tqapplication.h> +#include <tqtimer.h> + +/* TDE headers */ +#include <kdebug.h> +#include <klocale.h> + +/* TQDbus headers */ +#include <tqdbusconnection.h> +#include <tqdbusobjectpath.h> +#include <tqdbusdata.h> +#include <tqdbuserror.h> +#include <tqdbusdatamap.h> +#include <tqdbusvariant.h> +#include <tqdbusdatalist.h> + +/* NM headers */ +//#include <NetworkManager.h> + +/* Proxy headers */ +#include "networkmanagerproxy.h" +#include "networkmanagersettings.h" +#include "connectionsettings.h" +#include "deviceproxy.h" +#include "ethernetproxy.h" +#include "wifiproxy.h" +#include "activeconnectionproxy.h" +#include "accesspointproxy.h" + +typedef TQT_DBusDataMap<TQString> TQT_DBusTQStringDataMap; +typedef TQValueList<TQT_DBusData> TQT_DBusDataValueList; + +typedef TQMap<uint, bool> NMAsyncCallIDMap; +typedef TQMap<uint, TQT_DBusTQStringDataMap> NMAsyncSettingsResponseMap; +typedef TQMap<uint, TQT_DBusObjectPath> NMAddConnectionAsyncResponseMap; + +typedef TQValueList<TQT_DBusObjectPath> TQT_DBusObjectPathList; + +class TDENetworkConnectionManager_BackendNMPrivate : public TQObject +{ + Q_OBJECT + + public: + TDENetworkConnectionManager_BackendNMPrivate() : m_networkManagerProxy(NULL), m_networkManagerSettings(NULL), m_networkDeviceProxy(NULL) {} + + public: + DBus::NetworkManagerProxy* m_networkManagerProxy; + DBus::SettingsInterface* m_networkManagerSettings; + DBus::DeviceProxy* m_networkDeviceProxy; + NMAsyncCallIDMap nmConnectionSettingsAsyncCallWaiting; + NMAsyncSettingsResponseMap nmConnectionSettingsAsyncSettingsResponse; + NMAddConnectionAsyncResponseMap nmAddConnectionAsyncResponse; + + public slots: + void processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&); + void processConnectionSettingsUpdateAsyncReply(int); + void processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&); +}; + +#endif // _TDENETWORKBACKEND_NETWORKMANAGER_P_H
\ No newline at end of file diff --git a/tdecore/tdehardwaredevices.cpp b/tdecore/tdehardwaredevices.cpp index ab3c06e91..293454457 100644 --- a/tdecore/tdehardwaredevices.cpp +++ b/tdecore/tdehardwaredevices.cpp @@ -16,8 +16,6 @@ Boston, MA 02110-1301, USA. */ -#define USE_NETWORKMANAGER_NETWORK_BACKEND - #include <tdehardwaredevices.h> #include <tqfile.h> @@ -61,9 +59,12 @@ // Network connection manager #include "tdenetworkconnections.h" -#ifdef USE_NETWORKMANAGER_NETWORK_BACKEND +// Compile-time configuration +#include "config.h" + +#ifdef WITH_NETWORK_MANAGER_BACKEND #include "networkbackends/network-manager/network-manager.h" -#endif // USE_NETWORKMANAGER_NETWORK_BACKEND +#endif // WITH_NETWORK_MANAGER_BACKEND // BEGIN BLOCK // Copied from include/linux/genhd.h @@ -1458,11 +1459,11 @@ void TDENetworkDevice::internalSetTxPackets(double tx) { } TDENetworkConnectionManager* TDENetworkDevice::connectionManager() { -#ifdef USE_NETWORKMANAGER_NETWORK_BACKEND +#ifdef WITH_NETWORK_MANAGER_BACKEND if (!m_connectionManager) { m_connectionManager = new TDENetworkConnectionManager_BackendNM(m_macAddress); } -#endif // USE_NETWORKMANAGER_NETWORK_BACKEND +#endif // WITH_NETWORK_MANAGER_BACKEND return m_connectionManager; } diff --git a/tdecore/tdenetworkconnections.cpp b/tdecore/tdenetworkconnections.cpp index e137457ed..0a3893f1f 100644 --- a/tdecore/tdenetworkconnections.cpp +++ b/tdecore/tdenetworkconnections.cpp @@ -19,13 +19,297 @@ #include "tdehardwaredevices.h" #include "tdenetworkconnections.h" +#define SET_BIT(x, y) (x |= 1 << y) +#define TEST_BIT(x, y) ((x & (1 << y)) >> y) + +/*================================================================================================*/ +/* TDENetworkSearchDomain */ +/*================================================================================================*/ + +TDENetworkSearchDomain::TDENetworkSearchDomain() { + m_isIPV6 = false; +} + +TDENetworkSearchDomain::TDENetworkSearchDomain(TQString domain, bool ipv6) { + m_isIPV6 = ipv6; + m_domain = domain; +} + +TDENetworkSearchDomain::~TDENetworkSearchDomain() { + // +} + +TQString TDENetworkSearchDomain::searchDomain() { + return m_domain; +} + +void TDENetworkSearchDomain::setSearchDomain(TQString domain, bool ipv6) { + m_isIPV6 = ipv6; + m_domain = domain; +} + +bool TDENetworkSearchDomain::isIPv4() { + return !m_isIPV6; +} + +bool TDENetworkSearchDomain::isIPv6() { + return m_isIPV6; +} + +/*================================================================================================*/ +/* TDENetMask */ +/*================================================================================================*/ + +TDENetMask::TDENetMask() { + m_ipv4NetMask = 0; + m_isIPV6 = false; +} + +TDENetMask::TDENetMask(TQ_UINT32 netmask) { + m_ipv4NetMask = netmask; + m_isIPV6 = false; +} + +TDENetMask::TDENetMask(TQ_UINT8* netmask) { + m_ipv6NetMask = TQHostAddress(netmask); + m_isIPV6 = true; +} + +TDENetMask::~TDENetMask() { + // +} + +void TDENetMask::fromCIDRMask(unsigned char mask, bool ipv6) { + unsigned int i; + unsigned int j; + if (!ipv6) { + m_ipv4NetMask = 0; + for (i=31;i>=(32-mask);i--) { + SET_BIT(m_ipv4NetMask, i); + } + m_isIPV6 = false; + } + else { + Q_IPV6ADDR maskarray; + j=0; + unsigned int byteno=0; + memset(maskarray.c, 0, 16); + for (i=127;i>=(128-mask);i--) { + SET_BIT(maskarray.c[byteno], (i-((15-byteno)*8))); + j++; + if (j>7) { + j=0; + byteno++; + } + } + m_ipv6NetMask = TQHostAddress(maskarray); + m_isIPV6 = true; + } +} + +unsigned char TDENetMask::toCIDRMask() { + unsigned int i; + unsigned int j; + if (!m_isIPV6) { + for (i=0; i<32; i++) { + if (TEST_BIT(m_ipv4NetMask, i)) { + break; + } + } + return 32-i; + } + else { + Q_IPV6ADDR mask = m_ipv6NetMask.toIPv6Address(); + bool found = false; + for (j=0; j<16; ++j) { + for (i=0; i<8; i++) { + if (!TEST_BIT(mask.c[j], i)) { + found = true; + break; + } + } + if (found) break; + } + return ((j*8)+i); + } +} + +void TDENetMask::fromString(TQString mask) { + if (mask.contains(".")) { + m_isIPV6 = false; + m_ipv4NetMask = 0; + TQStringList pieces = TQStringList::split(".", mask); + TQ_UINT8 chunk; + chunk = pieces[0].toUShort(); + m_ipv4NetMask = m_ipv4NetMask | (chunk << 24); + chunk = pieces[1].toUShort(); + m_ipv4NetMask = m_ipv4NetMask | (chunk << 16); + chunk = pieces[2].toUShort(); + m_ipv4NetMask = m_ipv4NetMask | (chunk << 8); + chunk = pieces[3].toUShort(); + m_ipv4NetMask = m_ipv4NetMask | (chunk << 0); + } + else if (mask.contains(":")) { + m_isIPV6 = true; + m_ipv6NetMask.setAddress(mask); + } +} + +TQString TDENetMask::toString() { + if (!m_isIPV6) { + return TQString("%1.%2.%3.%4").arg((m_ipv4NetMask & 0xff000000) >> 24).arg((m_ipv4NetMask & 0x00ff0000) >> 16).arg((m_ipv4NetMask & 0x0000ff00) >> 8).arg((m_ipv4NetMask & 0x000000ff) >> 0); + } + else { + return m_ipv6NetMask.toString(); + } +} + +bool TDENetMask::isIPv4() { + return !m_isIPV6; +} + +bool TDENetMask::isIPv6() { + return m_isIPV6; +} + +/*================================================================================================*/ +/* TDEMACAddress */ +/*================================================================================================*/ + +TDEMACAddress::TDEMACAddress() { + m_macAddress.clear(); + m_isValid = false; +} + +TDEMACAddress::TDEMACAddress(TDENetworkByteList address) { + m_macAddress = address; + m_isValid = true; +} + +TDEMACAddress::~TDEMACAddress() { + // +} + +TDENetworkByteList TDEMACAddress::address() { + return m_macAddress; +} + +void TDEMACAddress::setAddress(TDENetworkByteList address) { + m_macAddress = address; + m_isValid = true; +} + +bool TDEMACAddress::isValid() { + return m_isValid; +} + +void TDEMACAddress::fromString(TQString address) { + TQStringList pieces = TQStringList::split(":", address); + m_macAddress.clear(); + for (TQStringList::Iterator it = pieces.begin(); it != pieces.end(); ++it) { + m_macAddress.append((*it).toUShort(0, 16)); + } + m_isValid = true; +} + +TQString TDEMACAddress::toString() { + TQString ret; + TDENetworkByteList::iterator it; + for (it = m_macAddress.begin(); it != m_macAddress.end(); ++it) { + if (ret != "") { + ret.append(":"); + } + ret.append(TQString().sprintf("%02x", *it)); + } + return ret.lower(); +} + +bool operator==(const TDEMACAddress &a1, const TDEMACAddress &a2) { + if (a1.m_macAddress.count() != a2.m_macAddress.count()) { + return false; + } + else { + unsigned int i; + for (i=0; i<a1.m_macAddress.count(); i++) { + if (a1.m_macAddress[i] != a2.m_macAddress[i]) { + return false; + } + } + return true; + } +} + +/*================================================================================================*/ +/* TDENetworkSingleIPConfiguration */ +/*================================================================================================*/ + +TDENetworkSingleIPConfiguration::TDENetworkSingleIPConfiguration() { + valid = false; +} + +TDENetworkSingleIPConfiguration::~TDENetworkSingleIPConfiguration() { + // +} + +bool TDENetworkSingleIPConfiguration::isIPv4() { + return ipAddress.isIPv4Address() & valid; +} + +bool TDENetworkSingleIPConfiguration::isIPv6() { + return ipAddress.isIPv6Address() & valid; +} + +/*================================================================================================*/ +/* TDENetworkSingleRouteConfiguration */ +/*================================================================================================*/ + +TDENetworkSingleRouteConfiguration::TDENetworkSingleRouteConfiguration() { + valid = false; +} + +TDENetworkSingleRouteConfiguration::~TDENetworkSingleRouteConfiguration() { + // +} + +bool TDENetworkSingleRouteConfiguration::isIPv4() { + return ipAddress.isIPv4Address() & valid; +} + +bool TDENetworkSingleRouteConfiguration::isIPv6() { + return ipAddress.isIPv6Address() & valid; +} + +/*================================================================================================*/ +/* TDENetworkIEEE8021xConfiguration */ +/*================================================================================================*/ + +TDENetworkIEEE8021xConfiguration::TDENetworkIEEE8021xConfiguration() { + valid = false; + secretsValid = false; + fastProvisioningFlags = TDENetworkIEEE8021xFastFlags::None; + passwordFlags = TDENetworkPasswordHandlingFlags::None; + binaryPasswordFlags = TDENetworkPasswordHandlingFlags::None; + forceSystemCaCertificates = false; +} + +TDENetworkIEEE8021xConfiguration::~TDENetworkIEEE8021xConfiguration() { + // +} + /*================================================================================================*/ /* TDENetworkIPConfiguration */ /*================================================================================================*/ TDENetworkIPConfiguration::TDENetworkIPConfiguration() { valid = false; - connectionFlags = TDENetworkIPConfigurationFlags::Invalid; + connectionFlags = TDENetworkIPConfigurationFlags::IPV4DHCPIP | \ + TDENetworkIPConfigurationFlags::IPV4DHCPDNS | \ + TDENetworkIPConfigurationFlags::IPV4DHCPRoutes | \ + TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute | \ + TDENetworkIPConfigurationFlags::IPV6DHCPIP | \ + TDENetworkIPConfigurationFlags::IPV6DHCPDNS | \ + TDENetworkIPConfigurationFlags::IPV6DHCPRoutes | \ + TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute; } TDENetworkIPConfiguration::~TDENetworkIPConfiguration() { @@ -86,8 +370,12 @@ TDENetworkWiFiAPInfo::~TDENetworkWiFiAPInfo() { /* TDENetworkConnection */ /*================================================================================================*/ -TDENetworkConnection::TDENetworkConnection() : TQObject() { - // +TDENetworkConnection::TDENetworkConnection() { + autoConnect = false; + fullDuplex = true; + requireIPV4 = false; + requireIPV6 = false; + mtu = 0; } TDENetworkConnection::~TDENetworkConnection() { @@ -95,6 +383,18 @@ TDENetworkConnection::~TDENetworkConnection() { } /*================================================================================================*/ +/* TDEWiredEthernetConnection */ +/*================================================================================================*/ + +TDEWiredEthernetConnection::TDEWiredEthernetConnection() : TDENetworkConnection() { + // +} + +TDEWiredEthernetConnection::~TDEWiredEthernetConnection() { + // +} + +/*================================================================================================*/ /* TDEWiFiConnection */ /*================================================================================================*/ @@ -110,7 +410,7 @@ TDEWiFiConnection::~TDEWiFiConnection() { /* TDENetworkConnectionManager */ /*================================================================================================*/ -TDENetworkConnectionManager::TDENetworkConnectionManager(TQString macAddress) : TQObject(), m_connectionList(NULL), m_macAddress(macAddress) { +TDENetworkConnectionManager::TDENetworkConnectionManager(TQString macAddress) : TQObject(), m_connectionList(NULL), m_hwNeighborList(NULL), m_macAddress(macAddress), m_prevConnectionStatus(TDENetworkGlobalManagerFlags::Unknown) { // } @@ -122,6 +422,49 @@ TQString TDENetworkConnectionManager::deviceMACAddress() { return m_macAddress; } +TDENetworkConnectionList* TDENetworkConnectionManager::connections() { + return m_connectionList; +} + +TDENetworkConnection* TDENetworkConnectionManager::findConnectionByUUID(TQString uuid) { + TDENetworkConnection *connection; + for (connection = m_connectionList->first(); connection; connection = m_connectionList->next()) { + if (connection->UUID == uuid) { + return connection; + } + } + return NULL; +} + +void TDENetworkConnectionManager::clearTDENetworkConnectionList() { + TDENetworkConnection *connection; + for (connection = m_connectionList->first(); connection; connection = m_connectionList->next()) { + delete connection; + } + m_connectionList->clear(); +} + +void TDENetworkConnectionManager::clearTDENetworkHWNeighborList() { + TDENetworkHWNeighbor *neighbor; + for (neighbor = m_hwNeighborList->first(); neighbor; neighbor = m_hwNeighborList->next()) { + delete neighbor; + } + m_hwNeighborList->clear(); +} + +void TDENetworkConnectionManager::internalNetworkConnectionStateChanged(TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags newState) { + emit(networkConnectionStateChanged(m_prevConnectionStatus, newState)); + m_prevConnectionStatus = newState; +} + +void TDENetworkConnectionManager::internalNetworkDeviceStateChanged(TDENetworkConnectionStatus::TDENetworkConnectionStatus newState, TQString hwAddress) { + if (!m_prevDeviceStatus.contains("hwAddress")) { + m_prevDeviceStatus[hwAddress] = TDENetworkConnectionStatus::Invalid; + } + emit(networkDeviceStateChanged(m_prevDeviceStatus[hwAddress], newState, hwAddress)); + m_prevDeviceStatus[hwAddress] = newState; +} + /*================================================================================================*/ /* End */ /*================================================================================================*/ diff --git a/tdecore/tdenetworkconnections.h b/tdecore/tdenetworkconnections.h index 05c4bb591..bec8d3201 100644 --- a/tdecore/tdenetworkconnections.h +++ b/tdecore/tdenetworkconnections.h @@ -23,6 +23,7 @@ #include <tqstring.h> #include <tqptrlist.h> #include <tqstringlist.h> +#include <tqhostaddress.h> #include "kiconloader.h" #include "tdelibs_export.h" @@ -40,10 +41,26 @@ inline x operator~(x a) \ { \ return static_cast<x>(~static_cast<int>(a)); \ + } \ + \ + inline x &operator|=(x& a, const x& b) \ + { \ + a = static_cast<x>(static_cast<int>(a) | static_cast<int>(b)); \ + return a; \ + } \ + \ + inline x &operator&=(x& a, const x& b) \ + { \ + a = static_cast<x>(static_cast<int>(a) & static_cast<int>(b)); \ + return a; \ } +typedef TQValueList<TQ_UINT8> TDENetworkByteList; +typedef TQValueList<TQHostAddress> TDENetworkAddressList; + namespace TDENetworkConnectionType { enum TDENetworkConnectionType { + BackendOnly, WiredEthernet, WiFi, Bluetooth, @@ -139,6 +156,50 @@ namespace TDENetworkWiFiConnectionCipher { }; }; +namespace TDENetworkIEEE8021xType { + enum TDENetworkIEEE8021xType { + None, + LEAP, + MD5, + PAP, + CHAP, + MSCHAP, + MSCHAPV2, + Fast, + PSK, + PAX, + SAKE, + GPSK, + TLS, + PEAP, + TTLS, + SIM, + GTC, + OTP + }; +}; + +namespace TDENetworkIEEE8021xFastFlags { + enum TDENetworkIEEE8021xFastFlags { + None = 0x00000000, + AllowUnauthenticated = 0x00000001, + AllowAuthenticated = 0x00000002 + }; + + CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkIEEE8021xFastFlags) +}; + +namespace TDENetworkPasswordHandlingFlags { + enum TDENetworkPasswordHandlingFlags { + None = 0x00000000, + NoSave = 0x00000001, + NoPrompt = 0x00000002, + ExternalStorage = 0x00000004 + }; + + CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkPasswordHandlingFlags) +}; + namespace TDENetworkConnectionStatus { enum TDENetworkConnectionStatus { Invalid = 0x00000000, @@ -146,17 +207,18 @@ namespace TDENetworkConnectionStatus { Connected = 0x00000002, LinkUnavailable = 0x00000004, EstablishingLink = 0x00000008, - ConfiguringProtocols = 0x00000010, - Reconnecting = 0x00000020, - LinkLost = 0x00000040, - LinkLocalAccess = 0x00000080, - SiteLocalAccess = 0x00000100, - GlobalAccess = 0x00000200, - UnManaged = 0x00000400, - NeedAuthorization = 0x00000800, - Failed = 0x00001000, - VerifyingProtocols = 0x00002000, - DependencyWait = 0x00004000 + DeactivatingLink = 0x00000010, + ConfiguringProtocols = 0x00000020, + Reconnecting = 0x00000040, + LinkLost = 0x00000080, + LinkLocalAccess = 0x00000100, + SiteLocalAccess = 0x00000200, + GlobalAccess = 0x00000400, + UnManaged = 0x00000800, + NeedAuthorization = 0x00001000, + Failed = 0x00002000, + VerifyingProtocols = 0x00004000, + DependencyWait = 0x00008000 }; CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkConnectionStatus) @@ -164,16 +226,168 @@ namespace TDENetworkConnectionStatus { namespace TDENetworkIPConfigurationFlags { enum TDENetworkIPConfigurationFlags { - Invalid = 0x00000000, - IPV4 = 0x00000001, - IPV6 = 0x00000002, - DHCP = 0x00000004, - StaticIP = 0x00000008 + None = 0x00000000, + IPV4DHCPIP = 0x00000001, + IPV4DHCPDNS = 0x00000002, + IPV4DHCPRoutes = 0x00000004, + IPV4LocalOnly = 0x00000008, + IPV4StartConnectionSharingServer = 0x00000010, + IPV4Disabled = 0x00000020, + IPV4MayUseAsDefaultRoute = 0x00000040, + IPV6DHCPIP = 0x00000080, + IPV6DHCPDNS = 0x00000100, + IPV6DHCPRoutes = 0x00000200, + IPV6LocalOnly = 0x00000400, + IPV6StartConnectionSharingServer = 0x00000800, + IPV6Disabled = 0x00001000, + IPV6MayUseAsDefaultRoute = 0x00002000 }; CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkIPConfigurationFlags) }; +class TDECORE_EXPORT TDENetworkSearchDomain +{ + public: + TDENetworkSearchDomain(); + TDENetworkSearchDomain(TQString domain, bool ipv6=false); + ~TDENetworkSearchDomain(); + + TQString searchDomain(); + void setSearchDomain(TQString domain, bool ipv6=false); + + bool isIPv4(); + bool isIPv6(); + + private: + TQString m_domain; + bool m_isIPV6; +}; + +typedef TQValueList<TDENetworkSearchDomain> TDENetworkSearchDomainList; + +class TDECORE_EXPORT TDENetMask +{ + public: + TDENetMask(); + TDENetMask(TQ_UINT32 netmask); + TDENetMask(TQ_UINT8* netmask); + ~TDENetMask(); + + void fromCIDRMask(unsigned char mask, bool ipv6=false); + unsigned char toCIDRMask(); + void fromString(TQString mask); + TQString toString(); + + bool isIPv4(); + bool isIPv6(); + + private: + TQ_UINT32 m_ipv4NetMask; + TQHostAddress m_ipv6NetMask; + bool m_isIPV6; +}; + +class TDECORE_EXPORT TDEMACAddress +{ + public: + TDEMACAddress(); + TDEMACAddress(TDENetworkByteList address); + ~TDEMACAddress(); + + TDENetworkByteList address(); + void setAddress(TDENetworkByteList address); + TQString toString(); + void fromString(TQString address); + bool isValid(); + + private: + bool m_isValid; + TDENetworkByteList m_macAddress; + + friend bool operator==(const TDEMACAddress &a1, const TDEMACAddress &a2); +}; + +bool operator==(const TDEMACAddress &a1, const TDEMACAddress &a2); + +class TDECORE_EXPORT TDENetworkSingleIPConfiguration +{ + public: + TDENetworkSingleIPConfiguration(); + ~TDENetworkSingleIPConfiguration(); + + bool isIPv4(); + bool isIPv6(); + + public: + bool valid; + TQHostAddress ipAddress; + TDENetMask networkMask; + TQHostAddress gateway; +}; + +typedef TQValueList<TDENetworkSingleIPConfiguration> TDENetworkSingleIPConfigurationList; + +class TDECORE_EXPORT TDENetworkSingleRouteConfiguration +{ + public: + TDENetworkSingleRouteConfiguration(); + ~TDENetworkSingleRouteConfiguration(); + + bool isIPv4(); + bool isIPv6(); + + public: + bool valid; + TQHostAddress ipAddress; + TDENetMask networkMask; + TQHostAddress gateway; + TQ_UINT32 metric; +}; + +typedef TQValueList<TDENetworkSingleRouteConfiguration> TDENetworkSingleRouteConfigurationList; + +class TDENetworkIEEE8021xConfiguration +{ + public: + TDENetworkIEEE8021xConfiguration(); + ~TDENetworkIEEE8021xConfiguration(); + + public: + bool valid; + bool secretsValid; + TDENetworkIEEE8021xType::TDENetworkIEEE8021xType type; + TQString userName; + TQString anonymousUserName; + TQString pacFileName; + TQByteArray caCertificate; + TQString additionalCAFilesPath; + TQString authServerCertSubjectMatch; + TQStringList alternateAuthServerCertSubjectMatch; + TQByteArray clientCertificate; + TQString forcePEAPVersion; + TQString forcePEAPLabel; + TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags fastProvisioningFlags; + TQString phase2NonEAPAuthMethod; + TQString phase2EAPAuthMethod; + TQByteArray phase2CaCertificate; + TQString phase2CaFilesPath; + TQString phase2AuthServerCertSubjectMatch; + TQStringList phase2AlternateAuthServerCertSubjectMatch; + TQByteArray phase2ClientCertificate; + TQString password; + TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags passwordFlags; + TQByteArray binaryPassword; + TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags binaryPasswordFlags; + TQByteArray privateKey; + TQString privateKeyPassword; + TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags privateKeyPasswordFlags; + TQByteArray phase2PrivateKey; + TQString phase2PrivateKeyPassword; + TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags phase2PrivateKeyPasswordFlags; + bool forceSystemCaCertificates; +}; + class TDECORE_EXPORT TDENetworkIPConfiguration { public: @@ -183,11 +397,13 @@ class TDECORE_EXPORT TDENetworkIPConfiguration public: bool valid; TDENetworkIPConfigurationFlags::TDENetworkIPConfigurationFlags connectionFlags; - TQString ipAddress; - TQString networkMask; - TQString gateway; - TQString broadcast; - TQString destination; + TDENetworkSingleIPConfigurationList ipConfigurations; + TDENetworkSingleRouteConfigurationList routeConfigurations; + TQHostAddress broadcast; + TQHostAddress destination; + TDENetworkAddressList resolvers; + TDENetworkSearchDomainList searchDomains; + TQString dhcpClientIdentifier; }; class TDECORE_EXPORT TDENetworkWiFiDeviceInfo @@ -198,8 +414,8 @@ class TDECORE_EXPORT TDENetworkWiFiDeviceInfo public: bool valid; - TQString hwAddress; - TQString permanentHWAddress; + TDEMACAddress hwAddress; + TDEMACAddress permanentHWAddress; TDEWiFiMode::TDEWiFiMode operatingMode; unsigned int bitrate; TQString activeAccessPointBSSID; @@ -225,7 +441,7 @@ class TDECORE_EXPORT TDENetworkDeviceInformation bool autoConnect; bool firmwareMissing; TDENetworkConnectionType::TDENetworkConnectionType deviceType; - TDENetworkWiFiDeviceInfo wirelessInfo; + TDENetworkWiFiDeviceInfo wiFiInfo; }; class TDECORE_EXPORT TDENetworkHWNeighbor @@ -245,8 +461,9 @@ class TDECORE_EXPORT TDENetworkWiFiAPInfo : public TDENetworkHWNeighbor ~TDENetworkWiFiAPInfo(); public: - TQString SSID; - TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags flags; + TQByteArray SSID; + TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags wpaFlags; + TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags rsnFlags; unsigned int frequency; TQString BSSID; unsigned int maxBitrate; @@ -255,28 +472,38 @@ class TDECORE_EXPORT TDENetworkWiFiAPInfo : public TDENetworkHWNeighbor typedef TQPtrList< TDENetworkHWNeighbor > TDENetworkHWNeighborList; -class TDECORE_EXPORT TDENetworkConnection : public TQObject +class TDECORE_EXPORT TDENetworkConnection { - Q_OBJECT - public: TDENetworkConnection(); - ~TDENetworkConnection(); + virtual ~TDENetworkConnection(); public: TQString UUID; TQString friendlyName; TDENetworkIPConfiguration ipConfig; + TDEMACAddress lockedHWAddress; + TDEMACAddress manualHWAddress; bool autoConnect; + bool fullDuplex; + bool requireIPV4; + bool requireIPV6; + TQ_UINT32 mtu; + TDENetworkIEEE8021xConfiguration eapConfig; }; -class TDECORE_EXPORT TDEWiFiConnection : public TDENetworkConnection +class TDECORE_EXPORT TDEWiredEthernetConnection : public TDENetworkConnection { - Q_OBJECT + public: + TDEWiredEthernetConnection(); + virtual ~TDEWiredEthernetConnection(); +}; +class TDECORE_EXPORT TDEWiFiConnection : public TDENetworkConnection +{ public: TDEWiFiConnection(); - ~TDEWiFiConnection(); + virtual ~TDEWiFiConnection(); public: TQString SSID; @@ -297,6 +524,8 @@ class TDECORE_EXPORT TDENetworkConnectionManager : public TQObject /** * Constructor. * @param macAddress The MAC address of the hardware device + * If an empty MAC address is passed, this object will make global networking backend + * methods available exclusively (TDENetworkConnectionType::BackendOnly). */ TDENetworkConnectionManager(TQString macAddress); @@ -327,15 +556,25 @@ class TDECORE_EXPORT TDENetworkConnectionManager : public TQObject /** * Loads all connection information from the configuration backend + * Secret information must be loaded separately via a call to + * loadConnectionSecrets(TQString uuid) after this method has been + * executed at least once. */ virtual void loadConnectionInformation() = 0; /** - * @param connection a TDENetworkConnection object containing a + * @param uuid a TQString conntaining the UUID of a connection for which to + * load secrets from the configuration backend. + * @return true on success, false on failure. + */ + virtual bool loadConnectionSecrets(TQString uuid) = 0; + + /** + * @param connection a pointer to a TDENetworkConnection object containing a * connection to save to the configuration backend. * @return true on success, false on failure. */ - virtual bool saveConnection(TDENetworkConnection connection) = 0; + virtual bool saveConnection(TDENetworkConnection* connection) = 0; /** * @param uuid a TQString conntaining the UUID of a connection to @@ -345,21 +584,6 @@ class TDECORE_EXPORT TDENetworkConnectionManager : public TQObject virtual bool deleteConnection(TQString uuid) = 0; /** - * @return a TDENetworkConnectionList object containing a list of all - * possible connections this connection manager is aware of, regardless - * of current state or availability. - * - * loadConnectionInformation() should be called at least once before calling - * this method, in order to update internal connection information from the - * configuration backend. - * - * Note that the returned list is internally managed and must not be deleted! - * Also note that pointers in the list may become invalid on subsequent calls to - * loadConnectionInformation(), saveConnection(), deleteConnection(), or connections(). - */ - virtual TDENetworkConnectionList* connections() = 0; - - /** * Initiates a connection with UUID @param uuid. * @return A TDENetworkConnectionStatus enum value with the current connection status * The client application should poll for status updates using checkConnectionStatus() @@ -390,9 +614,78 @@ class TDECORE_EXPORT TDENetworkConnectionManager : public TQObject */ virtual TDENetworkHWNeighborList* siteSurvey() = 0; - private: + /** + * @return true if networking is enabled, false if not. + */ + virtual bool networkingEnabled() = 0; + + /** + * @return true if WiFi hardware is enabled, false if not. + */ + virtual bool wiFiHardwareEnabled() = 0; + + /** + * @param enable true to enable WiFi, false to disable it. + * @return true on success, false on failure. + */ + virtual bool enableWiFi(bool enable) = 0; + + /** + * @return true if WiFi is enabled, false if not. + */ + virtual bool wiFiEnabled() = 0; + + signals: + /** + * Emitted whenever the state of the system's connection changes + * If previous state data was unavailable, @param previousState will contain TDENetworkConnectionStatus::Invalid + */ + void networkConnectionStateChanged(TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags newState, TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags previousState); + + /** + * Emitted whenever the state of a device changes + * If previous state data was unavailable, @param previousState will contain TDENetworkConnectionStatus::Invalid + * If the global connection state has changed, @param hwAddress will be empty, otherwise it will contain the MAC address + * of the networking hardware that has changed state. + */ + void networkDeviceStateChanged(TDENetworkConnectionStatus::TDENetworkConnectionStatus newState, TDENetworkConnectionStatus::TDENetworkConnectionStatus previousState, TQString hwAddress); + + public: + /** + * @return a TDENetworkConnectionList object containing a list of all + * possible connections this connection manager is aware of, regardless + * of current state or availability. + * + * loadConnectionInformation() should be called at least once before calling + * this method, in order to update internal connection information from the + * configuration backend. + * + * Note that the returned list is internally managed and must not be deleted! + * Also note that pointers in the list may become invalid on subsequent calls to + * loadConnectionInformation(), saveConnection(), deleteConnection(), or connections(). + */ + virtual TDENetworkConnectionList* connections(); + + /** + * @return a pointer to a TDENetworkConnection object with the specified @param uuid, + * or a NULL pointer if no such connection exists. + * + * Note that the returned object is internally managed and must not be deleted! + */ + TDENetworkConnection* findConnectionByUUID(TQString uuid); + + protected: + void clearTDENetworkConnectionList(); + void clearTDENetworkHWNeighborList(); + void internalNetworkConnectionStateChanged(TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags newState); + void internalNetworkDeviceStateChanged(TDENetworkConnectionStatus::TDENetworkConnectionStatus newState, TQString hwAddress=TQString::null); + + protected: TDENetworkConnectionList* m_connectionList; + TDENetworkHWNeighborList* m_hwNeighborList; TQString m_macAddress; + TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags m_prevConnectionStatus; + TQMap<TQString, TDENetworkConnectionStatus::TDENetworkConnectionStatus> m_prevDeviceStatus; }; #endif // _TDENETWORKCONNECTIONS_H
\ No newline at end of file |