• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • tdecore
 

tdecore

network-manager.cpp
00001 /* This file is part of the TDE libraries
00002    Copyright (C) 2012 Timothy Pearson <kb9vqf@pearsoncomputing.net>
00003 
00004    This library is free software; you can redistribute it and/or
00005    modify it under the terms of the GNU Library General Public
00006    License version 2 as published by the Free Software Foundation.
00007 
00008    This library is distributed in the hope that it will be useful,
00009    but WITHOUT ANY WARRANTY; without even the implied warranty of
00010    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011    Library General Public License for more details.
00012 
00013    You should have received a copy of the GNU Library General Public License
00014    along with this library; see the file COPYING.LIB.  If not, write to
00015    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00016    Boston, MA 02110-1301, USA.
00017 */
00018 
00019 #include <tqdir.h>
00020 
00021 #include <tqdbusmessage.h>
00022 
00023 #include "tdeconfig.h"
00024 #include "tdehardwaredevices.h"
00025 #include "tdenetworkdevice.h"
00026 
00027 #include "network-manager.h"
00028 #include "network-manager_p.h"
00029 
00030 // #define DEBUG_NETWORK_MANAGER_COMMUNICATIONS
00031 
00032 #define PRINT_ERROR(x) printf("[TDE NM Backend ERROR] [%s:%d] %s\n", __FILE__, __LINE__, x.ascii());
00033 
00034 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
00035 #define PRINT_WARNING(x) printf("[TDE NM Backend WARNING] [%s:%d] %s\n", __FILE__, __LINE__, x.ascii());
00036 #else
00037 #define PRINT_WARNING(x)
00038 #endif
00039 
00040 #define UPDATE_STRING_SETTING_IF_VALID(string, key, settingsMap)    if (!string.isNull()) settingsMap[key] = convertDBUSDataToVariantData(TQT_DBusData::fromString(string));    \
00041                                     else settingsMap.remove(key);
00042 
00043 #define NM_ASYNC_TIMEOUT_MS 1000
00044 // Give the user 5 minutes to authenticate to DBUS before timing out
00045 #define NM_ASYNC_SECRETS_INTERACTION_TIMEOUT_MS (5*60*1000)
00046 
00047 // #define WAIT_FOR_OPERATION_BEFORE_RETURNING 1
00048 #define USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS 1
00049 
00050 // Defined in tdehardwaredevices.cpp
00051 TQT_DBusData convertDBUSDataToVariantData(TQT_DBusData);
00052 
00053 TQ_UINT32 reverseIPV4ByteOrder(TQ_UINT32 address) {
00054     TQ_UINT32 ret;
00055     unsigned char valuearray[4];
00056     valuearray[0] = (address & 0xff000000) >> 24;
00057     valuearray[1] = (address & 0x00ff0000) >> 16;
00058     valuearray[2] = (address & 0x0000ff00) >> 8;
00059     valuearray[3] = (address & 0x000000ff) >> 0;
00060     ret = 0;
00061     ret = ret | (valuearray[0] << 0);
00062     ret = ret | (valuearray[1] << 8);
00063     ret = ret | (valuearray[2] << 16);
00064     ret = ret | (valuearray[3] << 24);
00065     return ret;
00066 }
00067 
00068 void printDBUSObjectStructure(TQT_DBusData object, int level=0, TQString mapKey=TQString::null) {
00069     int i;
00070     TQString levelIndent = "";
00071     for (i=0; i<level; i++) {
00072         levelIndent = levelIndent + " ";
00073     }
00074     TQCString signature = object.buildDBusSignature();
00075 
00076     if (object.type() == TQT_DBusData::String) {
00077         printf("%s%s\t%s%s'%s'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toString().ascii()); fflush(stdout);
00078     }
00079     else if (object.type() == TQT_DBusData::Bool) {
00080         printf("%s%s\t%s%s'%s'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", (object.toBool())?"true":"false"); fflush(stdout);
00081     }
00082     else if (object.type() == TQT_DBusData::Byte) {
00083         printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toByte()); fflush(stdout);
00084     }
00085     else if (object.type() == TQT_DBusData::Int16) {
00086         printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toInt16()); fflush(stdout);
00087     }
00088     else if (object.type() == TQT_DBusData::UInt16) {
00089         printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toUInt16()); fflush(stdout);
00090     }
00091     else if (object.type() == TQT_DBusData::Int32) {
00092         printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toInt32()); fflush(stdout);
00093     }
00094     else if (object.type() == TQT_DBusData::UInt32) {
00095         printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toUInt32()); fflush(stdout);
00096     }
00097     else if (object.type() == TQT_DBusData::Int64) {
00098         printf("%s%s\t%s%s'%lld'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toInt64()); fflush(stdout);
00099     }
00100     else if (object.type() == TQT_DBusData::UInt64) {
00101         printf("%s%s\t%s%s'%lld'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toUInt64()); fflush(stdout);
00102     }
00103     else {
00104         printf("%s%s\n", levelIndent.ascii(), signature.data()); fflush(stdout);
00105     }
00106 
00107     if (object.type() == TQT_DBusData::Map) {
00108         // HACK
00109         // NetworkManager currently uses string key maps exclusively as far as I can tell, so this should be adequate for the time being
00110         TQMap<TQString, TQT_DBusData> outerMap = object.toStringKeyMap().toTQMap();
00111         TQMap<TQString, TQT_DBusData>::const_iterator it;
00112             for (it = outerMap.begin(); it != outerMap.end(); ++it) {
00113             printDBUSObjectStructure(*it, level+1, it.key());
00114         }
00115     }
00116     else if (object.type() == TQT_DBusData::List) {
00117         TQT_DBusDataValueList valueList = object.toTQValueList();
00118         TQT_DBusDataValueList::const_iterator it;
00119         for (it = valueList.begin(); it != valueList.end(); ++it) {
00120             printDBUSObjectStructure(*it, level+1);
00121         }
00122     }
00123     else if (object.type() == TQT_DBusData::Variant) {
00124         TQT_DBusVariant dataValueVariant = object.toVariant();
00125         TQT_DBusData dataValue = dataValueVariant.value;
00126         printDBUSObjectStructure(dataValue, level+1, mapKey);
00127     }
00128 }
00129 
00130 TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags nmGlobalStateToTDEGlobalState(TQ_UINT32 nmType) {
00131     TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags ret = TDENetworkGlobalManagerFlags::Unknown;
00132 
00133     if (nmType == NM_STATE_UNKNOWN) {
00134         ret |= TDENetworkGlobalManagerFlags::Unknown;
00135     }
00136     else if (nmType == NM_STATE_ASLEEP) {
00137         ret |= TDENetworkGlobalManagerFlags::Disconnected;
00138         ret |= TDENetworkGlobalManagerFlags::Sleeping;
00139     }
00140     else if (nmType == NM_STATE_DISCONNECTED) {
00141         ret |= TDENetworkGlobalManagerFlags::Disconnected;
00142     }
00143     else if (nmType == NM_STATE_DISCONNECTING) {
00144         ret |= TDENetworkGlobalManagerFlags::Connected;
00145         ret |= TDENetworkGlobalManagerFlags::DeactivatingLink;
00146     }
00147     else if (nmType == NM_STATE_CONNECTING) {
00148         ret |= TDENetworkGlobalManagerFlags::Disconnected;
00149         ret |= TDENetworkGlobalManagerFlags::EstablishingLink;
00150     }
00151     else if (nmType == NM_STATE_CONNECTED_LOCAL) {
00152         ret |= TDENetworkGlobalManagerFlags::Connected;
00153         ret |= TDENetworkGlobalManagerFlags::LinkLocalAccess;
00154     }
00155     else if (nmType == NM_STATE_CONNECTED_SITE) {
00156         ret |= TDENetworkGlobalManagerFlags::Connected;
00157         ret |= TDENetworkGlobalManagerFlags::SiteLocalAccess;
00158     }
00159     else if (nmType == NM_STATE_CONNECTED_GLOBAL) {
00160         ret |= TDENetworkGlobalManagerFlags::Connected;
00161         ret |= TDENetworkGlobalManagerFlags::GlobalAccess;
00162     }
00163 
00164     return ret;
00165 }
00166 
00167 TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags nmVPNStateToTDEGlobalState(TQ_UINT32 nmType) {
00168     TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags ret = TDENetworkGlobalManagerFlags::Unknown;
00169 
00170     if (nmType == NM_VPN_STATE_UNKNOWN) {
00171         ret |= TDENetworkGlobalManagerFlags::VPNUnknown;
00172     }
00173     else if (nmType == NM_VPN_STATE_PREPARE) {
00174         ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
00175         ret |= TDENetworkGlobalManagerFlags::VPNEstablishingLink;
00176     }
00177     else if (nmType == NM_VPN_STATE_NEED_AUTH) {
00178         ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
00179         ret |= TDENetworkGlobalManagerFlags::VPNNeedAuthorization;
00180     }
00181     else if (nmType == NM_VPN_STATE_CONNECT) {
00182         ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
00183         ret |= TDENetworkGlobalManagerFlags::VPNConfiguringProtocols;
00184     }
00185     else if (nmType == NM_VPN_STATE_IP_CONFIG_GET) {
00186         ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
00187         ret |= TDENetworkGlobalManagerFlags::VPNVerifyingProtocols;
00188     }
00189     else if (nmType == NM_VPN_STATE_ACTIVATED) {
00190         ret |= TDENetworkGlobalManagerFlags::VPNConnected;
00191     }
00192     else if (nmType == NM_VPN_STATE_FAILED) {
00193         ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
00194         ret |= TDENetworkGlobalManagerFlags::VPNFailed;
00195     }
00196     else if (nmType == NM_VPN_STATE_DISCONNECTED) {
00197         ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
00198     }
00199 
00200     return ret;
00201 }
00202 
00203 TDENetworkConnectionStatus::TDENetworkConnectionStatus nmDeviceStateToTDEDeviceState(TQ_UINT32 nmType) {
00204     TDENetworkConnectionStatus::TDENetworkConnectionStatus ret = TDENetworkConnectionStatus::None;
00205 
00206     if (nmType == NM_DEVICE_STATE_UNKNOWN) {
00207         ret |= TDENetworkConnectionStatus::Invalid;
00208     }
00209     else if (nmType == NM_DEVICE_STATE_UNMANAGED) {
00210         ret |= TDENetworkConnectionStatus::UnManaged;
00211     }
00212     else if (nmType == NM_DEVICE_STATE_UNAVAILABLE) {
00213         ret |= TDENetworkConnectionStatus::Disconnected;
00214         ret |= TDENetworkConnectionStatus::LinkUnavailable;
00215     }
00216     else if (nmType == NM_DEVICE_STATE_DISCONNECTED) {
00217         ret |= TDENetworkConnectionStatus::Disconnected;
00218     }
00219     else if (nmType == NM_DEVICE_STATE_PREPARE) {
00220         ret |= TDENetworkConnectionStatus::Disconnected;
00221         ret |= TDENetworkConnectionStatus::EstablishingLink;
00222     }
00223     else if (nmType == NM_DEVICE_STATE_CONFIG) {
00224         ret |= TDENetworkConnectionStatus::Disconnected;
00225         ret |= TDENetworkConnectionStatus::EstablishingLink;
00226     }
00227     else if (nmType == NM_DEVICE_STATE_NEED_AUTH) {
00228         ret |= TDENetworkConnectionStatus::Disconnected;
00229         ret |= TDENetworkConnectionStatus::NeedAuthorization;
00230     }
00231     else if (nmType == NM_DEVICE_STATE_IP_CONFIG) {
00232         ret |= TDENetworkConnectionStatus::Disconnected;
00233         ret |= TDENetworkConnectionStatus::ConfiguringProtocols;
00234     }
00235     else if (nmType == NM_DEVICE_STATE_IP_CHECK) {
00236         ret |= TDENetworkConnectionStatus::Disconnected;
00237         ret |= TDENetworkConnectionStatus::VerifyingProtocols;
00238     }
00239     else if (nmType == NM_DEVICE_STATE_SECONDARIES) {
00240         ret |= TDENetworkConnectionStatus::Disconnected;
00241         ret |= TDENetworkConnectionStatus::DependencyWait;
00242     }
00243     else if (nmType == NM_DEVICE_STATE_ACTIVATED) {
00244         ret |= TDENetworkConnectionStatus::Connected;
00245     }
00246     else if (nmType == NM_DEVICE_STATE_DEACTIVATING) {
00247         ret |= TDENetworkConnectionStatus::Connected;
00248         ret |= TDENetworkConnectionStatus::DeactivatingLink;
00249     }
00250     else if (nmType == NM_DEVICE_STATE_FAILED) {
00251         ret |= TDENetworkConnectionStatus::Disconnected;
00252         ret |= TDENetworkConnectionStatus::Failed;
00253     }
00254 
00255     return ret;
00256 }
00257 
00258 TDENetworkDeviceType::TDENetworkDeviceType TDENetworkConnectionManager_BackendNM::nmDeviceTypeToTDEDeviceType(TQ_UINT32 nmType) {
00259     TDENetworkDeviceType::TDENetworkDeviceType ret = TDENetworkDeviceType::Other;
00260 
00261     if (nmType == NM_DEVICE_TYPE_UNKNOWN) {
00262         ret = TDENetworkDeviceType::Other;
00263     }
00264     else if (nmType == NM_DEVICE_TYPE_ETHERNET) {
00265         ret = TDENetworkDeviceType::WiredEthernet;
00266     }
00267     else if (nmType == NM_DEVICE_TYPE_WIFI) {
00268         ret = TDENetworkDeviceType::WiFi;
00269     }
00270     else if (nmType == NM_DEVICE_TYPE_UNUSED1) {
00271     }
00272     else if (nmType == NM_DEVICE_TYPE_UNUSED2) {
00273     }
00274     else if (nmType == NM_DEVICE_TYPE_BT) {
00275         ret = TDENetworkDeviceType::Bluetooth;
00276     }
00277     else if (nmType == NM_DEVICE_TYPE_OLPC_MESH) {
00278         ret = TDENetworkDeviceType::OLPCMesh;
00279     }
00280     else if (nmType == NM_DEVICE_TYPE_WIMAX) {
00281         ret = TDENetworkDeviceType::WiMax;
00282     }
00283     else if (nmType == NM_DEVICE_TYPE_MODEM) {
00284         ret = TDENetworkDeviceType::Modem;
00285     }
00286     else if (nmType == NM_DEVICE_TYPE_INFINIBAND) {
00287         ret = TDENetworkDeviceType::Infiniband;
00288     }
00289     else if (nmType == NM_DEVICE_TYPE_BOND) {
00290         ret = TDENetworkDeviceType::Bond;
00291     }
00292     else if (nmType == NM_DEVICE_TYPE_VLAN) {
00293         ret = TDENetworkDeviceType::VLAN;
00294     }
00295     else if (nmType == NM_DEVICE_TYPE_ADSL) {
00296         ret = TDENetworkDeviceType::ADSL;
00297     }
00298 
00299     return ret;
00300 }
00301 
00302 TDENetworkConnectionType::TDENetworkConnectionType nmConnectionTypeToTDEConnectionType(TQString nm) {
00303     TDENetworkConnectionType::TDENetworkConnectionType ret = TDENetworkConnectionType::Other;
00304 
00305     if (nm.lower() == "802-3-ethernet") {
00306         ret = TDENetworkConnectionType::WiredEthernet;
00307     }
00308     else if (nm.lower() == "infiniband") {
00309         ret = TDENetworkConnectionType::Infiniband;
00310     }
00311     else if (nm.lower() == "802-11-wireless") {
00312         ret = TDENetworkConnectionType::WiFi;
00313     }
00314     else if (nm.lower() == "vpn") {
00315         ret = TDENetworkConnectionType::VPN;
00316     }
00317     else if (nm.lower() == "wimax") {
00318         ret = TDENetworkConnectionType::WiMax;
00319     }
00320     else if (nm.lower() == "vlan") {
00321         ret = TDENetworkConnectionType::VLAN;
00322     }
00323     else if (nm.lower() == "802-11-olpc-mesh") {
00324         ret = TDENetworkConnectionType::OLPCMesh;
00325     }
00326     else if (nm.lower() == "bluetooth") {
00327         ret = TDENetworkConnectionType::Bluetooth;
00328     }
00329     else if (nm.lower() == "cdma") {
00330         ret = TDENetworkConnectionType::Modem;
00331     }
00332     else if (nm.lower() == "gsm") {
00333         ret = TDENetworkConnectionType::Modem;
00334     }
00335 
00336     return ret;
00337 }
00338 
00339 TQString tdeConnectionTypeToNMConnectionType(TDENetworkConnectionType::TDENetworkConnectionType type, TDEModemConnectionType::TDEModemConnectionType modemType=TDEModemConnectionType::Other) {
00340     TQString ret;
00341 
00342     if (type == TDENetworkConnectionType::WiredEthernet) {
00343         ret = "802-3-ethernet";
00344     }
00345     else if (type == TDENetworkConnectionType::Infiniband) {
00346         ret = "infiniband";
00347     }
00348     else if (type == TDENetworkConnectionType::WiFi) {
00349         ret = "802-11-wireless";
00350     }
00351     else if (type == TDENetworkConnectionType::VPN) {
00352         ret = "vpn";
00353     }
00354     else if (type == TDENetworkConnectionType::WiMax) {
00355         ret = "wimax";
00356     }
00357     else if (type == TDENetworkConnectionType::VLAN) {
00358         ret = "vlan";
00359     }
00360     else if (type == TDENetworkConnectionType::OLPCMesh) {
00361         ret = "802-11-olpc-mesh";
00362     }
00363     else if (type == TDENetworkConnectionType::Bluetooth) {
00364         ret = "bluetooth";
00365     }
00366     else if (type == TDENetworkConnectionType::Modem) {
00367         if (modemType == TDEModemConnectionType::CDMA) {
00368             ret = "cdma";
00369         }
00370         else if (modemType == TDEModemConnectionType::GSM) {
00371             ret = "gsm";
00372         }
00373     }
00374 
00375     return ret;
00376 }
00377 
00378 TDENetworkIEEE8021xType::TDENetworkIEEE8021xType nmEAPTypeToTDEEAPType(TQString nm) {
00379     TDENetworkIEEE8021xType::TDENetworkIEEE8021xType ret = TDENetworkIEEE8021xType::None;
00380 
00381     if (nm.lower() == "") {
00382         ret = TDENetworkIEEE8021xType::None;
00383     }
00384     else if (nm.lower() == "leap") {
00385         ret = TDENetworkIEEE8021xType::LEAP;
00386     }
00387     else if (nm.lower() == "md5") {
00388         ret = TDENetworkIEEE8021xType::MD5;
00389     }
00390     else if (nm.lower() == "pap") {
00391         ret = TDENetworkIEEE8021xType::PAP;
00392     }
00393     else if (nm.lower() == "chap") {
00394         ret = TDENetworkIEEE8021xType::CHAP;
00395     }
00396     else if (nm.lower() == "mschap") {
00397         ret = TDENetworkIEEE8021xType::MSCHAP;
00398     }
00399     else if (nm.lower() == "mschapv2") {
00400         ret = TDENetworkIEEE8021xType::MSCHAPV2;
00401     }
00402     else if (nm.lower() == "fast") {
00403         ret = TDENetworkIEEE8021xType::Fast;
00404     }
00405     else if (nm.lower() == "psk") {
00406         ret = TDENetworkIEEE8021xType::PSK;
00407     }
00408     else if (nm.lower() == "pax") {
00409         ret = TDENetworkIEEE8021xType::PAX;
00410     }
00411     else if (nm.lower() == "sake") {
00412         ret = TDENetworkIEEE8021xType::SAKE;
00413     }
00414     else if (nm.lower() == "gpsk") {
00415         ret = TDENetworkIEEE8021xType::GPSK;
00416     }
00417     else if (nm.lower() == "tls") {
00418         ret = TDENetworkIEEE8021xType::TLS;
00419     }
00420     else if (nm.lower() == "peap") {
00421         ret = TDENetworkIEEE8021xType::PEAP;
00422     }
00423     else if (nm.lower() == "ttls") {
00424         ret = TDENetworkIEEE8021xType::TTLS;
00425     }
00426     else if (nm.lower() == "sim") {
00427         ret = TDENetworkIEEE8021xType::SIM;
00428     }
00429     else if (nm.lower() == "gtc") {
00430         ret = TDENetworkIEEE8021xType::GTC;
00431     }
00432     else if (nm.lower() == "otp") {
00433         ret = TDENetworkIEEE8021xType::OTP;
00434     }
00435     else {
00436         PRINT_ERROR(TQString("unknown EAP type %s requested in existing connection").arg(nm.lower()))
00437     }
00438 
00439     return ret;
00440 }
00441 
00442 TQString tdeEAPTypeToNMEAPType(TDENetworkIEEE8021xType::TDENetworkIEEE8021xType eaptype) {
00443     TQString ret = "";
00444 
00445     if (eaptype == TDENetworkIEEE8021xType::None) {
00446         ret = "";
00447     }
00448     else if (eaptype == TDENetworkIEEE8021xType::LEAP) {
00449         ret = "leap";
00450     }
00451     else if (eaptype == TDENetworkIEEE8021xType::MD5) {
00452         ret = "md5";
00453     }
00454     else if (eaptype == TDENetworkIEEE8021xType::PAP) {
00455         ret = "pap";
00456     }
00457     else if (eaptype == TDENetworkIEEE8021xType::CHAP) {
00458         ret = "chap";
00459     }
00460     else if (eaptype == TDENetworkIEEE8021xType::MSCHAP) {
00461         ret = "mschap";
00462     }
00463     else if (eaptype == TDENetworkIEEE8021xType::MSCHAPV2) {
00464         ret = "mschapv2";
00465     }
00466     else if (eaptype == TDENetworkIEEE8021xType::Fast) {
00467         ret = "fast";
00468     }
00469     else if (eaptype == TDENetworkIEEE8021xType::PSK) {
00470         ret = "psk";
00471     }
00472     else if (eaptype == TDENetworkIEEE8021xType::PAX) {
00473         ret = "pax";
00474     }
00475     else if (eaptype == TDENetworkIEEE8021xType::SAKE) {
00476         ret = "sake";
00477     }
00478     else if (eaptype == TDENetworkIEEE8021xType::GPSK) {
00479         ret = "gpsk";
00480     }
00481     else if (eaptype == TDENetworkIEEE8021xType::TLS) {
00482         ret = "tls";
00483     }
00484     else if (eaptype == TDENetworkIEEE8021xType::PEAP) {
00485         ret = "peap";
00486     }
00487     else if (eaptype == TDENetworkIEEE8021xType::TTLS) {
00488         ret = "ttls";
00489     }
00490     else if (eaptype == TDENetworkIEEE8021xType::SIM) {
00491         ret = "sim";
00492     }
00493     else if (eaptype == TDENetworkIEEE8021xType::GTC) {
00494         ret = "gtc";
00495     }
00496     else if (eaptype == TDENetworkIEEE8021xType::OTP) {
00497         ret = "otp";
00498     }
00499     else {
00500         PRINT_ERROR(TQString("unknown TDE EAP type %d requested in new or updated connection").arg(eaptype))
00501     }
00502 
00503     return ret;
00504 }
00505 
00506 TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags nmEAPFastFlagsToTDEEAPFastFlags(TQString nm) {
00507     TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags ret = TDENetworkIEEE8021xFastFlags::AllowUnauthenticated | TDENetworkIEEE8021xFastFlags::AllowAuthenticated;
00508 
00509     unsigned int nm_int = nm.toUInt();
00510     if (nm_int == NM_EAP_FAST_PROVISIONING_DISABLED) {
00511         ret = TDENetworkIEEE8021xFastFlags::None;
00512     }
00513     else if (nm_int == NM_EAP_FAST_PROVISIONING_UNAUTHONLY) {
00514         ret = TDENetworkIEEE8021xFastFlags::AllowUnauthenticated;
00515     }
00516     else if (nm_int == NM_EAP_FAST_PROVISIONING_AUTHONLY) {
00517         ret = TDENetworkIEEE8021xFastFlags::AllowAuthenticated;
00518     }
00519     else if (nm_int == NM_EAP_FAST_PROVISIONING_BOTH) {
00520         ret = TDENetworkIEEE8021xFastFlags::AllowUnauthenticated | TDENetworkIEEE8021xFastFlags::AllowAuthenticated;
00521     }
00522     else {
00523         PRINT_ERROR(TQString("unknown EAP fast flag %s requested in existing connection").arg(nm.lower()))
00524     }
00525 
00526     return ret;
00527 }
00528 
00529 TQString tdeEAPFastFlagsToNMEAPFastFlags(TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags eaptype) {
00530     TQString ret = "";
00531 
00532     if ((eaptype & TDENetworkIEEE8021xFastFlags::AllowUnauthenticated) && (eaptype & TDENetworkIEEE8021xFastFlags::AllowAuthenticated)) {
00533         ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_BOTH);
00534     }
00535     else if (eaptype & TDENetworkIEEE8021xFastFlags::AllowAuthenticated) {
00536         ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_AUTHONLY);
00537     }
00538     else if (eaptype & TDENetworkIEEE8021xFastFlags::AllowUnauthenticated) {
00539         ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_UNAUTHONLY);
00540     }
00541     else {
00542         ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_DISABLED);
00543     }
00544 
00545     return ret;
00546 }
00547 
00548 TDEWiFiMode::TDEWiFiMode nmWiFiModeToTDEWiFiMode(TQString nm) {
00549     TDEWiFiMode::TDEWiFiMode ret = TDEWiFiMode::Infrastructure;
00550 
00551     if (nm.lower() == "infrastructure") {
00552         ret = TDEWiFiMode::Infrastructure;
00553     }
00554     else if (nm.lower() == "adhoc") {
00555         ret = TDEWiFiMode::AdHoc;
00556     }
00557 
00558     return ret;
00559 }
00560 
00561 TQString tdeWiFiModeToNMWiFiMode(TDEWiFiMode::TDEWiFiMode mode) {
00562     TQString ret;
00563 
00564     if (mode == TDEWiFiMode::Infrastructure) {
00565         ret = "infrastructure";
00566     }
00567     else if (mode == TDEWiFiMode::AdHoc) {
00568         ret = "adhoc";
00569     }
00570 
00571     return ret;
00572 }
00573 
00574 TDEWiFiMode::TDEWiFiMode nmWiFiModeToTDEWiFiMode(TQ_UINT32 nm) {
00575     TDEWiFiMode::TDEWiFiMode ret = TDEWiFiMode::Infrastructure;
00576 
00577     if (nm == NM_802_11_MODE_INFRASTRUCTURE) {
00578         ret = TDEWiFiMode::Infrastructure;
00579     }
00580     else if (nm == NM_802_11_MODE_ADHOC) {
00581         ret = TDEWiFiMode::AdHoc;
00582     }
00583 
00584     return ret;
00585 }
00586 
00587 TDENetworkWiFiClientFlags::TDENetworkWiFiClientFlags tdeWiFiFlagsToNMWiFiFlags(TQ_UINT32 nm) {
00588     TDENetworkWiFiClientFlags::TDENetworkWiFiClientFlags ret = TDENetworkWiFiClientFlags::None;
00589 
00590     if (nm & NM_802_11_DEVICE_CAP_CIPHER_WEP40) {
00591         ret | TDENetworkWiFiClientFlags::CipherWEP40;
00592     }
00593     if (nm & NM_802_11_DEVICE_CAP_CIPHER_WEP104) {
00594         ret | TDENetworkWiFiClientFlags::CipherWEP104;
00595     }
00596     if (nm & NM_802_11_DEVICE_CAP_CIPHER_TKIP) {
00597         ret | TDENetworkWiFiClientFlags::CipherTKIP;
00598     }
00599     if (nm & NM_802_11_DEVICE_CAP_CIPHER_CCMP) {
00600         ret | TDENetworkWiFiClientFlags::CipherCCMP;
00601     }
00602     if (nm & NM_802_11_DEVICE_CAP_WPA) {
00603         ret | TDENetworkWiFiClientFlags::CipherWPA;
00604     }
00605     if (nm & NM_802_11_DEVICE_CAP_RSN) {
00606         ret | TDENetworkWiFiClientFlags::CipherRSN;
00607     }
00608 
00609     return ret;
00610 }
00611 
00612 TDEBluetoothConnectionType::TDEBluetoothConnectionType nmBluetoothModeToTDEBluetoothMode(TQString nm) {
00613     TDEBluetoothConnectionType::TDEBluetoothConnectionType ret = TDEBluetoothConnectionType::PAN;
00614 
00615     if (nm.lower() == "dun") {
00616         ret = TDEBluetoothConnectionType::DUN;
00617     }
00618     else if (nm.lower() == "panu") {
00619         ret = TDEBluetoothConnectionType::PAN;
00620     }
00621 
00622     return ret;
00623 }
00624 
00625 TQString tdeBluetoothModeToNMBluetoothMode(TDEBluetoothConnectionType::TDEBluetoothConnectionType type) {
00626     TQString ret;
00627 
00628     if (type == TDEBluetoothConnectionType::DUN) {
00629         ret = "dun";
00630     }
00631     else if (type == TDEBluetoothConnectionType::PAN) {
00632         ret = "panu";
00633     }
00634 
00635     return ret;
00636 }
00637 
00638 TDEGSMNetworkType::TDEGSMNetworkType nmGSMModeToTDEGSMMode(TQ_INT32 nm) {
00639     TDEGSMNetworkType::TDEGSMNetworkType ret = TDEGSMNetworkType::Any;
00640 
00641     if (nm == NM_GSM_3G_ONLY) {
00642         ret = TDEGSMNetworkType::Only3G;
00643     }
00644     else if (nm == NM_GSM_GPRS_EDGE_ONLY) {
00645         ret = TDEGSMNetworkType::GPRSEdge;
00646     }
00647     else if (nm == NM_GSM_PREFER_3G) {
00648         ret = TDEGSMNetworkType::Prefer3G;
00649     }
00650     else if (nm == NM_GSM_PREFER_2G) {
00651         ret = TDEGSMNetworkType::Prefer2G;
00652     }
00653 
00654     return ret;
00655 }
00656 
00657 TQ_INT32 tdeGSMModeToNMGSMMode(TDEGSMNetworkType::TDEGSMNetworkType type) {
00658     TQ_INT32 ret = -1;
00659 
00660     if (type == TDEGSMNetworkType::Only3G) {
00661         ret = NM_GSM_3G_ONLY;
00662     }
00663     else if (type == TDEGSMNetworkType::GPRSEdge) {
00664         ret = NM_GSM_GPRS_EDGE_ONLY;
00665     }
00666     else if (type == TDEGSMNetworkType::Prefer3G) {
00667         ret = NM_GSM_PREFER_3G;
00668     }
00669     else if (type == TDEGSMNetworkType::Prefer2G) {
00670         ret = NM_GSM_PREFER_2G;
00671     }
00672 
00673     return ret;
00674 }
00675 
00676 TDEWiFiFrequencyBand::TDEWiFiFrequencyBand nmWiFiFrequencyBandToTDEWiFiFrequencyBand(TQString nm) {
00677     TDEWiFiFrequencyBand::TDEWiFiFrequencyBand ret = TDEWiFiFrequencyBand::Other;
00678 
00679     if (nm.lower() == "") {
00680         ret = TDEWiFiFrequencyBand::None;
00681     }
00682     else if (nm.lower() == "bg") {
00683         ret = TDEWiFiFrequencyBand::Band2_4GHz;
00684     }
00685     else if (nm.lower() == "a") {
00686         ret = TDEWiFiFrequencyBand::Band5GHz;
00687     }
00688 
00689     return ret;
00690 }
00691 
00692 TQString tdeWiFiFrequencyBandToNMWiFiFrequencyBand(TDEWiFiFrequencyBand::TDEWiFiFrequencyBand mode) {
00693     TQString ret;
00694 
00695     if (mode == TDEWiFiFrequencyBand::None) {
00696         ret = TQString::null;
00697     }
00698     else if (mode == TDEWiFiFrequencyBand::Band2_4GHz) {
00699         ret = "bg";
00700     }
00701     else if (mode == TDEWiFiFrequencyBand::Band5GHz) {
00702         ret = "a";
00703     }
00704 
00705     return ret;
00706 }
00707 
00708 TDENetworkWiFiKeyType::TDENetworkWiFiKeyType nmWiFiKeyTypeToTDEWiFiKeyType(TQString nm) {
00709     TDENetworkWiFiKeyType::TDENetworkWiFiKeyType ret = TDENetworkWiFiKeyType::Other;
00710 
00711     if (nm.lower() == "none") {
00712         ret = TDENetworkWiFiKeyType::WEP;
00713     }
00714     else if (nm.lower() == "ieee8021x") {
00715         ret = TDENetworkWiFiKeyType::DynamicWEP;
00716     }
00717     else if (nm.lower() == "wpa-none") {
00718         ret = TDENetworkWiFiKeyType::WPAAdHoc;
00719     }
00720     else if (nm.lower() == "wpa-psk") {
00721         ret = TDENetworkWiFiKeyType::WPAInfrastructure;
00722     }
00723     else if (nm.lower() == "wpa-eap") {
00724         ret = TDENetworkWiFiKeyType::WPAEnterprise;
00725     }
00726 
00727     return ret;
00728 }
00729 
00730 TQString tdeWiFiKeyTypeToNMWiFiKeyType(TDENetworkWiFiKeyType::TDENetworkWiFiKeyType type) {
00731     TQString ret;
00732 
00733     if (type == TDENetworkWiFiKeyType::WEP) {
00734         return "none";
00735     }
00736     else if (type == TDENetworkWiFiKeyType::DynamicWEP) {
00737         return "ieee8021x";
00738     }
00739     else if (type == TDENetworkWiFiKeyType::WPAAdHoc) {
00740         return "wpa-none";
00741     }
00742     else if (type == TDENetworkWiFiKeyType::WPAInfrastructure) {
00743         return "wpa-psk";
00744     }
00745     else if (type == TDENetworkWiFiKeyType::WPAEnterprise) {
00746         return "wpa-eap";
00747     }
00748 
00749     return ret;
00750 }
00751 
00752 TDENetworkWiFiAuthType::TDENetworkWiFiAuthType nmWiFiAuthTypeToTDEWiFiAuthType(TQString nm) {
00753     TDENetworkWiFiAuthType::TDENetworkWiFiAuthType ret = TDENetworkWiFiAuthType::Other;
00754 
00755     if (nm.lower() == "open") {
00756         ret = TDENetworkWiFiAuthType::Open;
00757     }
00758     else if (nm.lower() == "shared") {
00759         ret = TDENetworkWiFiAuthType::Shared;
00760     }
00761     else if (nm.lower() == "leap") {
00762         ret = TDENetworkWiFiAuthType::LEAP;
00763     }
00764 
00765     return ret;
00766 }
00767 
00768 TQString tdeWiFiAuthTypeToNMWiFiAuthType(TDENetworkWiFiAuthType::TDENetworkWiFiAuthType type) {
00769     TQString ret;
00770 
00771     if (type == TDENetworkWiFiAuthType::Open) {
00772         return "open";
00773     }
00774     else if (type == TDENetworkWiFiAuthType::Shared) {
00775         return "shared";
00776     }
00777     else if (type == TDENetworkWiFiAuthType::LEAP) {
00778         return "leap";
00779     }
00780 
00781     return ret;
00782 }
00783 
00784 TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags nmWiFiWPAVersionToTDEWiFiWPAVersion(TQStringList nm) {
00785     TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags ret = TDENetworkWiFiWPAVersionFlags::None;
00786 
00787     if ((nm.contains("wpa") && nm.contains("rsn")) || (nm.count() < 1)) {
00788         ret |= TDENetworkWiFiWPAVersionFlags::Any;
00789     }
00790     else if (nm.contains("wpa")) {
00791         ret |= TDENetworkWiFiWPAVersionFlags::WPA;
00792     }
00793     else if (nm.contains("rsn")) {
00794         ret |= TDENetworkWiFiWPAVersionFlags::RSN;
00795     }
00796 
00797     return ret;
00798 }
00799 
00800 TQStringList tdeWiFiWPAVersionToNMWiFiWPAVersion(TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags type) {
00801     TQStringList ret;
00802 
00803     if (type & TDENetworkWiFiWPAVersionFlags::WPA) {
00804         ret.append("wpa");
00805     }
00806     if (type & TDENetworkWiFiWPAVersionFlags::RSN) {
00807         ret.append("rsn");
00808     }
00809 
00810     return ret;
00811 }
00812 
00813 TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher nmWiFiCipherToTDEWiFiCipher(TQString nm) {
00814     TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher ret = TDENetworkWiFiConnectionCipher::None;
00815 
00816     if (nm.lower() == "wep40") {
00817         ret = TDENetworkWiFiConnectionCipher::CipherWEP40;
00818     }
00819     else if (nm.lower() == "wep104") {
00820         ret = TDENetworkWiFiConnectionCipher::CipherWEP104;
00821     }
00822     else if (nm.lower() == "tkip") {
00823         ret = TDENetworkWiFiConnectionCipher::CipherTKIP;
00824     }
00825     else if (nm.lower() == "ccmp") {
00826         ret = TDENetworkWiFiConnectionCipher::CipherCCMP;
00827     }
00828 
00829     return ret;
00830 }
00831 
00832 TQString tdeWiFiCipherToNMWiFiCipher(TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher cipher) {
00833     TQString ret;
00834 
00835     if (cipher == TDENetworkWiFiConnectionCipher::CipherWEP40) {
00836         ret = "wep40";
00837     }
00838     else if (cipher == TDENetworkWiFiConnectionCipher::CipherWEP104) {
00839         ret = "wep104";
00840     }
00841     else if (cipher == TDENetworkWiFiConnectionCipher::CipherTKIP) {
00842         ret = "tkip";
00843     }
00844     else if (cipher == TDENetworkWiFiConnectionCipher::CipherCCMP) {
00845         ret = "ccmp";
00846     }
00847 
00848     return ret;
00849 }
00850 
00851 TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType nmSlaveTypeToTDESlaveType(TQString nm) {
00852     TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType ret = TDENetworkSlaveDeviceType::None;
00853 
00854     if (nm.lower() == "bond") {
00855         ret = TDENetworkSlaveDeviceType::Bond;
00856     }
00857 
00858     return ret;
00859 }
00860 
00861 TQString tdeSlaveTypeToNMSlaveType(TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType slavetype) {
00862     TQString ret;
00863 
00864     if (slavetype == TDENetworkSlaveDeviceType::Bond) {
00865         ret = "bond";
00866     }
00867 
00868     return ret;
00869 }
00870 
00871 TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags nmPasswordFlagsToTDEPasswordFlags(unsigned int nm) {
00872     TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags ret = TDENetworkPasswordHandlingFlags::None;
00873 
00874     if (nm & NM_PASSWORD_SECRET_AGENTOWNED) {
00875         ret |= TDENetworkPasswordHandlingFlags::ExternalStorage;
00876     }
00877     if (nm & NM_PASSWORD_SECRET_NOTSAVED) {
00878         ret |= TDENetworkPasswordHandlingFlags::NoSave;
00879     }
00880     if (nm & NM_PASSWORD_SECRET_NOTREQUIRED) {
00881         ret |= TDENetworkPasswordHandlingFlags::NoPrompt;
00882     }
00883 
00884     return ret;
00885 }
00886 
00887 unsigned int tdePasswordFlagsToNMPasswordFlags(TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags flags) {
00888     unsigned int ret = 0;
00889 
00890     if (flags & TDENetworkPasswordHandlingFlags::ExternalStorage) {
00891         ret |= NM_PASSWORD_SECRET_AGENTOWNED;
00892     }
00893     if (flags & TDENetworkPasswordHandlingFlags::NoSave) {
00894         ret |= NM_PASSWORD_SECRET_NOTSAVED;
00895     }
00896     if (flags & TDENetworkPasswordHandlingFlags::NoPrompt) {
00897         ret |= NM_PASSWORD_SECRET_NOTREQUIRED;
00898     }
00899 
00900     return ret;
00901 }
00902 
00903 TDENetworkVLANFlags::TDENetworkVLANFlags nmVLANFlagsToTDEVLANFlags(unsigned int nm) {
00904     TDENetworkVLANFlags::TDENetworkVLANFlags ret = TDENetworkVLANFlags::None;
00905 
00906     if (nm & NM_VLAN_REORDER_PACKET_HEADERS) {
00907         ret |= TDENetworkVLANFlags::ReorderPacketHeaders;
00908     }
00909     if (nm & NM_VLAN_USE_GVRP) {
00910         ret |= TDENetworkVLANFlags::UseGVRP;
00911     }
00912     if (nm & NM_VLAN_LOOSE_BINDING) {
00913         ret |= TDENetworkVLANFlags::LooseBinding;
00914     }
00915 
00916     return ret;
00917 }
00918 
00919 unsigned int tdeVLANFlagsToNMVLANFlags(TDENetworkVLANFlags::TDENetworkVLANFlags flags) {
00920     unsigned int ret = 0;
00921 
00922     if (flags & TDENetworkVLANFlags::ReorderPacketHeaders) {
00923         ret |= NM_VLAN_REORDER_PACKET_HEADERS;
00924     }
00925     if (flags & TDENetworkVLANFlags::UseGVRP) {
00926         ret |= NM_VLAN_USE_GVRP;
00927     }
00928     if (flags & TDENetworkVLANFlags::LooseBinding) {
00929         ret |= NM_VLAN_LOOSE_BINDING;
00930     }
00931 
00932     return ret;
00933 }
00934 
00935 TDENetworkParity::TDENetworkParity nmParityToTDEParity(char nm) {
00936     TDENetworkParity::TDENetworkParity ret = TDENetworkParity::None;
00937 
00938     if (nm == 'E') {
00939         ret = TDENetworkParity::Even;
00940     }
00941     else if (nm == 'o') {
00942         ret = TDENetworkParity::Odd;
00943     }
00944 
00945     return ret;
00946 }
00947 
00948 char tdeParityToNMParity(TDENetworkParity::TDENetworkParity parity) {
00949     char ret = 'n';
00950 
00951     if (parity == TDENetworkParity::Even) {
00952         ret = 'E';
00953     }
00954     else if (parity == TDENetworkParity::Odd) {
00955         ret = 'o';
00956     }
00957 
00958     return ret;
00959 }
00960 
00961 TDENetworkWepKeyType::TDENetworkWepKeyType nmWepKeyTypeToTDEWepKeyType(unsigned int nm, TQString key=TQString::null) {
00962     TDENetworkWepKeyType::TDENetworkWepKeyType ret = TDENetworkWepKeyType::Hexadecimal;
00963 
00964     if (nm == NM_WEP_TYPE_HEXADECIMAL) {
00965         if (key.isNull()) {
00966             ret = TDENetworkWepKeyType::Hexadecimal;
00967         }
00968         else {
00969             if ((key.length() == 10) || (key.length() == 26)) {
00970                 ret = TDENetworkWepKeyType::Hexadecimal;
00971             }
00972             else {
00973                 ret = TDENetworkWepKeyType::Ascii;
00974             }
00975         }
00976     }
00977     else if (nm == NM_WEP_TYPE_PASSPHRASE) {
00978         ret = TDENetworkWepKeyType::Passphrase;
00979     }
00980 
00981     return ret;
00982 }
00983 
00984 unsigned int tdeWepKeyTypeToNMWepKeyType(TDENetworkWepKeyType::TDENetworkWepKeyType type) {
00985     unsigned int ret = 0;
00986 
00987     if (type == TDENetworkWepKeyType::Hexadecimal) {
00988         ret = NM_WEP_TYPE_HEXADECIMAL;
00989     }
00990     else if (type == TDENetworkWepKeyType::Ascii) {
00991         ret = NM_WEP_TYPE_HEXADECIMAL;
00992     }
00993     else if (type == TDENetworkWepKeyType::Passphrase) {
00994         ret = NM_WEP_TYPE_PASSPHRASE;
00995     }
00996 
00997     return ret;
00998 }
00999 
01000 TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags nmCapabilityFlagsToTDECapabilityFlags(unsigned int nm) {
01001     TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags ret = TDENetworkDeviceCapabilityFlags::None;
01002 
01003     if (nm & NM_DEVICE_CAP_NM_SUPPORTED) {
01004         ret |= TDENetworkDeviceCapabilityFlags::Supported;
01005     }
01006     if (nm & NM_DEVICE_CAP_CARRIER_DETECT) {
01007         ret |= TDENetworkDeviceCapabilityFlags::CanDetectLink;
01008     }
01009 
01010     return ret;
01011 }
01012 
01013 unsigned int tdeCapabilityFlagsToNMCapabilityFlags(TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags flags) {
01014     unsigned int ret = 0;
01015 
01016     if (flags & TDENetworkDeviceCapabilityFlags::Supported) {
01017         ret |= NM_DEVICE_CAP_NM_SUPPORTED;
01018     }
01019     if (flags & TDENetworkDeviceCapabilityFlags::CanDetectLink) {
01020         ret |= NM_DEVICE_CAP_CARRIER_DETECT;
01021     }
01022 
01023     return ret;
01024 }
01025 
01026 TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags nmAPSecFlagsToTDEAPSecFlags(unsigned int genflags, unsigned int nm) {
01027     TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags ret = TDENetworkWiFiAPFlags::None;
01028 
01029     if (genflags & NM_ACCESS_POINT_CAP_PRIVACY) {
01030         ret |= TDENetworkWiFiAPFlags::PrivacySupport;
01031     }
01032 
01033     if (nm & NM_ACCESS_POINT_SEC_PAIR_WEP40) {
01034         ret |= TDENetworkWiFiAPFlags::PairWEP40;
01035     }
01036     if (nm & NM_ACCESS_POINT_SEC_PAIR_WEP104) {
01037         ret |= TDENetworkWiFiAPFlags::PairWEP104;
01038     }
01039     if (nm & NM_ACCESS_POINT_SEC_PAIR_TKIP) {
01040         ret |= TDENetworkWiFiAPFlags::PairTKIP;
01041     }
01042     if (nm & NM_ACCESS_POINT_SEC_PAIR_CCMP) {
01043         ret |= TDENetworkWiFiAPFlags::PairCCMP;
01044     }
01045     if (nm & NM_ACCESS_POINT_SEC_GROUP_WEP40) {
01046         ret |= TDENetworkWiFiAPFlags::GroupWEP40;
01047     }
01048     if (nm & NM_ACCESS_POINT_SEC_GROUP_WEP104) {
01049         ret |= TDENetworkWiFiAPFlags::GroupWEP104;
01050     }
01051     if (nm & NM_ACCESS_POINT_SEC_GROUP_TKIP) {
01052         ret |= TDENetworkWiFiAPFlags::GroupTKIP;
01053     }
01054     if (nm & NM_ACCESS_POINT_SEC_GROUP_CCMP) {
01055         ret |= TDENetworkWiFiAPFlags::GroupCCMP;
01056     }
01057     if (nm & NM_ACCESS_POINT_SEC_KEY_MGMT_PSK) {
01058         ret |= TDENetworkWiFiAPFlags::KeyManagementPSK;
01059     }
01060     if (nm & NM_ACCESS_POINT_SEC_KEY_MGMT_802_1X) {
01061         ret |= TDENetworkWiFiAPFlags::KeyManagement80211;
01062     }
01063 
01064     return ret;
01065 }
01066 
01067 unsigned int tdeAPSecFlagsToNMAPGenSecFlags(TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags flags) {
01068     unsigned int ret = 0;
01069 
01070     if (flags & TDENetworkWiFiAPFlags::PrivacySupport) {
01071         ret |= NM_ACCESS_POINT_CAP_PRIVACY;
01072     }
01073 
01074     return ret;
01075 }
01076 
01077 unsigned int tdeAPSecFlagsToNMAPSecFlags(TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags flags) {
01078     unsigned int ret = 0;
01079 
01080     if (flags & TDENetworkWiFiAPFlags::PairWEP40) {
01081         ret |= NM_ACCESS_POINT_SEC_PAIR_WEP40;
01082     }
01083     if (flags & TDENetworkWiFiAPFlags::PairWEP104) {
01084         ret |= NM_ACCESS_POINT_SEC_PAIR_WEP104;
01085     }
01086     if (flags & TDENetworkWiFiAPFlags::PairTKIP) {
01087         ret |= NM_ACCESS_POINT_SEC_PAIR_TKIP;
01088     }
01089     if (flags & TDENetworkWiFiAPFlags::PairCCMP) {
01090         ret |= NM_ACCESS_POINT_SEC_PAIR_CCMP;
01091     }
01092     if (flags & TDENetworkWiFiAPFlags::GroupWEP40) {
01093         ret |= NM_ACCESS_POINT_SEC_GROUP_WEP40;
01094     }
01095     if (flags & TDENetworkWiFiAPFlags::GroupWEP104) {
01096         ret |= NM_ACCESS_POINT_SEC_GROUP_WEP104;
01097     }
01098     if (flags & TDENetworkWiFiAPFlags::GroupTKIP) {
01099         ret |= NM_ACCESS_POINT_SEC_GROUP_TKIP;
01100     }
01101     if (flags & TDENetworkWiFiAPFlags::GroupCCMP) {
01102         ret |= NM_ACCESS_POINT_SEC_GROUP_CCMP;
01103     }
01104     if (flags & TDENetworkWiFiAPFlags::KeyManagementPSK) {
01105         ret |= NM_ACCESS_POINT_SEC_KEY_MGMT_PSK;
01106     }
01107     if (flags & TDENetworkWiFiAPFlags::KeyManagement80211) {
01108         ret |= NM_ACCESS_POINT_SEC_KEY_MGMT_802_1X;
01109     }
01110 
01111     return ret;
01112 }
01113 
01114 TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode nmIBTransportToTDEIBTransport(TQString nm) {
01115     TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode ret = TDENetworkInfinibandTransportMode::Other;
01116 
01117     if (nm.lower() == "datagram") {
01118         ret = TDENetworkInfinibandTransportMode::Datagram;
01119     }
01120     else if (nm.lower() == "connected") {
01121         ret = TDENetworkInfinibandTransportMode::Connected;
01122     }
01123 
01124     return ret;
01125 }
01126 
01127 TQString tdeIBTransportToNMIBTransport(TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode mode) {
01128     TQString ret;
01129 
01130     if (mode == TDENetworkInfinibandTransportMode::Datagram) {
01131         ret = "datagram";
01132     }
01133     else if (mode == TDENetworkInfinibandTransportMode::Connected) {
01134         ret = "connected";
01135     }
01136 
01137     return ret;
01138 }
01139 
01140 TQString TDENetworkConnectionManager_BackendNM::deviceInterfaceString(TQString deviceNode) {
01141     if (d->m_networkManagerProxy) {
01142         TQT_DBusObjectPathList devices;
01143         TQT_DBusError error;
01144         bool ret;
01145         ret = d->m_networkManagerProxy->GetDevices(devices, error);
01146         if (ret) {
01147             TQT_DBusObjectPathList::iterator it;
01148             for (it = devices.begin(); it != devices.end(); ++it) {
01149                 DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, (*it));
01150                 genericDevice.setConnection(TQT_DBusConnection::systemBus());
01151                 TQString deviceInterface = genericDevice.getInterface(error);
01152                 if (error.isValid()) {
01153                     // Error!
01154                     PRINT_ERROR((error.name() + ": " + error.message()))
01155                     break;
01156                 }
01157                 else if (deviceInterface == deviceNode) {
01158                     return (*it);
01159                 }
01160             }
01161             return TQString::null;
01162         }
01163         else {
01164             // Error!
01165             PRINT_ERROR((error.name() + ": " + error.message()))
01166             return TQString::null;
01167         }
01168     }
01169     else {
01170         return TQString::null;
01171     }
01172 }
01173 
01174 TQString tdeDeviceUUIDForGenericDevice(TQT_DBusObjectPath path) {
01175     TQT_DBusError error;
01176     DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, path);
01177     genericDevice.setConnection(TQT_DBusConnection::systemBus());
01178     TQString deviceInterface = genericDevice.getInterface(error);
01179     if (error.isValid()) {
01180         return TQString::null;
01181     }
01182 
01183     TDEHardwareDevices *hwdevices = TDEGlobal::hardwareDevices();
01184     if (!hwdevices) {
01185         return TQString::null;
01186     }
01187 
01188     TDEGenericHardwareList devices = hwdevices->listByDeviceClass(TDEGenericDeviceType::Network);
01189     for (TDEGenericHardwareList::iterator it = devices.begin(); it != devices.end(); ++it) {
01190         TDENetworkDevice* dev = dynamic_cast<TDENetworkDevice*>(*it);
01191         if (dev) {
01192             if (deviceInterface == dev->deviceNode()) {
01193                 return dev->uniqueID();
01194             }
01195         }
01196     }
01197 
01198     return TQString::null;
01199 }
01200 
01201 TDENetworkConnectionManager_BackendNM_DBusSignalReceiver::TDENetworkConnectionManager_BackendNM_DBusSignalReceiver(TDENetworkConnectionManager_BackendNMPrivate* parent) : m_parent(parent) {
01202     //
01203 }
01204 
01205 TDENetworkConnectionManager_BackendNM_DBusSignalReceiver::~TDENetworkConnectionManager_BackendNM_DBusSignalReceiver() {
01206     //
01207 }
01208 
01209 void TDENetworkConnectionManager_BackendNM_DBusSignalReceiver::dbusSignal(const TQT_DBusMessage& message) {
01210     if (message.type() == TQT_DBusMessage::SignalMessage) {
01211         TQString interface = message.interface();
01212         TQString sender = message.sender();
01213         TQString member = message.member();
01214         TQString path = message.path();
01215 
01216 //      printf("[DEBUG] In dbusSignal: sender: %s, member: %s, interface: %s, path: %s, parent path: %s\n", sender.ascii(), member.ascii(), interface.ascii(), path.ascii(), m_parent->m_dbusDeviceString.ascii()); fflush(stdout);
01217 
01218         if (interface == NM_VPN_DBUS_CONNECTION_SERVICE) {
01219             if (member == "VpnStateChanged") {
01220                 // Demarshal data
01221                 TQ_UINT32 state = message[0].toUInt32();
01222                 TQ_UINT32 reason = message[1].toUInt32();
01223                 if (state == NM_VPN_STATE_FAILED) {
01224                     m_parent->internalProcessVPNFailure(reason);
01225                 }
01226             }
01227         }
01228         else if (interface == NM_DBUS_DEVICE_SERVICE) {
01229             if (path == m_parent->m_dbusDeviceString) {
01230                 if (member == "StateChanged") {
01231                     // Demarshal data
01232                     TQ_UINT32 new_state = message[0].toUInt32();
01233                     TQ_UINT32 old_state = message[1].toUInt32();
01234                     TQ_UINT32 reason = message[2].toUInt32();
01235                     m_parent->internalProcessDeviceStateChanged(new_state, old_state, reason);
01236                 }
01237             }
01238         }
01239     }
01240 }
01241 
01242 TDENetworkConnectionManager_BackendNM::TDENetworkConnectionManager_BackendNM(TDENetworkDevice* networkDevice) : TDENetworkConnectionManager(networkDevice) {
01243     d = new TDENetworkConnectionManager_BackendNMPrivate(this);
01244 
01245     // Set up proxy interfaces
01246     d->m_networkManagerProxy = new DBus::NetworkManagerProxy(NM_DBUS_SERVICE, NM_DBUS_PATH);
01247     d->m_networkManagerProxy->setConnection(TQT_DBusConnection::systemBus());
01248     d->m_networkManagerSettings = new DBus::SettingsInterface(NM_DBUS_SERVICE, NM_DBUS_PATH_SETTINGS);
01249     d->m_networkManagerSettings->setConnection(TQT_DBusConnection::systemBus());
01250     d->m_vpnProxy = new DBus::VPNPluginProxy(NM_VPN_DBUS_PLUGIN_SERVICE, NM_VPN_DBUS_PLUGIN_PATH);
01251     d->m_vpnProxy->setConnection(TQT_DBusConnection::systemBus());
01252 
01253     d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
01254     if (!d->m_dbusDeviceString.isEmpty()) {
01255         d->m_networkDeviceProxy = new DBus::DeviceProxy(NM_DBUS_SERVICE, d->m_dbusDeviceString);
01256         d->m_networkDeviceProxy->setConnection(TQT_DBusConnection::systemBus());
01257         if (deviceType() == TDENetworkDeviceType::WiFi) {
01258             d->m_wiFiDeviceProxy = new DBus::WiFiDeviceProxy(NM_DBUS_SERVICE, d->m_dbusDeviceString);
01259             d->m_wiFiDeviceProxy->setConnection(TQT_DBusConnection::systemBus());
01260         }
01261     }
01262 
01263     // Connect global signals
01264     connect(d->m_networkManagerProxy, SIGNAL(StateChanged(TQ_UINT32)), d, SLOT(internalProcessGlobalStateChanged(TQ_UINT32)));
01265 
01266     // Connect VPN signals
01267     if (d->m_vpnProxy) {
01268         connect(d->m_vpnProxy, SIGNAL(StateChanged(TQ_UINT32)), d, SLOT(internalProcessVPNStateChanged(TQ_UINT32)));
01269         connect(d->m_vpnProxy, SIGNAL(LoginBanner(const TQString&)), d, SLOT(internalProcessVPNLoginBanner(const TQString&)));
01270         connect(d->m_vpnProxy, SIGNAL(Failure(TQ_UINT32)), d, SLOT(internalProcessVPNFailure(TQ_UINT32)));
01271     }
01272 
01273     // Connect local signals
01274     if (d->m_networkDeviceProxy) {
01275         connect(d->m_networkDeviceProxy, SIGNAL(StateChanged(TQ_UINT32, TQ_UINT32, TQ_UINT32)), d, SLOT(internalProcessDeviceStateChanged(TQ_UINT32, TQ_UINT32, TQ_UINT32)));
01276     }
01277     if (d->m_wiFiDeviceProxy) {
01278         connect(d->m_wiFiDeviceProxy, SIGNAL(AccessPointAdded(const TQT_DBusObjectPath&)), d, SLOT(internalProcessWiFiAccessPointAdded(const TQT_DBusObjectPath&)));
01279         connect(d->m_wiFiDeviceProxy, SIGNAL(AccessPointRemoved(const TQT_DBusObjectPath&)), d, SLOT(internalProcessWiFiAccessPointRemoved(const TQT_DBusObjectPath&)));
01280         connect(d->m_wiFiDeviceProxy, SIGNAL(PropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)), d, SLOT(internalProcessWiFiPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)));
01281     }
01282 
01283     // Create public lists
01284     m_connectionList = new TDENetworkConnectionList;
01285     m_hwNeighborList = new TDENetworkHWNeighborList;
01286 
01287     // Run site survey to populate neighbor list with initial data
01288     siteSurvey();
01289 }
01290 
01291 TDENetworkConnectionManager_BackendNM::~TDENetworkConnectionManager_BackendNM() {
01292     // Destroy public lists
01293     clearTDENetworkConnectionList();
01294     delete m_connectionList;
01295     clearTDENetworkHWNeighborList();
01296     delete m_hwNeighborList;
01297 
01298     // Tear down proxy interfaces
01299     if (d->m_networkManagerProxy) delete d->m_networkManagerProxy;
01300     if (d->m_networkManagerSettings) delete d->m_networkManagerSettings;
01301     if (d->m_networkDeviceProxy) delete d->m_networkDeviceProxy;
01302 
01303     delete d;
01304 }
01305 
01306 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessGlobalStateChanged(TQ_UINT32 state) {
01307     m_parent->internalNetworkConnectionStateChanged(m_parent->backendStatus());
01308 }
01309 
01310 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessVPNStateChanged(TQ_UINT32 state) {
01311     m_parent->internalNetworkConnectionStateChanged(m_parent->backendStatus());
01312 }
01313 
01314 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessVPNLoginBanner(const TQString& banner) {
01315     m_parent->internalVpnEvent(TDENetworkVPNEventType::LoginBanner, banner);
01316 }
01317 
01318 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessVPNFailure(TQ_UINT32 reason) {
01319     // FIXME
01320     // This should provide a plain-text interpretation of the NetworkManager-specific error code
01321     m_parent->internalVpnEvent(TDENetworkVPNEventType::Failure, TQString("VPN connection attempt failed!<br>NetworkManager returned error %1.").arg(reason));
01322 }
01323 
01324 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessDeviceStateChanged(TQ_UINT32 newState, TQ_UINT32 oldState, TQ_UINT32 reason) {
01325     Q_UNUSED(oldState)
01326 
01327     if (m_prevDeviceState == newState) return;
01328     m_prevDeviceState = newState;
01329 
01330     if (newState == NM_DEVICE_STATE_FAILED) {
01331         TQString errorString;
01332         if (reason == NM_DEVICE_STATE_REASON_NONE) {
01333             errorString = TQString("Connection attempt failed!");
01334         }
01335         else if (reason == NM_DEVICE_STATE_REASON_UNKNOWN) {
01336             errorString = TQString("Connection attempt failed!<br>Unknown error detected.");
01337         }
01338         else if (reason == NM_DEVICE_STATE_REASON_NOW_MANAGED) {
01339             errorString = TQString("Connection attempt failed!<br>Network device is now managed.");
01340         }
01341         else if (reason == NM_DEVICE_STATE_REASON_NOW_UNMANAGED) {
01342             errorString = TQString("Connection attempt failed!<br>Network device is now unmanaged.");
01343         }
01344         else if (reason == NM_DEVICE_STATE_REASON_CONFIG_FAILED) {
01345             errorString = TQString("Connection attempt failed!<br>Configuration failed.");
01346         }
01347         else if (reason == NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE) {
01348             errorString = TQString("Connection attempt failed!<br>IP configuration unavailable.");
01349         }
01350         else if (reason == NM_DEVICE_STATE_REASON_IP_CONFIG_EXPIRED) {
01351             errorString = TQString("Connection attempt failed!<br>IP configuration expired.");
01352         }
01353         else if (reason == NM_DEVICE_STATE_REASON_NO_SECRETS) {
01354             errorString = i18n("Connection attempt failed!<br>Secrets were required to establish a connection, but no secrets were available.");
01355         }
01356         else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT) {
01357             errorString = TQString("Connection attempt failed!<br>The supplicant was disconnected while attempting to establish a wireless connection.");
01358         }
01359         else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_CONFIG_FAILED) {
01360             errorString = TQString("Connection attempt failed!<br>Supplicant configuration failed while attempting to establish a wireless connection.");
01361         }
01362         else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED) {
01363             errorString = i18n("Connection attempt failed!<br>The supplicant failed while attempting to establish a wireless connection.");
01364         }
01365         else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_TIMEOUT) {
01366             errorString = i18n("Connection attempt failed!<br>The supplicant timed out while attempting to establish a wireless connection.");
01367         }
01368         else if (reason == NM_DEVICE_STATE_REASON_PPP_START_FAILED) {
01369             errorString = i18n("Connection attempt failed!<br>The PPP client failed to start.");
01370         }
01371         else if (reason == NM_DEVICE_STATE_REASON_PPP_DISCONNECT) {
01372             errorString = i18n("Connection attempt failed!<br>The PPP client was disconnected.");
01373         }
01374         else if (reason == NM_DEVICE_STATE_REASON_PPP_FAILED) {
01375             errorString = i18n("Connection attempt failed!<br>Unknown PPP failure.");
01376         }
01377         else if (reason == NM_DEVICE_STATE_REASON_DHCP_START_FAILED) {
01378             errorString = i18n("Connection attempt failed!<br>The DHCP client failed to start.");
01379         }
01380         else if (reason == NM_DEVICE_STATE_REASON_DHCP_ERROR) {
01381             errorString = i18n("Connection attempt failed!<br>The DHCP client encountered an error.");
01382         }
01383         else if (reason == NM_DEVICE_STATE_REASON_DHCP_FAILED) {
01384             errorString = i18n("Connection attempt failed!<br>Uknown DHCP failure.");
01385         }
01386         else if (reason == NM_DEVICE_STATE_REASON_SHARED_START_FAILED) {
01387             errorString = i18n("Connection attempt failed!<br>The connection sharing service failed to start.");
01388         }
01389         else if (reason == NM_DEVICE_STATE_REASON_SHARED_FAILED) {
01390             errorString = i18n("Connection attempt failed!<br>The connection sharing service encountered an error.");
01391         }
01392         else if (reason == NM_DEVICE_STATE_REASON_AUTOIP_START_FAILED) {
01393             errorString = i18n("Connection attempt failed!<br>The AutoIP service failed to start.");
01394         }
01395         else if (reason == NM_DEVICE_STATE_REASON_AUTOIP_ERROR) {
01396             errorString = i18n("Connection attempt failed!<br>The AutoIP service encountered an error.");
01397         }
01398         else if (reason == NM_DEVICE_STATE_REASON_AUTOIP_FAILED) {
01399             errorString = i18n("Connection attempt failed!<br>Unknown AutoIP failure.");
01400         }
01401         else if (reason == NM_DEVICE_STATE_REASON_MODEM_BUSY) {
01402             errorString = i18n("Connection attempt failed!<br>Modem was busy.");
01403         }
01404         else if (reason == NM_DEVICE_STATE_REASON_MODEM_NO_DIAL_TONE) {
01405             errorString = i18n("Connection attempt failed!<br>No dial tone.");
01406         }
01407         else if (reason == NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER) {
01408             errorString = i18n("Connection attempt failed!<br>No carrier detected.");
01409         }
01410         else if (reason == NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT) {
01411             errorString = i18n("Connection attempt failed!<br>Modem timed out while dialing.");
01412         }
01413         else if (reason == NM_DEVICE_STATE_REASON_MODEM_DIAL_FAILED) {
01414             errorString = i18n("Connection attempt failed!<br>The modem failed to dial.");
01415         }
01416         else if (reason == NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED) {
01417             errorString = i18n("Connection attempt failed!<br>Modem initialization failed.");
01418         }
01419         else if (reason == NM_DEVICE_STATE_REASON_GSM_APN_FAILED) {
01420             errorString = i18n("Connection attempt failed!<br>GSM APN failure.");
01421         }
01422         else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING) {
01423             errorString = i18n("Connection attempt failed!<br>GSM registration failed to search for networks.");
01424         }
01425         else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED) {
01426             errorString = i18n("Connection attempt failed!<br>GSM registration attempt was rejected.");
01427         }
01428         else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_TIMEOUT) {
01429             errorString = i18n("Connection attempt failed!<br>GSM registration attempt timed out.");
01430         }
01431         else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_FAILED) {
01432             errorString = i18n("Connection attempt failed!<br>GSM registration attempt failed.");
01433         }
01434         else if (reason == NM_DEVICE_STATE_REASON_GSM_PIN_CHECK_FAILED) {
01435             errorString = i18n("Connection attempt failed!<br>GSM PIN check failed.");
01436         }
01437         else if (reason == NM_DEVICE_STATE_REASON_FIRMWARE_MISSING) {
01438             errorString = i18n("Connection attempt failed!<br>Network device firmware is missing.");
01439         }
01440         else if (reason == NM_DEVICE_STATE_REASON_REMOVED) {
01441             errorString = i18n("Connection attempt failed!<br>Network device was removed.");
01442         }
01443         else if (reason == NM_DEVICE_STATE_REASON_SLEEPING) {
01444             errorString = i18n("Connection attempt failed!<br>Network device is sleeping.");
01445         }
01446         else if (reason == NM_DEVICE_STATE_REASON_CONNECTION_REMOVED) {
01447             errorString = i18n("Connection attempt failed!<br>Connection was removed.");
01448         }
01449         else if (reason == NM_DEVICE_STATE_REASON_USER_REQUESTED) {
01450             errorString = i18n("Connection attempt failed!<br>User requested device disconnection.");
01451         }
01452         else if (reason == NM_DEVICE_STATE_REASON_CARRIER) {
01453             errorString = i18n("Connection attempt failed!<br>Carrier or link status changed.");
01454         }
01455         else if (reason == NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED) {
01456             errorString = i18n("Connection attempt failed!<br>Device and/or connection already active.");
01457         }
01458         else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE) {
01459             errorString = i18n("Connection attempt failed!<br>The supplicant is now available.");
01460         }
01461         else if (reason == NM_DEVICE_STATE_REASON_MODEM_NOT_FOUND) {
01462             errorString = i18n("Connection attempt failed!<br>Requested modem was not found.");
01463         }
01464         else if (reason == NM_DEVICE_STATE_REASON_BT_FAILED) {
01465             errorString = i18n("Connection attempt failed!<br>Bluetooth connection timeout.");
01466         }
01467         else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED) {
01468             errorString = i18n("Connection attempt failed!<br>GSM SIM not inserted.");
01469         }
01470         else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED) {
01471             errorString = i18n("Connection attempt failed!<br>GSM PIN required.");
01472         }
01473         else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED) {
01474             errorString = i18n("Connection attempt failed!<br>GSM PUK required.");
01475         }
01476         else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_WRONG) {
01477             errorString = i18n("Connection attempt failed!<br>GSM SIM incorrect.");
01478         }
01479         else if (reason == NM_DEVICE_STATE_REASON_INFINIBAND_MODE) {
01480             errorString = i18n("Connection attempt failed!<br>Incorrect Infiniband mode.");
01481         }
01482         else if (reason == NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED) {
01483             errorString = i18n("Connection attempt failed!<br>Dependency failure.");
01484         }
01485         else if (reason == NM_DEVICE_STATE_REASON_BR2684_FAILED) {
01486             errorString = i18n("Connection attempt failed!<br>Unknown bridge failure.");
01487         }
01488         else if (reason == NM_DEVICE_STATE_REASON_MODEM_MANAGER_UNAVAILABLE) {
01489             errorString = i18n("Connection attempt failed!<br>ModemManager not available.");
01490         }
01491         else if (reason == NM_DEVICE_STATE_REASON_SSID_NOT_FOUND) {
01492             errorString = i18n("Connection attempt failed!<br>SSID not found.");
01493         }
01494         else if (reason == NM_DEVICE_STATE_REASON_SECONDARY_CONNECTION_FAILED) {
01495             errorString = i18n("Connection attempt failed!<br>Secondary connection failure.");
01496         }
01497         else {
01498             // FIXME
01499             // This should provide a plain-text interpretation of the NetworkManager-specific error code
01500             errorString = TQString("Connection attempt failed!<br>NetworkManager returned error %1.").arg(reason);
01501         }
01502         m_parent->internalNetworkDeviceEvent(TDENetworkDeviceEventType::Failure, errorString);
01503     }
01504 
01505     m_parent->internalNetworkDeviceStateChanged(nmDeviceStateToTDEDeviceState(newState), m_parent->deviceNode());
01506 }
01507 
01508 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessWiFiAccessPointAdded(const TQT_DBusObjectPath& dbuspath) {
01509     TDENetworkWiFiAPInfo* apInfo = m_parent->getAccessPointDetails(dbuspath);
01510     if (apInfo) {
01511         if (!m_accessPointProxyList.contains(dbuspath)) {
01512             // Set up monitoring object
01513             DBus::AccessPointProxy* apProxy = new DBus::AccessPointProxy(NM_DBUS_SERVICE, dbuspath);
01514             apProxy->setConnection(TQT_DBusConnection::systemBus());
01515             connect(apProxy, SIGNAL(PropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)), this, SLOT(internalProcessAPPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)));
01516             m_accessPointProxyList[dbuspath] = (apProxy);
01517 
01518             // Notify client applications
01519             m_parent->internalAccessPointStatusChanged(apInfo->BSSID, TDENetworkAPEventType::Discovered);
01520         }
01521         delete apInfo;
01522     }
01523 }
01524 
01525 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessWiFiAccessPointRemoved(const TQT_DBusObjectPath& dbuspath) {
01526     TDENetworkWiFiAPInfo* apInfo = m_parent->getAccessPointDetails(dbuspath);
01527     if (apInfo) {
01528         // Notify client applications
01529         m_parent->internalAccessPointStatusChanged(apInfo->BSSID, TDENetworkAPEventType::Lost);
01530         delete apInfo;
01531 
01532         // Destroy related monitoring object
01533         DBus::AccessPointProxy* apProxy = m_accessPointProxyList[dbuspath];
01534         m_accessPointProxyList.remove(dbuspath);
01535         if (apProxy) {
01536             delete apProxy;
01537         }
01538     }
01539 }
01540 
01541 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessWiFiPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>& props) {
01542     if (m_wiFiDeviceProxy) {
01543         if (props.contains("ActiveAccessPoint")) {
01544             TQT_DBusError error;
01545             TDENetworkWiFiAPInfo* apInfo = m_parent->getAccessPointDetails(m_wiFiDeviceProxy->getActiveAccessPoint(error));
01546             if (apInfo) {
01547                 m_parent->internalAccessPointStatusChanged(apInfo->BSSID, TDENetworkAPEventType::AccessPointChanged);
01548             }
01549         }
01550         else if (props.contains("Bitrate")) {
01551             m_parent->internalNetworkDeviceEvent(TDENetworkDeviceEventType::BitRateChanged, TQString::null);
01552         }
01553     }
01554 }
01555 
01556 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessAPPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>& props) {
01557     const DBus::AccessPointProxy* apProxy = dynamic_cast<const DBus::AccessPointProxy*>(sender());
01558     if (apProxy) {
01559         TQT_DBusError error;
01560         TDEMACAddress BSSID;
01561         BSSID.fromString(apProxy->getHwAddress(error));
01562         if (props.contains("Strength")) {
01563             m_parent->internalAccessPointStatusChanged(BSSID, TDENetworkAPEventType::SignalStrengthChanged);
01564         }
01565     }
01566 }
01567 
01568 TDENetworkDeviceType::TDENetworkDeviceType TDENetworkConnectionManager_BackendNM::deviceType() {
01569     if (!m_networkDevice) {
01570         return TDENetworkDeviceType::BackendOnly;
01571     }
01572 
01573     // Query NM for the device type
01574     TQT_DBusError error;
01575     d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
01576     if (!d->m_dbusDeviceString.isEmpty()) {
01577         DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, d->m_dbusDeviceString);
01578         genericDevice.setConnection(TQT_DBusConnection::systemBus());
01579         TDENetworkDeviceType::TDENetworkDeviceType ret = nmDeviceTypeToTDEDeviceType(genericDevice.getDeviceType(error));
01580         if (error.isValid()) {
01581             // Error!
01582             PRINT_ERROR((error.name() + ": " + error.message()))
01583             return TDENetworkDeviceType::Other;
01584         }
01585         else {
01586             return ret;
01587         }
01588     }
01589     else {
01590         // Error!
01591         PRINT_ERROR(TQString("Invalid empty DBUS device string"))
01592         return TDENetworkDeviceType::Other;
01593     }
01594 }
01595 
01596 TDENetworkConnectionType::TDENetworkConnectionType TDENetworkConnectionManager_BackendNM::connectionType(TQString dbusPath) {
01597     TDENetworkConnectionType::TDENetworkConnectionType connType = TDENetworkConnectionType::Other;
01598     TQ_UINT32 ret;
01599     TQT_DBusError error;
01600 
01601 #ifndef USE_ASYNC_DBUS_CALLS
01602     // Obtain connection settings from the path specified
01603     DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
01604     connectionSettings.setConnection(TQT_DBusConnection::systemBus());
01605     TQT_DBusTQStringDataMap connectionSettingsMap;
01606     ret = connectionSettings.GetSettings(connectionSettingsMap, error);
01607     if (ret && error.isValid()) {
01608         ret = 0;
01609         PRINT_ERROR((error.name() + ": " + error.message()))
01610     }
01611     if (ret) {
01612 #else // USE_ASYNC_DBUS_CALLS
01613     // Obtain connection settings from the path specified
01614     DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
01615     connectionSettings.setConnection(TQT_DBusConnection::systemBus());
01616     connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
01617     int asyncCallID;
01618     ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
01619     if (ret && error.isValid()) {
01620         ret = 0;
01621         PRINT_ERROR((error.name() + ": " + error.message()))
01622     }
01623     if (ret) {
01624         // Wait for the asynchronous call to return...
01625         d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
01626         TQTimer nmCallTimeoutTimer;
01627         nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
01628         while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
01629             tqApp->processEvents();
01630             if (!nmCallTimeoutTimer.isActive()) {
01631                 PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
01632                 break;
01633             }
01634         }
01635         TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
01636         if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
01637             PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
01638             d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
01639         }
01640         d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
01641         if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
01642             d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
01643         }
01644 #endif // USE_ASYNC_DBUS_CALLS
01645 
01646         // Parse settings to find connection type
01647         TQT_DBusTQStringDataMap::const_iterator it2;
01648         for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
01649             TQString outerKeyValue = it2.key();
01650             TQT_DBusData dataValue = it2.data();
01651 
01652             TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
01653             TQT_DBusTQStringDataMap::const_iterator it3;
01654             for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
01655                 TQString keyValue = it3.key();
01656                 TQT_DBusData dataValue = it3.data();
01657                 if (dataValue.type() == TQT_DBusData::Variant) {
01658                     TQT_DBusVariant dataValueVariant = dataValue.toVariant();
01659                     TQT_DBusData dataValue2 = dataValueVariant.value;
01660                     if (dataValue2.type() != TQT_DBusData::Variant) {
01661                         if (outerKeyValue.lower() == "connection") {
01662                             if (keyValue.lower() == "type") {
01663                                 connType = nmConnectionTypeToTDEConnectionType(dataValue2.toString());
01664                             }
01665                         }
01666                     }
01667                 }
01668             }
01669         }
01670     }
01671 
01672     return connType;
01673 }
01674 
01675 TQString TDENetworkConnectionManager_BackendNM::backendName() {
01676     return i18n("NetworkManager");
01677 }
01678 
01679 TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags TDENetworkConnectionManager_BackendNM::backendStatus() {
01680     if (d->m_networkManagerProxy) {
01681         TQ_UINT32 ret;
01682         TQT_DBusError error;
01683         ret = d->m_networkManagerProxy->getState(error);
01684         if (error.isValid()) {
01685             // Error!
01686             PRINT_ERROR((error.name() + ": " + error.message()))
01687             return TDENetworkGlobalManagerFlags::BackendUnavailable;
01688         }
01689         else {
01690             TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags globalFlags = nmGlobalStateToTDEGlobalState(ret);
01691             TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags vpnFlags = TDENetworkGlobalManagerFlags::Unknown;
01692             if (d->m_vpnProxy) {
01693                 ret = d->m_vpnProxy->getState(error);
01694                 if (error.isValid()) {
01695                     // Error!
01696                     bool print_error = true;
01697                     if (error.name() == "org.freedesktop.DBus.Error.ServiceUnknown") {
01698                         if (d->vpn_service_error_notified) {
01699                             print_error = false;
01700                         }
01701                         else {
01702                             d->vpn_service_error_notified = true;
01703                         }
01704                     }
01705                     if (print_error) {
01706                         PRINT_ERROR(TQString("Attempting to access the network-manager VPN service returned: %1").arg(error.name() + ": " + error.message()))
01707                     }
01708                     vpnFlags = TDENetworkGlobalManagerFlags::VPNUnknown;
01709                 }
01710                 else {
01711                     vpnFlags = nmVPNStateToTDEGlobalState(ret);
01712                 }
01713             }
01714             return globalFlags | vpnFlags;
01715         }
01716     }
01717     else {
01718         return TDENetworkGlobalManagerFlags::BackendUnavailable;
01719     }
01720 }
01721 
01722 TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceInformation() {
01723     TQT_DBusError error;
01724     TDENetworkDeviceInformation ret;
01725 
01726     if (d->m_networkDeviceProxy) {
01727         ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
01728         ret.UUID = d->m_networkDeviceProxy->getUdi(error);
01729         ret.backendDriver = d->m_networkDeviceProxy->getDriver(error);
01730         ret.backendDriverVersion = d->m_networkDeviceProxy->getDriverVersion(error);
01731         ret.firmwareVersion = d->m_networkDeviceProxy->getFirmwareVersion(error);
01732         ret.capabilityFlags = nmCapabilityFlagsToTDECapabilityFlags(d->m_networkDeviceProxy->getCapabilities(error));
01733         // ipConfiguration is not filled in, as the TDE HW library provides complementary functionality and is more reliable/easier to use and maintain
01734         ret.managed = d->m_networkDeviceProxy->getManaged(error);
01735         ret.autoConnect = d->m_networkDeviceProxy->getAutoconnect(error);
01736         ret.firmwareMissing = d->m_networkDeviceProxy->getFirmwareMissing(error);
01737         ret.deviceType = nmDeviceTypeToTDEDeviceType(d->m_networkDeviceProxy->getDeviceType(error));
01738         if (error.isValid()) {
01739             // Error!
01740             bool print_error = true;
01741             if (error.name() == "org.freedesktop.DBus.Error.AccessDenied") {
01742                 if (error.message().contains("org.freedesktop.NetworkManager.Device")) {
01743                     // Unable to determine if device allows autoconnect
01744                     // Assume true!
01745                     ret.autoConnect = true;
01746                     if (d->device_autoconnect_error_notified) {
01747                         print_error = false;
01748                     }
01749                     else {
01750                         d->device_autoconnect_error_notified = true;
01751                     }
01752                 }
01753             }
01754             if (print_error) {
01755                 PRINT_ERROR((error.name() + ": " + error.message()))
01756             }
01757 
01758             // Reset error object to avoid spurious error messages on the command line
01759             error = TQT_DBusError();
01760         }
01761 
01762         // Populate wiFiInfo
01763         if ((deviceType() == TDENetworkDeviceType::WiFi) && (d->m_wiFiDeviceProxy)) {
01764             ret.wiFiInfo.valid = true;
01765             ret.wiFiInfo.hwAddress.fromString(d->m_wiFiDeviceProxy->getHwAddress(error));
01766             ret.wiFiInfo.permanentHWAddress.fromString(d->m_wiFiDeviceProxy->getPermHwAddress(error));
01767             ret.wiFiInfo.operatingMode = nmWiFiModeToTDEWiFiMode(d->m_wiFiDeviceProxy->getMode(error));
01768             ret.wiFiInfo.bitrate = d->m_wiFiDeviceProxy->getBitrate(error);
01769             TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(d->m_wiFiDeviceProxy->getActiveAccessPoint(error));
01770             if (error.isValid()) {
01771                 PRINT_ERROR((error.name() + ": " + error.message()))
01772 
01773                 // Reset error object to avoid spurious error messages on the command line
01774                 error = TQT_DBusError();
01775             }
01776             if (apInfo) {
01777                 ret.wiFiInfo.activeAccessPointBSSID = apInfo->BSSID;
01778                 TDENetworkWiFiAPInfo* neighborListAPInfo = findAccessPointByBSSID(ret.wiFiInfo.activeAccessPointBSSID);
01779                 if (neighborListAPInfo) {
01780                     *neighborListAPInfo = *apInfo;
01781                 }
01782                 delete apInfo;
01783             }
01784             else {
01785                 ret.wiFiInfo.activeAccessPointBSSID = TDEMACAddress();
01786             }
01787             ret.wiFiInfo.wirelessFlags = tdeWiFiFlagsToNMWiFiFlags(d->m_wiFiDeviceProxy->getWirelessCapabilities(error));
01788         }
01789         else {
01790             ret.wiFiInfo.valid = false;
01791         }
01792 
01793         // Get active connection UUID
01794         TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
01795         if (!error.isValid()) {
01796             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
01797             activeConnection.setConnection(TQT_DBusConnection::systemBus());
01798             ret.activeConnectionUUID = activeConnection.getUuid(error);
01799             if (error.isValid()) {
01800                 ret.activeConnectionUUID = TQString::null;
01801             }
01802         }
01803 
01804         ret.valid = true;
01805     }
01806 
01807     return ret;
01808 }
01809 
01810 TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceStatus() {
01811     TQT_DBusError error;
01812     TDENetworkDeviceInformation ret;
01813 
01814     if (d->m_networkDeviceProxy) {
01815         ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
01816         ret.UUID = d->m_networkDeviceProxy->getUdi(error);
01817 
01818         // Get active connection UUID
01819         TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
01820         if (!error.isValid()) {
01821             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
01822             activeConnection.setConnection(TQT_DBusConnection::systemBus());
01823             ret.activeConnectionUUID = activeConnection.getUuid(error);
01824             if (error.isValid()) {
01825                 ret.activeConnectionUUID = TQString::null;
01826             }
01827         }
01828 
01829         ret.valid = true;
01830     }
01831 
01832     return ret;
01833 }
01834 
01835 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncReply(int asyncCallId, const TQT_DBusDataMap<TQString>& settings) {
01836     nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
01837     nmConnectionSettingsAsyncSettingsResponse[asyncCallId] = settings;
01838 }
01839 
01840 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncReply(int asyncCallId) {
01841     nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
01842 }
01843 
01844 void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncReply(int asyncCallId, const TQT_DBusObjectPath& path) {
01845     nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
01846     nmAddConnectionAsyncResponse[asyncCallId] = path;
01847 }
01848 
01849 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncError(int asyncCallId, const TQT_DBusError error) {
01850     nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallId] = error;
01851 }
01852 
01853 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncError(int asyncCallId, const TQT_DBusError error) {
01854     nmConnectionSettingsUpdateAsyncSettingsErrorResponse[asyncCallId] = error;
01855 }
01856 
01857 void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncError(int asyncCallId, const TQT_DBusError error) {
01858     nmAddConnectionAsyncErrorResponse[asyncCallId] = error;
01859 }
01860 
01861 void TDENetworkConnectionManager_BackendNM::loadConnectionInformation() {
01862     if (d->nonReentrantCallActive) return;
01863 
01864     d->nonReentrantCallActive = true;
01865 
01866     TDEMACAddress deviceMACAddress;
01867     deviceMACAddress.fromString(this->deviceMACAddress());
01868 
01869     if (d->m_networkManagerSettings) {
01870         clearTDENetworkConnectionList();
01871         TQT_DBusObjectPathList connections;
01872         TQT_DBusError error;
01873         bool ret;
01874         int state;
01875         ret = d->m_networkManagerSettings->ListConnections(connections, error);
01876         if (ret) {
01877             TQT_DBusObjectPathList::iterator it;
01878             for (it = connections.begin(); it != connections.end(); ++it) {
01879                 TDENetworkConnection* connection;
01880                 TDEWiredEthernetConnection* ethernetConnection = NULL;
01881                 TDEWiredInfinibandConnection* infinibandConnection = NULL;
01882                 TDEWiFiConnection* wiFiConnection = NULL;
01883                 TDEVPNConnection* vpnConnection = NULL;
01884                 TDEWiMaxConnection* wiMaxConnection = NULL;
01885                 TDEVLANConnection* vlanConnection = NULL;
01886                 TDEOLPCMeshConnection* olpcMeshConnection = NULL;
01887                 TDEBluetoothConnection* bluetoothConnection = NULL;
01888                 TDEModemConnection* modemConnection = NULL;
01889                 TDENetworkConnectionType::TDENetworkConnectionType connType = connectionType((*it));
01890                 if (connType == TDENetworkConnectionType::WiredEthernet) {
01891                     connection = ethernetConnection = new TDEWiredEthernetConnection;
01892                 }
01893                 else if (connType == TDENetworkConnectionType::Infiniband) {
01894                     connection = infinibandConnection = new TDEWiredInfinibandConnection;
01895                 }
01896                 else if (connType == TDENetworkConnectionType::WiFi) {
01897                     connection = wiFiConnection = new TDEWiFiConnection;
01898                 }
01899                 else if (connType == TDENetworkConnectionType::VPN) {
01900                     connection = vpnConnection = new TDEVPNConnection;
01901                 }
01902                 else if (connType == TDENetworkConnectionType::WiMax) {
01903                     connection = wiMaxConnection = new TDEWiMaxConnection;
01904                 }
01905                 else if (connType == TDENetworkConnectionType::VLAN) {
01906                     connection = vlanConnection = new TDEVLANConnection;
01907                 }
01908                 else if (connType == TDENetworkConnectionType::OLPCMesh) {
01909                     connection = olpcMeshConnection = new TDEOLPCMeshConnection;
01910                 }
01911                 else if (connType == TDENetworkConnectionType::Bluetooth) {
01912                     connection = bluetoothConnection = new TDEBluetoothConnection;
01913                 }
01914                 else if (connType == TDENetworkConnectionType::Modem) {
01915                     connection = modemConnection = new TDEModemConnection;
01916                 }
01917                 else {
01918                     connection = new TDENetworkConnection;
01919                 }
01920                 // Set up defaults
01921                 connection->ipConfig.connectionFlags =  TDENetworkIPConfigurationFlags::IPV4DHCPIP          | \
01922                                     TDENetworkIPConfigurationFlags::IPV4DHCPDNS         | \
01923                                     TDENetworkIPConfigurationFlags::IPV4DHCPRoutes          | \
01924                                     TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute    | \
01925                                     TDENetworkIPConfigurationFlags::IPV6DHCPIP          | \
01926                                     TDENetworkIPConfigurationFlags::IPV6DHCPDNS         | \
01927                                     TDENetworkIPConfigurationFlags::IPV6DHCPRoutes          | \
01928                                     TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
01929                 // Set up NM-specific defaults
01930                 // Keep in sync with latest NM default settings!
01931                 // NM 0.9 setting descriptions and default values are available at:
01932                 // http://projects.gnome.org/NetworkManager/developers/api/09/ref-settings.html
01933                 connection->autoConnect = true;
01934 
01935                 if (wiFiConnection) {
01936                     wiFiConnection->securitySettings.authType = TDENetworkWiFiAuthType::Open;
01937                 }
01938 
01939 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
01940                 printf("[network-manager comm debug] %s\n", (*it).data()); fflush(stdout);
01941 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
01942 
01943 #ifndef USE_ASYNC_DBUS_CALLS
01944                 // Obtain connection settings from the path specified
01945                 DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
01946                 connectionSettings.setConnection(TQT_DBusConnection::systemBus());
01947                 TQT_DBusTQStringDataMap connectionSettingsMap;
01948                 ret = connectionSettings.GetSettings(connectionSettingsMap, error);
01949                 if (ret && error.isValid()) {
01950                     ret = 0;
01951                     PRINT_ERROR((error.name() + ": " + error.message()))
01952                 }
01953                 if (ret) {
01954 #else // USE_ASYNC_DBUS_CALLS
01955                 // Obtain connection settings from the path specified
01956                 DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
01957                 connectionSettings.setConnection(TQT_DBusConnection::systemBus());
01958                 connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
01959                 connect(&connectionSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processConnectionSettingsAsyncError(int, const TQT_DBusError)));
01960                 int asyncCallID;
01961                 ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
01962                 if (ret && error.isValid()) {
01963                     ret = 0;
01964                     PRINT_ERROR((error.name() + ": " + error.message()))
01965                 }
01966                 if (ret) {
01967                     // Wait for the asynchronous call to return...
01968                     d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
01969                     TQTimer nmCallTimeoutTimer;
01970                     nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
01971                     while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
01972                         tqApp->processEvents();
01973                         if (!nmCallTimeoutTimer.isActive()) {
01974                             PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
01975                             break;
01976                         }
01977                     }
01978                     TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
01979                     if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
01980                         PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
01981                         d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
01982                     }
01983                     d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
01984                     if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
01985                         d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
01986                     }
01987 #endif // USE_ASYNC_DBUS_CALLS
01988 
01989 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
01990                     printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
01991                     printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
01992 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
01993 
01994                     // Parse settings
01995                     TQT_DBusTQStringDataMap::const_iterator it2;
01996                     for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
01997                         TQString outerKeyValue = it2.key();
01998                         TQT_DBusData dataValue = it2.data();
01999 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02000                         printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
02001 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02002                         TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
02003                         TQT_DBusTQStringDataMap::const_iterator it3;
02004                         for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
02005                             TQString keyValue = it3.key();
02006                             TQT_DBusData dataValue = it3.data();
02007                             if (dataValue.type() != TQT_DBusData::Variant) {
02008 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02009                                 printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
02010 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02011                                 // No NM settings are known which use this style
02012                             }
02013                             else {
02014                                 TQT_DBusVariant dataValueVariant = dataValue.toVariant();
02015                                 TQT_DBusData dataValue2 = dataValueVariant.value;
02016                                 if (dataValue2.type() != TQT_DBusData::Variant) {
02017 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02018                                     printf("[network-manager comm debug] %s = %s (type %d(%s), signature %s)\n", keyValue.ascii(), dataValue2.toString().ascii(), dataValue2.type(), dataValue2.typeName(), dataValueVariant.signature.ascii()); fflush(stdout);
02019 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02020                                     // Most NM settings use this style
02021                                     if (outerKeyValue.lower() == "connection") {
02022                                         if (keyValue.lower() == "id") {
02023                                             connection->friendlyName = dataValue2.toString();
02024                                         }
02025                                         else if (keyValue.lower() == "uuid") {
02026                                             connection->UUID = dataValue2.toString().lower();
02027                                         }
02028                                         else if (keyValue.lower() == "permissions") {
02029                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02030                                             TQT_DBusDataValueList::const_iterator it4;
02031                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02032                                                 TQT_DBusData innerDataValue = *it4;
02033                                                 TQString authString = innerDataValue.toString();
02034                                                 TQStringList pieces = TQStringList::split(":", authString);
02035                                                 if (pieces[0].lower() == "user") {
02036                                                     connection->authorizedUsers.append(pieces[1]);
02037                                                 }
02038                                             }
02039                                         }
02040                                         else if (keyValue.lower() == "autoconnect") {
02041                                             connection->autoConnect = dataValue2.toBool();
02042                                         }
02043                                         else if (keyValue.lower() == "read-only") {
02044                                             connection->readOnly = dataValue2.toBool();
02045                                         }
02046                                         else if (keyValue.lower() == "master") {
02047                                             connection->masterConnectionUUID = dataValue2.toString().lower();
02048                                         }
02049                                         else if (keyValue.lower() == "slave-type") {
02050                                             connection->slaveType = nmSlaveTypeToTDESlaveType(dataValue2.toString());
02051                                         }
02052                                         else if (keyValue.lower() == "timestamp") {
02053                                             connection->lastKnownConnection.setTime_t(dataValue2.toUInt64());
02054                                         }
02055                                     }
02056                                     else if (outerKeyValue.lower() == "802-1x") {
02057                                         if (keyValue.lower() == "eap") {
02058                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02059                                             TQT_DBusDataValueList::const_iterator it4;
02060                                             state = 0;
02061                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02062                                                 TQT_DBusData innerDataValue = *it4;
02063                                                 if (state == 0) {
02064                                                     // EAP type
02065                                                     connection->eapConfig.type = nmEAPTypeToTDEEAPType(innerDataValue.toString());
02066                                                 }
02067                                                 state++;
02068                                             }
02069                                         }
02070                                         else if (keyValue.lower() == "identity") {
02071                                             connection->eapConfig.userName = dataValue2.toString();
02072                                         }
02073                                         else if (keyValue.lower() == "anonymous-identity") {
02074                                             connection->eapConfig.anonymousUserName = dataValue2.toString();
02075                                         }
02076                                         else if (keyValue.lower() == "pac-file") {
02077                                             connection->eapConfig.pacFileName = dataValue2.toString();
02078                                         }
02079                                         else if (keyValue.lower() == "ca-cert") {
02080                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02081                                             TQT_DBusDataValueList::const_iterator it4;
02082                                             int count=0;
02083                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02084                                                 TQT_DBusData innerDataValue = *it4;
02085                                                 count++;
02086                                                 connection->eapConfig.caCertificate.resize(count+1);
02087                                                 connection->eapConfig.caCertificate[count] = innerDataValue.toByte();
02088                                             }
02089                                         }
02090                                         else if (keyValue.lower() == "ca-path") {
02091                                             connection->eapConfig.additionalCAFilesPath = dataValue2.toString();
02092                                         }
02093                                         else if (keyValue.lower() == "subject-match") {
02094                                             connection->eapConfig.authServerCertSubjectMatch = dataValue2.toString();
02095                                         }
02096                                         else if (keyValue.lower() == "altsubject-matches") {
02097                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02098                                             TQT_DBusDataValueList::const_iterator it4;
02099                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02100                                                 TQT_DBusData innerDataValue = *it4;
02101                                                 connection->eapConfig.alternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
02102                                             }
02103                                         }
02104                                         else if (keyValue.lower() == "client-cert") {
02105                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02106                                             TQT_DBusDataValueList::const_iterator it4;
02107                                             int count=0;
02108                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02109                                                 TQT_DBusData innerDataValue = *it4;
02110                                                 count++;
02111                                                 connection->eapConfig.clientCertificate.resize(count+1);
02112                                                 connection->eapConfig.clientCertificate[count] = innerDataValue.toByte();
02113                                             }
02114                                         }
02115                                         else if (keyValue.lower() == "phase1-peapver") {
02116                                             connection->eapConfig.forcePEAPVersion = dataValue2.toString();
02117                                         }
02118                                         else if (keyValue.lower() == "phase1-peaplabel") {
02119                                             connection->eapConfig.forcePEAPLabel = dataValue2.toString();
02120                                         }
02121                                         else if (keyValue.lower() == "phase1-fast-provisioning") {
02122                                             connection->eapConfig.fastProvisioningFlags = nmEAPFastFlagsToTDEEAPFastFlags(dataValue2.toString());
02123                                         }
02124                                         else if (keyValue.lower() == "phase2-auth") {
02125                                             connection->eapConfig.phase2NonEAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
02126                                         }
02127                                         else if (keyValue.lower() == "phase2-autheap") {
02128                                             connection->eapConfig.phase2EAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
02129                                         }
02130                                         else if (keyValue.lower() == "phase2-ca-cert") {
02131                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02132                                             TQT_DBusDataValueList::const_iterator it4;
02133                                             int count=0;
02134                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02135                                                 TQT_DBusData innerDataValue = *it4;
02136                                                 count++;
02137                                                 connection->eapConfig.phase2CaCertificate.resize(count+1);
02138                                                 connection->eapConfig.phase2CaCertificate[count] = innerDataValue.toByte();
02139                                             }
02140                                         }
02141                                         else if (keyValue.lower() == "phase2-ca-path") {
02142                                             connection->eapConfig.phase2CaFilesPath = dataValue2.toString();
02143                                         }
02144                                         else if (keyValue.lower() == "phase2-subject-match") {
02145                                             connection->eapConfig.phase2AuthServerCertSubjectMatch = dataValue2.toString();
02146                                         }
02147                                         else if (keyValue.lower() == "phase2-altsubject-matches") {
02148                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02149                                             TQT_DBusDataValueList::const_iterator it4;
02150                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02151                                                 TQT_DBusData innerDataValue = *it4;
02152                                                 connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
02153                                             }
02154                                         }
02155                                         else if (keyValue.lower() == "phase2-client-cert") {
02156                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02157                                             TQT_DBusDataValueList::const_iterator it4;
02158                                             int count=0;
02159                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02160                                                 TQT_DBusData innerDataValue = *it4;
02161                                                 count++;
02162                                                 connection->eapConfig.phase2ClientCertificate.resize(count+1);
02163                                                 connection->eapConfig.phase2ClientCertificate[count] = innerDataValue.toByte();
02164                                             }
02165                                         }
02166                                         else if (keyValue.lower() == "password-flags") {
02167                                             connection->eapConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02168                                         }
02169                                         else if (keyValue.lower() == "password-raw-flags") {
02170                                             connection->eapConfig.binaryPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02171                                         }
02172                                         else if (keyValue.lower() == "private-key") {
02173                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02174                                             TQT_DBusDataValueList::const_iterator it4;
02175                                             int count=0;
02176                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02177                                                 TQT_DBusData innerDataValue = *it4;
02178                                                 count++;
02179                                                 connection->eapConfig.privateKey.resize(count+1);
02180                                                 connection->eapConfig.privateKey[count] = innerDataValue.toByte();
02181                                             }
02182                                         }
02183                                         else if (keyValue.lower() == "private-key-password-flags") {
02184                                             connection->eapConfig.privateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02185                                         }
02186                                         else if (keyValue.lower() == "phase2-private-key") {
02187                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02188                                             TQT_DBusDataValueList::const_iterator it4;
02189                                             int count=0;
02190                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02191                                                 TQT_DBusData innerDataValue = *it4;
02192                                                 count++;
02193                                                 connection->eapConfig.phase2PrivateKey.resize(count+1);
02194                                                 connection->eapConfig.phase2PrivateKey[count] = innerDataValue.toByte();
02195                                             }
02196                                         }
02197                                         else if (keyValue.lower() == "phase2-private-key-password-flags") {
02198                                             connection->eapConfig.phase2PrivateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02199                                         }
02200                                         else if (keyValue.lower() == "system-ca-certs") {
02201                                             connection->eapConfig.forceSystemCaCertificates = dataValue2.toBool();
02202                                         }
02203                                         connection->eapConfig.valid = true;
02204                                     }
02205                                     else if (outerKeyValue.lower() == "802-3-ethernet") {
02206                                         if (keyValue.lower() == "duplex") {
02207                                             connection->fullDuplex = (dataValue2.toString().lower() == "full")?true:false;
02208                                         }
02209                                         else if (keyValue.lower() == "mac-address") {
02210                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02211                                             TQT_DBusDataValueList::const_iterator it4;
02212                                             TDENetworkByteList macAddress;
02213                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02214                                                 TQT_DBusData innerDataValue = *it4;
02215                                                 macAddress.append(innerDataValue.toByte());
02216                                             }
02217                                             connection->lockedHWAddress.setAddress(macAddress);
02218                                         }
02219                                         else if (keyValue.lower() == "cloned-mac-address") {
02220                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02221                                             TQT_DBusDataValueList::const_iterator it4;
02222                                             TDENetworkByteList macAddress;
02223                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02224                                                 TQT_DBusData innerDataValue = *it4;
02225                                                 macAddress.append(innerDataValue.toByte());
02226                                             }
02227                                             connection->manualHWAddress.setAddress(macAddress);
02228                                         }
02229                                         else if (keyValue.lower() == "mtu") {
02230                                             connection->mtu = dataValue2.toUInt32();
02231                                         }
02232                                     }
02233                                     else if (outerKeyValue.lower() == "infiniband") {
02234                                         if (keyValue.lower() == "mac-address") {
02235                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02236                                             TQT_DBusDataValueList::const_iterator it4;
02237                                             TDENetworkByteList macAddress;
02238                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02239                                                 TQT_DBusData innerDataValue = *it4;
02240                                                 macAddress.append(innerDataValue.toByte());
02241                                             }
02242                                             connection->lockedHWAddress.setAddress(macAddress);
02243                                         }
02244                                         else if (keyValue.lower() == "mtu") {
02245                                             connection->mtu = dataValue2.toUInt32();
02246                                         }
02247                                         else if (keyValue.lower() == "transport-mode") {
02248                                             infinibandConnection->transportMode = nmIBTransportToTDEIBTransport(dataValue2.toString());
02249                                         }
02250                                     }
02251                                     else if (outerKeyValue.lower() == "802-11-wireless") {
02252                                         if (keyValue.lower() == "ssid") {
02253                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02254                                             TQT_DBusDataValueList::const_iterator it4;
02255                                             int count = 0;
02256                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02257                                                 TQT_DBusData innerDataValue = *it4;
02258                                                 wiFiConnection->SSID.resize(count+1);
02259                                                 wiFiConnection->SSID[count] = innerDataValue.toByte();
02260                                                 count++;
02261                                             }
02262                                         }
02263                                         else if (keyValue.lower() == "mac-address") {
02264                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02265                                             TQT_DBusDataValueList::const_iterator it4;
02266                                             TDENetworkByteList macAddress;
02267                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02268                                                 TQT_DBusData innerDataValue = *it4;
02269                                                 macAddress.append(innerDataValue.toByte());
02270                                             }
02271                                             connection->lockedHWAddress.setAddress(macAddress);
02272                                         }
02273                                         else if (keyValue.lower() == "cloned-mac-address") {
02274                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02275                                             TQT_DBusDataValueList::const_iterator it4;
02276                                             TDENetworkByteList macAddress;
02277                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02278                                                 TQT_DBusData innerDataValue = *it4;
02279                                                 macAddress.append(innerDataValue.toByte());
02280                                             }
02281                                             connection->manualHWAddress.setAddress(macAddress);
02282                                         }
02283                                         else if (keyValue.lower() == "mtu") {
02284                                             connection->mtu = dataValue2.toUInt32();
02285                                         }
02286                                         else if (keyValue.lower() == "mode") {
02287                                             wiFiConnection->operatingMode = nmWiFiModeToTDEWiFiMode(dataValue2.toString());
02288                                         }
02289                                         else if (keyValue.lower() == "band") {
02290                                             wiFiConnection->bandRestriction = nmWiFiFrequencyBandToTDEWiFiFrequencyBand(dataValue2.toString());
02291                                         }
02292                                         else if (keyValue.lower() == "channel") {
02293                                             wiFiConnection->channelRestriction = dataValue2.toUInt32();
02294                                             if (wiFiConnection->channelRestriction == 0) wiFiConnection->channelRestriction = -1;
02295                                         }
02296                                         else if (keyValue.lower() == "rate") {
02297                                             wiFiConnection->bitRateRestriction = dataValue2.toUInt32()*1000;
02298                                             if (wiFiConnection->bitRateRestriction == 0) wiFiConnection->bitRateRestriction = -1;
02299                                         }
02300                                         else if (keyValue.lower() == "tx-power") {
02301                                             wiFiConnection->powerRestriction = dataValue2.toUInt32();
02302                                             if (wiFiConnection->powerRestriction == 0) wiFiConnection->powerRestriction = -1;
02303                                         }
02304                                         else if (keyValue.lower() == "bssid") {
02305                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02306                                             TQT_DBusDataValueList::const_iterator it4;
02307                                             TDENetworkByteList macAddress;
02308                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02309                                                 TQT_DBusData innerDataValue = *it4;
02310                                                 macAddress.append(innerDataValue.toByte());
02311                                             }
02312                                             wiFiConnection->accessPointRestriction.setAddress(macAddress);
02313                                         }
02314                                         else if (keyValue.lower() == "mac-address-blacklist") {
02315                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02316                                             TQT_DBusDataValueList::const_iterator it4;
02317                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02318                                                 TQT_DBusData innerDataValue = *it4;
02319                                                 TDEMACAddress hwAddress;
02320                                                 hwAddress.fromString(innerDataValue.toString());
02321                                                 wiFiConnection->blacklistedBSSIDs.append(hwAddress);
02322                                             }
02323                                         }
02324                                         else if (keyValue.lower() == "seen-bssids") {
02325                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02326                                             TQT_DBusDataValueList::const_iterator it4;
02327                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02328                                                 TQT_DBusData innerDataValue = *it4;
02329                                                 TDEMACAddress hwAddress;
02330                                                 hwAddress.fromString(innerDataValue.toString());
02331                                                 wiFiConnection->heardBSSIDs.append(hwAddress);
02332                                             }
02333                                         }
02334                                         else if (keyValue.lower() == "security") {
02335                                             TQString setting;
02336                                             if (setting.lower() == "802-11-wireless-security") {
02337                                                 wiFiConnection->securityRequired = true;
02338                                             }
02339                                             else {
02340                                                 wiFiConnection->securityRequired = false;
02341                                             }
02342                                         }
02343                                         else if (keyValue.lower() == "hidden") {
02344                                             wiFiConnection->isHiddenNetwork = dataValue2.toBool();
02345                                         }
02346                                     }
02347                                     else if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
02348                                         if (keyValue.lower() == "key-mgmt") {
02349                                             wiFiConnection->securitySettings.keyType = nmWiFiKeyTypeToTDEWiFiKeyType(dataValue2.toString());
02350                                         }
02351                                         else if (keyValue.lower() == "wep-tx-keyidx") {
02352                                             wiFiConnection->securitySettings.wepKeyIndex = dataValue2.toUInt32();
02353                                         }
02354                                         else if (keyValue.lower() == "auth-alg") {
02355                                             wiFiConnection->securitySettings.authType = nmWiFiAuthTypeToTDEWiFiAuthType(dataValue2.toString());
02356                                         }
02357                                         else if (keyValue.lower() == "proto") {
02358                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02359                                             TQT_DBusDataValueList::const_iterator it4;
02360                                             TQStringList strings;
02361                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02362                                                 TQT_DBusData innerDataValue = *it4;
02363                                                 strings.append(innerDataValue.toString());
02364                                             }
02365                                             wiFiConnection->securitySettings.wpaVersion = nmWiFiWPAVersionToTDEWiFiWPAVersion(strings);
02366                                         }
02367                                         else if (keyValue.lower() == "pairwise") {
02368                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02369                                             TQT_DBusDataValueList::const_iterator it4;
02370                                             TQStringList strings;
02371                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02372                                                 TQT_DBusData innerDataValue = *it4;
02373                                                 wiFiConnection->securitySettings.allowedPairWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
02374                                             }
02375                                             if ((wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
02376                                                 || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
02377                                                 || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
02378                                                 || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
02379                                                 wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
02380                                             }
02381                                         }
02382                                         else if (keyValue.lower() == "group") {
02383                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02384                                             TQT_DBusDataValueList::const_iterator it4;
02385                                             TQStringList strings;
02386                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02387                                                 TQT_DBusData innerDataValue = *it4;
02388                                                 wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
02389                                             }
02390                                             if ((wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
02391                                                 || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
02392                                                 || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
02393                                                 || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
02394                                                 wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
02395                                             }
02396                                         }
02397                                         else if (keyValue.lower() == "leap-username") {
02398                                             wiFiConnection->securitySettings.leapUsername = dataValue2.toString();
02399                                         }
02400                                         else if (keyValue.lower() == "wep-key-flags") {
02401                                             wiFiConnection->securitySettings.wepKeyFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02402                                         }
02403                                         else if (keyValue.lower() == "wep-key-type") {
02404                                             wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(dataValue2.toUInt32());
02405                                         }
02406                                         else if (keyValue.lower() == "psk-flags") {
02407                                             wiFiConnection->securitySettings.pskFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02408                                         }
02409                                         else if (keyValue.lower() == "leap-password-flags") {
02410                                             wiFiConnection->securitySettings.leapPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02411                                         }
02412                                         wiFiConnection->securitySettings.valid = true;
02413                                     }
02414                                     else if (outerKeyValue.lower() == "vpn") {
02415                                         if (keyValue.lower() == "service-type") {
02416                                             TQString plugin = dataValue2.toString();
02417                                             plugin.replace("org.freedesktop.NetworkManager.", "");
02418                                             vpnConnection->vpnPluginID = plugin;
02419                                         }
02420                                         else if (keyValue.lower() == "user-name") {
02421                                             vpnConnection->lockedUserName = dataValue2.toString();
02422                                         }
02423                                         else if (keyValue.lower() == "data") {
02424                                             vpnConnection->pluginData.clear();
02425                                             TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
02426                                             TQT_DBusTQStringDataMap::const_iterator it4;
02427                                             for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
02428                                                 TQString keyValue4 = it4.key();
02429                                                 TQT_DBusData dataValue4 = it4.data();
02430                                                 if (dataValue4.type() == TQT_DBusData::String) {
02431                                                     vpnConnection->pluginData[keyValue4] = dataValue4.toString();
02432                                                 }
02433                                             }
02434                                         }
02435                                     }
02436                                     else if (outerKeyValue.lower() == "wimax") {
02437                                         if (keyValue.lower() == "mac-address") {
02438                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02439                                             TQT_DBusDataValueList::const_iterator it4;
02440                                             TDENetworkByteList macAddress;
02441                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02442                                                 TQT_DBusData innerDataValue = *it4;
02443                                                 macAddress.append(innerDataValue.toByte());
02444                                             }
02445                                             connection->lockedHWAddress.setAddress(macAddress);
02446                                         }
02447                                         else if (keyValue.lower() == "network-name") {
02448                                             wiMaxConnection->networkServiceProvider = dataValue2.toString();
02449                                         }
02450                                     }
02451                                     else if (outerKeyValue.lower() == "vlan") {
02452                                         if (keyValue.lower() == "interface-name") {
02453                                             vlanConnection->kernelName = dataValue2.toString();
02454                                         }
02455                                         else if (keyValue.lower() == "parent") {
02456                                             vlanConnection->parentConnectionUUID = dataValue2.toString();
02457                                         }
02458                                         else if (keyValue.lower() == "id") {
02459                                             vlanConnection->vlanID = dataValue2.toUInt32();
02460                                         }
02461                                         else if (keyValue.lower() == "flags") {
02462                                             vlanConnection->vlanFlags = nmVLANFlagsToTDEVLANFlags(dataValue2.toUInt32());
02463                                         }
02464                                         else if (keyValue.lower() == "ingress-priority-map") {
02465                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02466                                             TQT_DBusDataValueList::const_iterator it4;
02467                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02468                                                 TQT_DBusData innerDataValue = *it4;
02469                                                 TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
02470                                                 vlanConnection->ingressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
02471                                             }
02472                                         }
02473                                         else if (keyValue.lower() == "egress-priority-map") {
02474                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02475                                             TQT_DBusDataValueList::const_iterator it4;
02476                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02477                                                 TQT_DBusData innerDataValue = *it4;
02478                                                 TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
02479                                                 vlanConnection->egressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
02480                                             }
02481                                         }
02482                                     }
02483                                     else if (outerKeyValue.lower() == "serial") {
02484                                         if (keyValue.lower() == "baud") {
02485                                             connection->serialConfig.baudRate = dataValue2.toUInt32();
02486                                         }
02487                                         else if (keyValue.lower() == "bits") {
02488                                             connection->serialConfig.byteWidth = dataValue2.toUInt32();
02489                                         }
02490                                         else if (keyValue.lower() == "parity") {
02491                                             connection->serialConfig.parity = nmParityToTDEParity(dataValue2.toByte());
02492                                         }
02493                                         else if (keyValue.lower() == "stopbits") {
02494                                             connection->serialConfig.stopBits = dataValue2.toUInt32();
02495                                         }
02496                                         else if (keyValue.lower() == "send-delay") {
02497                                             connection->serialConfig.txDelay = dataValue2.toUInt64();
02498                                         }
02499                                         connection->serialConfig.valid = true;
02500                                     }
02501                                     else if (outerKeyValue.lower() == "ppp") {
02502                                         if (keyValue.lower() == "noauth") {
02503                                             connection->pppConfig.requireServerAuthentication = !(dataValue2.toBool());
02504                                         }
02505                                         else if (keyValue.lower() == "refuse-eap") {
02506                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableEAP;
02507                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableEAP;
02508                                         }
02509                                         else if (keyValue.lower() == "refuse-pap") {
02510                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisablePAP;
02511                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisablePAP;
02512                                         }
02513                                         else if (keyValue.lower() == "refuse-chap") {
02514                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableCHAP;
02515                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableCHAP;
02516                                         }
02517                                         else if (keyValue.lower() == "refuse-mschap") {
02518                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableMSCHAP;
02519                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAP;
02520                                         }
02521                                         else if (keyValue.lower() == "refuse-mschapv2") {
02522                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableMSCHAPv2;
02523                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAPv2;
02524                                         }
02525                                         else if (keyValue.lower() == "nobsdcomp") {
02526                                             if (dataValue2.toBool())    connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowBSDCompression;
02527                                             else                connection->pppConfig.flags |=  TDENetworkPPPFlags::AllowBSDCompression;
02528                                         }
02529                                         else if (keyValue.lower() == "nodeflate") {
02530                                             if (dataValue2.toBool())    connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowDeflateCompression;
02531                                             else                connection->pppConfig.flags |=  TDENetworkPPPFlags::AllowDeflateCompression;
02532                                         }
02533                                         else if (keyValue.lower() == "no-vj-comp") {
02534                                             if (dataValue2.toBool())    connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowVJCompression;
02535                                             else                connection->pppConfig.flags |=  TDENetworkPPPFlags::AllowVJCompression;
02536                                         }
02537                                         else if (keyValue.lower() == "require-mppe") {
02538                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::RequireMPPE;
02539                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE;
02540                                         }
02541                                         else if (keyValue.lower() == "require-mppe-128") {
02542                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::RequireMPPE128;
02543                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE128;
02544                                         }
02545                                         else if (keyValue.lower() == "mppe-stateful") {
02546                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::StatefulMPPE;
02547                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::StatefulMPPE;
02548                                         }
02549                                         else if (keyValue.lower() == "crtscts") {
02550                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::UseHardwareFlowControl;
02551                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::UseHardwareFlowControl;
02552                                         }
02553                                         else if (keyValue.lower() == "baud") {
02554                                             connection->pppConfig.baudRate = dataValue2.toUInt32();
02555                                         }
02556                                         else if (keyValue.lower() == "mru") {
02557                                             connection->pppConfig.mru = dataValue2.toUInt32();
02558                                         }
02559                                         else if (keyValue.lower() == "mtu") {
02560                                             connection->pppConfig.mtu = dataValue2.toUInt32();
02561                                         }
02562                                         else if (keyValue.lower() == "lcp-echo-interval") {
02563                                             connection->pppConfig.lcpEchoPingInterval = dataValue2.toUInt32();
02564                                         }
02565                                         else if (keyValue.lower() == "lcp-echo-failure") {
02566                                             connection->pppConfig.lcpEchoFailureThreshold = dataValue2.toUInt32();
02567                                         }
02568                                         connection->pppConfig.valid = true;
02569                                     }
02570                                     else if (outerKeyValue.lower() == "pppoe") {
02571                                         if (keyValue.lower() == "service") {
02572                                             connection->pppoeConfig.networkServiceProvider = dataValue2.toString();
02573                                         }
02574                                         else if (keyValue.lower() == "username") {
02575                                             connection->pppoeConfig.username = dataValue2.toString();
02576                                         }
02577                                         else if (keyValue.lower() == "password-flags") {
02578                                             connection->pppoeConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02579                                         }
02580                                         connection->pppoeConfig.secretsValid = true;
02581                                     }
02582                                     else if ((outerKeyValue.lower() == "802-11-olpc-mesh") && (olpcMeshConnection)) {
02583                                         if (keyValue.lower() == "ssid") {
02584                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02585                                             TQT_DBusDataValueList::const_iterator it4;
02586                                             int count = 0;
02587                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02588                                                 TQT_DBusData innerDataValue = *it4;
02589                                                 olpcMeshConnection->SSID.resize(count+1);
02590                                                 olpcMeshConnection->SSID[count] = innerDataValue.toByte();
02591                                                 count++;
02592                                             }
02593                                         }
02594                                         else if (keyValue.lower() == "channel") {
02595                                             olpcMeshConnection->channel = dataValue2.toUInt32();
02596                                         }
02597                                         else if (keyValue.lower() == "dhcp-anycast-address") {
02598                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02599                                             TQT_DBusDataValueList::const_iterator it4;
02600                                             int count = 0;
02601                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02602                                                 TQT_DBusData innerDataValue = *it4;
02603                                                 olpcMeshConnection->anycastDHCPHWAddress.resize(count+1);
02604                                                 olpcMeshConnection->anycastDHCPHWAddress[count] = innerDataValue.toByte();
02605                                                 count++;
02606                                             }
02607                                         }
02608                                     }
02609                                     else if ((outerKeyValue.lower() == "bluetooth") && (bluetoothConnection)) {
02610                                         if (keyValue.lower() == "bdaddr") {
02611                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02612                                             TQT_DBusDataValueList::const_iterator it4;
02613                                             TDENetworkByteList macAddress;
02614                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02615                                                 TQT_DBusData innerDataValue = *it4;
02616                                                 macAddress.append(innerDataValue.toByte());
02617                                             }
02618                                             connection->lockedHWAddress.setAddress(macAddress);
02619                                         }
02620                                         else if (keyValue.lower() == "type") {
02621                                             bluetoothConnection->type = nmBluetoothModeToTDEBluetoothMode(dataValue2.toString());
02622                                         }
02623                                     }
02624                                     else if ((outerKeyValue.lower() == "cdma") && (modemConnection)) {
02625                                         if (keyValue.lower() == "number") {
02626                                             modemConnection->cdmaConfig.providerDataNumber = dataValue2.toString();
02627                                         }
02628                                         else if (keyValue.lower() == "username") {
02629                                             modemConnection->cdmaConfig.username = dataValue2.toString();
02630                                         }
02631                                         else if (keyValue.lower() == "password-flags") {
02632                                             modemConnection->cdmaConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02633                                         }
02634                                         modemConnection->type = TDEModemConnectionType::CDMA;
02635                                         modemConnection->cdmaConfig.valid = true;
02636                                     }
02637                                     else if ((outerKeyValue.lower() == "gsm") && (modemConnection)) {
02638                                         if (keyValue.lower() == "number") {
02639                                             modemConnection->gsmConfig.providerDataNumber = dataValue2.toString();
02640                                         }
02641                                         else if (keyValue.lower() == "username") {
02642                                             modemConnection->gsmConfig.username = dataValue2.toString();
02643                                         }
02644                                         else if (keyValue.lower() == "password-flags") {
02645                                             modemConnection->gsmConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02646                                         }
02647                                         else if (keyValue.lower() == "apn") {
02648                                             modemConnection->gsmConfig.accessPointName = dataValue2.toString();
02649                                         }
02650                                         else if (keyValue.lower() == "network-id") {
02651                                             modemConnection->gsmConfig.networkID = dataValue2.toString();
02652                                         }
02653                                         else if (keyValue.lower() == "network-type") {
02654                                             modemConnection->gsmConfig.networkType = nmGSMModeToTDEGSMMode(dataValue2.toInt32());
02655                                         }
02656                                         else if (keyValue.lower() == "pin-flags") {
02657                                             modemConnection->gsmConfig.pinFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02658                                         }
02659                                         else if (keyValue.lower() == "allowed-bands") {
02660                                             modemConnection->gsmConfig.allowedFrequencyBands = dataValue2.toUInt32();
02661                                         }
02662                                         else if (keyValue.lower() == "home-only") {
02663                                             modemConnection->gsmConfig.allowRoaming = !dataValue2.toBool();
02664                                         }
02665                                         modemConnection->type = TDEModemConnectionType::GSM;
02666                                         modemConnection->gsmConfig.valid = true;
02667                                     }
02668                                     else if (outerKeyValue.lower() == "ipv4") {
02669                                         if (keyValue.lower() == "addresses") {
02670                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02671                                             TQT_DBusDataValueList::const_iterator it4;
02672                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02673                                                 TQT_DBusData innerDataValue = *it4;
02674                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
02675                                                 TQT_DBusDataValueList::const_iterator it5;
02676                                                 state = 0;
02677                                                 TDENetworkSingleIPConfiguration ipConfig;
02678                                                 for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
02679                                                     TQT_DBusData innerMostDataValue = *it5;
02680                                                     if (state == 0) {
02681                                                         // Address
02682                                                         ipConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
02683                                                     }
02684                                                     else if (state == 1) {
02685                                                         // Network mask
02686                                                         ipConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
02687                                                     }
02688                                                     else if (state == 2) {
02689                                                         // Gateway
02690                                                         ipConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
02691                                                     }
02692                                                     state++;
02693                                                 }
02694                                                 ipConfig.valid = true;
02695                                                 connection->ipConfig.ipConfigurations.append(ipConfig);
02696                                             }
02697                                         }
02698                                         else if (keyValue.lower() == "dhcp-client-id") {
02699                                             connection->ipConfig.dhcpClientIdentifier = dataValue2.toString();
02700                                         }
02701                                         else if (keyValue.lower() == "dns") {
02702                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02703                                             TQT_DBusDataValueList::const_iterator it4;
02704                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02705                                                 TQT_DBusData innerDataValue = *it4;
02706                                                 connection->ipConfig.resolvers.append(TQHostAddress(reverseIPV4ByteOrder(innerDataValue.toUInt32())));
02707                                             }
02708                                         }
02709                                         else if (keyValue.lower() == "dns-search") {
02710                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02711                                             TQT_DBusDataValueList::const_iterator it4;
02712                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02713                                                 TQT_DBusData innerDataValue = *it4;
02714                                                 connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), false));
02715                                             }
02716                                         }
02717                                         else if (keyValue.lower() == "ignore-auto-dns") {
02718                                             bool nm_static_dns = dataValue2.toBool();
02719                                             if (nm_static_dns) {
02720                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
02721                                             }
02722                                             else {
02723                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
02724                                             }
02725                                         }
02726                                         else if (keyValue.lower() == "may-fail") {
02727                                             bool nm_may_fail = dataValue2.toBool();
02728                                             connection->requireIPV4 = !nm_may_fail;
02729                                         }
02730                                         else if (keyValue.lower() == "method") {
02731                                             TQString nm_method = dataValue2.toString().lower();
02732                                             if (nm_method == "auto") {
02733                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPIP;
02734                                             }
02735                                             else if (nm_method == "manual") {
02736                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPIP;
02737                                             }
02738                                             else if (nm_method == "link-local") {
02739                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4LocalOnly;
02740                                             }
02741                                             else if (nm_method == "shared") {
02742                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer;
02743                                             }
02744                                             else if (nm_method == "disabled") {
02745                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4Disabled;
02746                                             }
02747                                         }
02748                                         else if (keyValue.lower() == "ignore-auto-routes") {
02749                                             bool nm_static_routes = dataValue2.toBool();
02750                                             if (nm_static_routes) {
02751                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
02752                                             }
02753                                             else {
02754                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
02755                                             }
02756                                         }
02757                                         else if (keyValue.lower() == "never-default") {
02758                                             bool nm_can_default_route = !dataValue2.toBool();
02759                                             if (nm_can_default_route) {
02760                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
02761                                             }
02762                                             else {
02763                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
02764                                             }
02765                                         }
02766                                         else if (keyValue.lower() == "routes") {
02767                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02768                                             TQT_DBusDataValueList::const_iterator it4;
02769                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02770                                                 TQT_DBusData innerDataValue = *it4;
02771                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
02772                                                 TQT_DBusDataValueList::const_iterator it5;
02773                                                 state = 0;
02774                                                 TDENetworkSingleRouteConfiguration routeConfig;
02775                                                 for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
02776                                                     TQT_DBusData innerMostDataValue = *it5;
02777                                                     if (state == 0) {
02778                                                         // Address
02779                                                         routeConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
02780                                                     }
02781                                                     else if (state == 1) {
02782                                                         // Network mask
02783                                                         routeConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
02784                                                     }
02785                                                     else if (state == 2) {
02786                                                         // Gateway
02787                                                         routeConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
02788                                                     }
02789                                                     else if (state == 3) {
02790                                                         // Metric
02791                                                         routeConfig.metric = innerMostDataValue.toUInt32();
02792                                                     }
02793                                                     state++;
02794                                                 }
02795                                                 routeConfig.valid = true;
02796                                                 connection->ipConfig.routeConfigurations.append(routeConfig);
02797                                             }
02798                                         }
02799                                         connection->ipConfig.valid = true;
02800                                     }
02801                                     else if (outerKeyValue.lower() == "ipv6") {
02802                                         if (keyValue.lower() == "addresses") {
02803                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02804                                             TQT_DBusDataValueList::const_iterator it4;
02805                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02806                                                 TQT_DBusData innerDataValue = *it4;
02807                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
02808                                                 TQT_DBusDataValueList::const_iterator it5;
02809                                                 TDENetworkSingleIPConfiguration ipConfig;
02810                                                 // Address
02811                                                 TQT_DBusDataValueList innerMostValueList;
02812                                                 innerMostValueList = innerValueList[0].toTQValueList();
02813                                                 TQ_UINT8 nm_v6address[16];
02814                                                 unsigned char nm_addr_ptr = 0;
02815                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02816                                                 for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
02817                                                     TQT_DBusData innerMostDataValue = *it5;
02818                                                     if (nm_addr_ptr < 16) {
02819                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02820                                                         nm_addr_ptr++;
02821                                                     }
02822                                                 }
02823                                                 ipConfig.ipAddress = TQHostAddress(nm_v6address);
02824 
02825                                                 // Netmask
02826                                                 ipConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);
02827 
02828                                                 // Gateway
02829                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02830                                                 for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
02831                                                     TQT_DBusData innerMostDataValue = *it5;
02832                                                     if (nm_addr_ptr < 16) {
02833                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02834                                                         nm_addr_ptr++;
02835                                                     }
02836                                                 }
02837                                                 ipConfig.gateway = TQHostAddress(nm_v6address);
02838 
02839                                                 ipConfig.valid = true;
02840                                                 connection->ipConfig.ipConfigurations.append(ipConfig);
02841                                             }
02842                                         }
02843                                         else if (keyValue.lower() == "dns") {
02844                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02845                                             TQT_DBusDataValueList::const_iterator it4;
02846                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02847                                                 TQT_DBusData innerDataValue = *it4;
02848                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
02849                                                 TQT_DBusDataValueList::const_iterator it5;
02850                                                 TQ_UINT8 nm_v6address[16];
02851                                                 unsigned char nm_addr_ptr = 0;
02852                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02853                                                 for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
02854                                                     TQT_DBusData innerMostDataValue = *it5;
02855                                                     if (nm_addr_ptr < 16) {
02856                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02857                                                         nm_addr_ptr++;
02858                                                     }
02859                                                 }
02860                                                 connection->ipConfig.resolvers.append(TQHostAddress(nm_v6address));
02861                                             }
02862                                         }
02863                                         else if (keyValue.lower() == "dns-search") {
02864                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02865                                             TQT_DBusDataValueList::const_iterator it4;
02866                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02867                                                 TQT_DBusData innerDataValue = *it4;
02868                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
02869                                                 TQT_DBusDataValueList::const_iterator it5;
02870                                                 connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), true));
02871                                             }
02872                                         }
02873                                         else if (keyValue.lower() == "ignore-auto-dns") {
02874                                             bool nm_static_dns = dataValue2.toBool();
02875                                             if (nm_static_dns) {
02876                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
02877                                             }
02878                                             else {
02879                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
02880                                             }
02881                                         }
02882                                         else if (keyValue.lower() == "may-fail") {
02883                                             bool nm_may_fail = dataValue2.toBool();
02884                                             connection->requireIPV6 = !nm_may_fail;
02885                                         }
02886                                         else if (keyValue.lower() == "method") {
02887                                             TQString nm_method = dataValue2.toString().lower();
02888                                             if (nm_method == "auto") {
02889                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPIP;
02890                                             }
02891                                             else if (nm_method == "manual") {
02892                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPIP;
02893                                             }
02894                                             else if (nm_method == "link-local") {
02895                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6LocalOnly;
02896                                             }
02897                                             else if (nm_method == "shared") {
02898                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer;
02899                                             }
02900                                             else if (nm_method == "ignore") {
02901                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6Disabled;
02902                                             }
02903                                         }
02904                                         else if (keyValue.lower() == "ignore-auto-routes") {
02905                                             bool nm_static_routes = dataValue2.toBool();
02906                                             if (nm_static_routes) {
02907                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
02908                                             }
02909                                             else {
02910                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
02911                                             }
02912                                         }
02913                                         else if (keyValue.lower() == "never-default") {
02914                                             bool nm_can_default_route = !dataValue2.toBool();
02915                                             if (nm_can_default_route) {
02916                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
02917                                             }
02918                                             else {
02919                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
02920                                             }
02921                                         }
02922                                         else if (keyValue.lower() == "routes") {
02923                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02924                                             TQT_DBusDataValueList::const_iterator it4;
02925                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02926                                                 TQT_DBusData innerDataValue = *it4;
02927                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
02928                                                 TQT_DBusDataValueList::const_iterator it5;
02929                                                 TDENetworkSingleRouteConfiguration routeConfig;
02930                                                 // Address
02931                                                 TQT_DBusDataValueList innerMostValueList;
02932                                                 innerMostValueList = innerValueList[0].toTQValueList();
02933                                                 TQ_UINT8 nm_v6address[16];
02934                                                 unsigned char nm_addr_ptr = 0;
02935                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02936                                                 for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
02937                                                     TQT_DBusData innerMostDataValue = *it5;
02938                                                     if (nm_addr_ptr < 16) {
02939                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02940                                                         nm_addr_ptr++;
02941                                                     }
02942                                                 }
02943                                                 routeConfig.ipAddress = TQHostAddress(nm_v6address);
02944 
02945                                                 // Netmask
02946                                                 routeConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);
02947 
02948                                                 // Gateway
02949                                                 innerMostValueList = innerValueList[2].toTQValueList();
02950                                                 nm_addr_ptr = 0;
02951                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02952                                                 for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
02953                                                     TQT_DBusData innerMostDataValue = *it5;
02954                                                     if (nm_addr_ptr < 16) {
02955                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02956                                                         nm_addr_ptr++;
02957                                                     }
02958                                                 }
02959                                                 routeConfig.gateway = TQHostAddress(nm_v6address);
02960 
02961                                                 // Metric
02962                                                 routeConfig.metric = innerValueList[3].toUInt32();
02963 
02964                                                 routeConfig.valid = true;
02965                                                 connection->ipConfig.routeConfigurations.append(routeConfig);
02966                                             }
02967                                         }
02968                                         connection->ipConfig.valid = true;
02969                                     }
02970                                 }
02971                                 else {
02972                                     // FIXME
02973                                     // There are several advanced properties which appear to use string maps
02974                                     // For example, s390-options
02975                                     // Support should eventually be added for these, e.g. in a backend-specific Advanced tab somewhere
02976                                 }
02977                             }
02978                         }
02979                     }
02980 
02981                     // If the connection's MAC matches my MAC, or if the connection is not locked to any MAC address,
02982                     // or if this manager object is not locked to a device, then add this connection to the list
02983                     if ((deviceMACAddress == connection->lockedHWAddress) || (!connection->lockedHWAddress.isValid()) || (!deviceMACAddress.isValid())) {
02984                         loadConnectionAllowedValues(connection);
02985                         m_connectionList->append(connection);
02986                     }
02987                 }
02988                 else {
02989                     // Error!
02990                     PRINT_ERROR((error.name() + ": " + error.message()))
02991                 }
02992             }
02993         }
02994         else {
02995             // Error!
02996             PRINT_ERROR((error.name() + ": " + error.message()))
02997         }
02998         internalNetworkManagementEvent(TDENetworkGlobalEventType::ConnectionListChanged);
02999     }
03000 
03001     d->nonReentrantCallActive = false;
03002 }
03003 
03004 void TDENetworkConnectionManager_BackendNM::loadConnectionAllowedValues(TDENetworkConnection* connection) {
03005     if (connection) {
03006         // Insert all allowed EAP phase 2 methods
03007         connection->eapConfig.allowedPhase2NonEAPMethods.clear();
03008         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MD5);
03009         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
03010         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::OTP);
03011         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::GTC);
03012         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::TLS);
03013 
03014         connection->eapConfig.allowedPhase2EAPMethods.clear();
03015         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::PAP);
03016         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::CHAP);
03017         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAP);
03018         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
03019         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::OTP);
03020         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::GTC);
03021         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::TLS);
03022 
03023         connection->eapConfig.allowedValid = true;
03024     }
03025 }
03026 
03027 // NOTE
03028 // While this separate separate routine is needed to get the secrets, note that secrets must
03029 // be saved using the same connection map save routine that all other settings use above.
03030 bool TDENetworkConnectionManager_BackendNM::loadConnectionSecrets(TQString uuid) {
03031     TDENetworkConnection* connection = findConnectionByUUID(uuid);
03032     if (!connection) {
03033         PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database.  Did you run loadConnectionInformation() first?"));
03034         return FALSE;
03035     }
03036     //TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
03037     //TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
03038     TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
03039     TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
03040     //TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
03041     //TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
03042     //TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
03043     //TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
03044     TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
03045 
03046     bool ret = TRUE;
03047     ret = ret && loadConnectionSecretsForGroup(uuid, "802-1x");
03048     if (wiFiConnection) {
03049         ret = ret && loadConnectionSecretsForGroup(uuid, "802-11-wireless-security");
03050     }
03051     if (vpnConnection) {
03052         ret = ret && loadConnectionSecretsForGroup(uuid, "vpn");
03053     }
03054     ret = ret && loadConnectionSecretsForGroup(uuid, "pppoe");
03055     if (modemConnection) {
03056         ret = ret && loadConnectionSecretsForGroup(uuid, "cdma");
03057         ret = ret && loadConnectionSecretsForGroup(uuid, "gsm");
03058     }
03059     return ret;
03060 }
03061 
03062 bool TDENetworkConnectionManager_BackendNM::loadConnectionSecretsForGroup(TQString uuid, TQString group) {
03063     TDENetworkConnection* connection = findConnectionByUUID(uuid);
03064     if (!connection) {
03065         PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database.  Did you run loadConnectionInformation() first?"));
03066         return FALSE;
03067     }
03068     //TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
03069     //TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
03070     TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
03071     TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
03072     //TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
03073     //TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
03074     //TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
03075     //TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
03076     TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
03077     TQT_DBusObjectPath existingConnection;
03078     TQT_DBusError error;
03079     bool ret;
03080     TQT_DBusTQStringDataMap connectionSecretsMap(TQT_DBusData::String);
03081     ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
03082     if (ret) {
03083 #ifndef USE_ASYNC_DBUS_CALLS
03084         // Obtain connection settings from the path specified
03085         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
03086         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
03087         ret = connectionSettings.GetSecrets(group, connectionSecretsMap, error);
03088         if (ret && error.isValid()) {
03089             ret = 0;
03090             PRINT_ERROR((error.name() + ": " + error.message()))
03091         }
03092         if (ret) {
03093 #else // USE_ASYNC_DBUS_CALLS
03094         // Obtain connection secrets from the path specified
03095         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
03096         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
03097         connect(&connectionSettings, SIGNAL(GetSecretsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
03098         int asyncCallID;
03099         ret = connectionSettings.GetSecretsAsync(asyncCallID, group, error);
03100         if (ret && error.isValid()) {
03101             ret = 0;
03102             PRINT_ERROR((error.name() + ": " + error.message()))
03103         }
03104         if (ret) {
03105             // Wait for the asynchronous call to return...
03106             d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
03107             TQTimer nmCallTimeoutTimer;
03108             nmCallTimeoutTimer.start(NM_ASYNC_SECRETS_INTERACTION_TIMEOUT_MS, TRUE);
03109             while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
03110                 tqApp->processEvents();
03111                 if (!nmCallTimeoutTimer.isActive()) {
03112                     PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
03113                     break;
03114                 }
03115             }
03116             connectionSecretsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
03117             if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
03118                 PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
03119                 d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
03120             }
03121             d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
03122             if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
03123                 d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
03124             }
03125 #endif // USE_ASYNC_DBUS_CALLS
03126 
03127 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03128             printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
03129             printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSecretsMap));
03130 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03131 
03132             // Parse settings
03133             TQT_DBusTQStringDataMap::const_iterator it2;
03134             for (it2 = connectionSecretsMap.begin(); it2 != connectionSecretsMap.end(); ++it2) {
03135                 TQString outerKeyValue = it2.key();
03136                 TQT_DBusData dataValue = it2.data();
03137 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03138                 printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
03139 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03140                 TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
03141                 TQT_DBusTQStringDataMap::const_iterator it3;
03142                 for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
03143                     TQString keyValue = it3.key();
03144                     TQT_DBusData dataValue = it3.data();
03145                     if (dataValue.type() != TQT_DBusData::Variant) {
03146 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03147                         printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
03148 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03149                         // No NM settings are known which use this style
03150                     }
03151                     else {
03152                         TQT_DBusVariant dataValueVariant = dataValue.toVariant();
03153                         TQT_DBusData dataValue2 = dataValueVariant.value;
03154                         if (dataValue2.type() != TQT_DBusData::Variant) {
03155 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03156                             printf("[network-manager comm debug] %s = %s (type %d(%s), signature %s)\n", keyValue.ascii(), dataValue2.toString().ascii(), dataValue2.type(), dataValue2.typeName(), dataValueVariant.signature.ascii()); fflush(stdout);
03157 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03158                             // Most NM settings use this style
03159                             if (outerKeyValue.lower() == "802-1x") {
03160                                 if (keyValue.lower() == "password") {
03161                                     connection->eapConfig.password = dataValue2.toString();
03162                                 }
03163                                 else if (keyValue.lower() == "password-raw") {
03164                                     TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
03165                                     TQT_DBusDataValueList::const_iterator it4;
03166                                     int count=0;
03167                                     for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
03168                                         TQT_DBusData innerDataValue = *it4;
03169                                         count++;
03170                                         connection->eapConfig.binaryPassword.resize(count+1);
03171                                         connection->eapConfig.binaryPassword[count] = innerDataValue.toByte();
03172                                     }
03173                                 }
03174                                 else if (keyValue.lower() == "private-key-password") {
03175                                     connection->eapConfig.privateKeyPassword = dataValue2.toString();
03176                                 }
03177                                 else if (keyValue.lower() == "phase2-private-key-password") {
03178                                     connection->eapConfig.phase2PrivateKeyPassword = dataValue2.toString();
03179                                 }
03180                                 connection->eapConfig.secretsValid = true;
03181                             }
03182                             if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
03183                                 if (keyValue.lower() == "wep-key0") {
03184                                     wiFiConnection->securitySettings.wepKey0 = dataValue2.toString();
03185                                     wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey0);
03186                                 }
03187                                 else if (keyValue.lower() == "wep-key1") {
03188                                     wiFiConnection->securitySettings.wepKey1 = dataValue2.toString();
03189                                     wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey1);
03190                                 }
03191                                 else if (keyValue.lower() == "wep-key2") {
03192                                     wiFiConnection->securitySettings.wepKey2 = dataValue2.toString();
03193                                     wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey2);
03194                                 }
03195                                 else if (keyValue.lower() == "wep-key3") {
03196                                     wiFiConnection->securitySettings.wepKey3 = dataValue2.toString();
03197                                     wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey3);
03198                                 }
03199                                 else if (keyValue.lower() == "psk") {
03200                                     wiFiConnection->securitySettings.psk = dataValue2.toString();
03201                                 }
03202                                 else if (keyValue.lower() == "eap-password") {
03203                                     wiFiConnection->securitySettings.leapPassword = dataValue2.toString();
03204                                 }
03205                             }
03206                             if ((outerKeyValue.lower() == "vpn") && (vpnConnection)) {
03207                                 if (keyValue.lower() == "secrets") {
03208                                     TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
03209                                     TQT_DBusTQStringDataMap::const_iterator it4;
03210                                     for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
03211                                         vpnConnection->pluginSecrets.clear();
03212                                         TQString keyValue4 = it4.key();
03213                                         TQT_DBusData dataValue4 = it4.data();
03214                                         if (dataValue4.type() == TQT_DBusData::String) {
03215                                             vpnConnection->pluginSecrets[keyValue4] = dataValue4.toString();
03216                                         }
03217                                     }
03218                                     vpnConnection->secretsValid = true;
03219                                 }
03220                             }
03221                             if (outerKeyValue.lower() == "pppoe") {
03222                                 if (keyValue.lower() == "password") {
03223                                     connection->pppoeConfig.password = dataValue2.toString();
03224                                 }
03225                                 connection->pppoeConfig.secretsValid = true;
03226                             }
03227                             if (outerKeyValue.lower() == "cdma") {
03228                                 if (keyValue.lower() == "password") {
03229                                     modemConnection->cdmaConfig.password = dataValue2.toString();
03230                                 }
03231                                 modemConnection->cdmaConfig.secretsValid = true;
03232                             }
03233                             if (outerKeyValue.lower() == "gsm") {
03234                                 if (keyValue.lower() == "password") {
03235                                     modemConnection->gsmConfig.password = dataValue2.toString();
03236                                 }
03237                                 else if (keyValue.lower() == "pin") {
03238                                     modemConnection->gsmConfig.pin = dataValue2.toString();
03239                                 }
03240                                 modemConnection->gsmConfig.secretsValid = true;
03241                             }
03242                         }
03243                     }
03244                 }
03245             }
03246             return TRUE;
03247         }
03248         else {
03249             PRINT_ERROR(TQString("Unable to load secrets for connection with uuid '%1'").arg(uuid))
03250             return FALSE;
03251         }
03252     }
03253     else {
03254         PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
03255         return FALSE;
03256     }
03257 }
03258 
03259 bool TDENetworkConnectionManager_BackendNM::saveConnection(TDENetworkConnection* connection) {
03260     bool timed_out = FALSE;
03261     bool command_failed = FALSE;
03262 
03263     if (!connection) {
03264         PRINT_ERROR(TQString("connection cannot be NULL!"));
03265         return FALSE;
03266     }
03267 
03268     // If the UUID is blank, generate a new UUID for this connection and also guarantee that it it truly unique
03269     if (connection->UUID == "") {
03270         bool unique = false;
03271         while (!unique) {
03272             connection->UUID = TQUuid::createUuid().toString();
03273             connection->UUID.replace("{", "");
03274             connection->UUID.replace("}", "");
03275             if (!findConnectionByUUID(connection->UUID)) {
03276                 unique = true;
03277             }
03278         }
03279     }
03280 
03281     // Find path for connection with specified UUID, if it exists
03282     // This is so that any settings that we are not aware of can be loaded now and preserved through the update operation
03283     TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
03284     TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
03285     TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
03286     TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
03287     TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
03288     TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
03289     TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEOLPCMeshConnection*>(connection);
03290     TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
03291     TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
03292     TQT_DBusObjectPath existingConnection;
03293     TQT_DBusError error;
03294     bool ret;
03295     bool existing;
03296     TQT_DBusTQStringDataMap connectionSettingsMap(TQT_DBusData::String);
03297     existing = false;
03298     ret = d->m_networkManagerSettings->GetConnectionByUuid(connection->UUID, existingConnection, error);
03299     if (ret) {
03300 #ifndef USE_ASYNC_DBUS_CALLS
03301         // Obtain connection settings from the path specified
03302         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
03303         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
03304         ret = connectionSettings.GetSettings(connectionSettingsMap, error);
03305         if (ret && error.isValid()) {
03306             ret = 0;
03307             PRINT_ERROR((error.name() + ": " + error.message()))
03308         }
03309         if (ret) {
03310 #else // USE_ASYNC_DBUS_CALLS
03311         // Obtain connection settings from the path specified
03312         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
03313         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
03314         connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
03315         int asyncCallID;
03316         ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
03317         if (ret && error.isValid()) {
03318             ret = 0;
03319             PRINT_ERROR((error.name() + ": " + error.message()))
03320         }
03321         if (ret) {
03322             // Wait for the asynchronous call to return...
03323             d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
03324             TQTimer nmCallTimeoutTimer;
03325             nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
03326             while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
03327                 tqApp->processEvents();
03328                 if (!nmCallTimeoutTimer.isActive()) {
03329                     PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
03330                     timed_out = true;
03331                     break;
03332                 }
03333             }
03334             connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
03335             if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
03336                 PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
03337                 d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
03338             }
03339             d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
03340             if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
03341                 d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
03342             }
03343 #endif // USE_ASYNC_DBUS_CALLS
03344             existing = true;
03345         }
03346     }
03347 
03348     // Create and/or update settings map from provided connection information
03349     // We start at the outermost layer and work our way inwards, in a structure which should match the parser in loadConnectionInformation() very closely
03350     bool groupValid;
03351     TQT_DBusData dbusData;
03352     TQT_DBusData innerDbusData;
03353     TQMap<TQString, TQT_DBusData> outerMap = connectionSettingsMap.toTQMap();
03354     {
03355         groupValid = false;
03356         dbusData = outerMap["connection"];
03357         {
03358             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03359             {
03360                 settingsMap["id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->friendlyName));
03361                 {
03362                     TQString type;
03363                     if (ethernetConnection) type = "802-3-ethernet";
03364                     else if (infinibandConnection) type = "infiniband";
03365                     else if (wiFiConnection) type = "802-11-wireless";
03366                     else if (vpnConnection) type = "vpn";
03367                     else if (wiMaxConnection) type = "wimax";
03368                     else if (vlanConnection) type = "vlan";
03369                     else if (olpcMeshConnection) type = "802-11-olpc-mesh";
03370                     else if (bluetoothConnection) type = "bluetooth";
03371                     else if (modemConnection) {
03372                         if (modemConnection->type == TDEModemConnectionType::CDMA) {
03373                             type = "cdma";
03374                         }
03375                         else if (modemConnection->type == TDEModemConnectionType::GSM) {
03376                             type = "gsm";
03377                         }
03378                     }
03379                     if (!type.isNull()) settingsMap["type"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(type));
03380                 }
03381                 settingsMap["uuid"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->UUID));
03382                 {
03383                     TQT_DBusDataValueList valueList;
03384                     {
03385                         for (TQStringList::Iterator it = connection->authorizedUsers.begin(); it != connection->authorizedUsers.end(); ++it) {
03386                             TQString assembledString = TQString("user:%1:").arg(*it);
03387                             valueList.append(TQT_DBusData::fromString(assembledString));
03388                         }
03389                     }
03390                     if (valueList.count() > 0) settingsMap["permissions"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03391                     else settingsMap.remove("permissions");
03392                 }
03393                 settingsMap["autoconnect"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->autoConnect));
03394                 settingsMap["read-only"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->readOnly));
03395                 UPDATE_STRING_SETTING_IF_VALID(connection->masterConnectionUUID, "master", settingsMap)
03396                 {
03397                     TQString slaveType = tdeSlaveTypeToNMSlaveType(connection->slaveType);
03398                     if (slaveType != "") settingsMap["slave-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(slaveType));
03399                     else settingsMap.remove("slave-type");
03400                 }
03401                 // settingsMap["timestamp"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt64(connection->lastKnownConnection.toTime_t()));   // Probably read-only to us
03402             }
03403             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03404             groupValid = (settingsMap.count() > 0);
03405         }
03406         if (groupValid) outerMap.insert("connection", dbusData, TRUE); else outerMap.remove("connection");
03407 
03408         groupValid = false;
03409         dbusData = outerMap["802-1x"];
03410         {
03411             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03412             {
03413                 if (connection->eapConfig.valid) {
03414                     TQT_DBusDataValueList valueList;
03415                     {
03416                         // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
03417                         // EAP type
03418                         valueList.append(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.type)));
03419                     }
03420                     settingsMap["eap"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03421                 }
03422                 else {
03423                     settingsMap.remove("eap");
03424                 }
03425                 if (connection->eapConfig.valid) {
03426                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.userName, "identity", settingsMap)
03427                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.anonymousUserName, "anonymous-identity", settingsMap)
03428                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.pacFileName, "pac-file", settingsMap)
03429                 }
03430                 else {
03431                     settingsMap.remove("identity");
03432                     settingsMap.remove("anonymous-identity");
03433                     settingsMap.remove("pac-file");
03434                 }
03435                 if (connection->eapConfig.valid) {
03436                     TQT_DBusDataValueList valueList;
03437                     {
03438                         unsigned int count;
03439                         for (count=0; count<connection->eapConfig.caCertificate.count(); count++) {
03440                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.caCertificate[count]));
03441                         }
03442                     }
03443                     if (valueList.count() > 0) settingsMap["ca-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03444                     else settingsMap.remove("ca-cert");
03445                 }
03446                 else {
03447                     settingsMap.remove("ca-cert");
03448                 }
03449                 if (connection->eapConfig.valid) {
03450                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.additionalCAFilesPath, "ca-path", settingsMap)
03451                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.authServerCertSubjectMatch, "subject-match", settingsMap)
03452                 }
03453                 else {
03454                     settingsMap.remove("ca-path");
03455                     settingsMap.remove("subject-match");
03456                 }
03457                 if (connection->eapConfig.valid) {
03458                     TQT_DBusDataValueList valueList;
03459                     {
03460                         for (TQStringList::Iterator it = connection->eapConfig.alternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.alternateAuthServerCertSubjectMatch.end(); ++it) {
03461                             valueList.append(TQT_DBusData::fromString(*it));
03462                         }
03463                     }
03464                     if (valueList.count() > 0) settingsMap["altsubject-matches"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03465                     else settingsMap.remove("altsubject-matches");
03466                 }
03467                 else {
03468                     settingsMap.remove("altsubject-matches");
03469                 }
03470                 if (connection->eapConfig.valid) {
03471                     TQT_DBusDataValueList valueList;
03472                     {
03473                         unsigned int count;
03474                         for (count=0; count<connection->eapConfig.clientCertificate.count(); count++) {
03475                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.clientCertificate[count]));
03476                         }
03477                     }
03478                     if (valueList.count() > 0) settingsMap["client-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03479                     else settingsMap.remove("client-cert");
03480                 }
03481                 else {
03482                     settingsMap.remove("client-cert");
03483                 }
03484                 if (connection->eapConfig.valid) {
03485                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPVersion, "phase1-peapver", settingsMap)
03486                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPLabel, "phase1-peaplabel", settingsMap)
03487                     UPDATE_STRING_SETTING_IF_VALID(tdeEAPFastFlagsToNMEAPFastFlags(connection->eapConfig.fastProvisioningFlags), "phase1-fast-provisioning", settingsMap)
03488                 }
03489                 else {
03490                     settingsMap.remove("phase1-peapver");
03491                     settingsMap.remove("phase1-peaplabel");
03492                     settingsMap.remove("phase1-fast-provisioning");
03493                 }
03494                 if (connection->eapConfig.valid) {
03495                     settingsMap["phase2-auth"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2NonEAPAuthMethod)));
03496                     settingsMap["phase2-autheap"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2EAPAuthMethod)));
03497                 }
03498                 else {
03499                     settingsMap.remove("phase2-auth");
03500                     settingsMap.remove("phase2-autheap");
03501                 }
03502                 if (connection->eapConfig.valid) {
03503                     TQT_DBusDataValueList valueList;
03504                     {
03505                         unsigned int count;
03506                         for (count=0; count<connection->eapConfig.phase2CaCertificate.count(); count++) {
03507                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2CaCertificate[count]));
03508                         }
03509                     }
03510                     if (valueList.count() > 0) settingsMap["phase2-ca-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03511                     else settingsMap.remove("phase2-ca-cert");
03512                 }
03513                 else {
03514                     settingsMap.remove("phase2-ca-cert");
03515                 }
03516                 if (connection->eapConfig.valid) {
03517                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2CaFilesPath, "phase2-ca-path", settingsMap)
03518                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2AuthServerCertSubjectMatch, "phase2-subject-match", settingsMap)
03519                 }
03520                 else {
03521                     settingsMap.remove("phase2-ca-path");
03522                     settingsMap.remove("phase2-subject-match");
03523                 }
03524                 if (connection->eapConfig.valid) {
03525                     TQT_DBusDataValueList valueList;
03526                     {
03527                         for (TQStringList::Iterator it = connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.end(); ++it) {
03528                             valueList.append(TQT_DBusData::fromString(*it));
03529                         }
03530                     }
03531                     if (valueList.count() > 0) settingsMap["phase2-altsubject-matches"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03532                     else settingsMap.remove("phase2-altsubject-matches");
03533                 }
03534                 else {
03535                     settingsMap.remove("phase2-altsubject-matches");
03536                 }
03537                 if (connection->eapConfig.valid) {
03538                     TQT_DBusDataValueList valueList;
03539                     {
03540                         unsigned int count;
03541                         for (count=0; count<connection->eapConfig.phase2ClientCertificate.count(); count++) {
03542                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2ClientCertificate[count]));
03543                         }
03544                     }
03545                     if (valueList.count() > 0) settingsMap["phase2-client-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03546                     else settingsMap.remove("phase2-client-cert");
03547                 }
03548                 else {
03549                     settingsMap.remove("phase2-client-cert");
03550                 }
03551                 if (connection->eapConfig.valid) {
03552                     settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.passwordFlags)));
03553                     settingsMap["password-raw-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.binaryPasswordFlags)));
03554                 }
03555                 else {
03556                     settingsMap.remove("password-flags");
03557                     settingsMap.remove("password-raw-flags");
03558                 }
03559                 if (connection->eapConfig.valid) {
03560                     TQT_DBusDataValueList valueList;
03561                     {
03562                         unsigned int count;
03563                         for (count=0; count<connection->eapConfig.privateKey.count(); count++) {
03564                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.privateKey[count]));
03565                         }
03566                     }
03567                     if (valueList.count() > 0) settingsMap["private-key"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03568                     else settingsMap.remove("private-key");
03569                 }
03570                 else {
03571                     settingsMap.remove("private-key");
03572                 }
03573                 if (connection->eapConfig.valid) {
03574                     settingsMap["private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.privateKeyPasswordFlags)));
03575                 }
03576                 else {
03577                     settingsMap.remove("private-key-password-flags");
03578                 }
03579                 if (connection->eapConfig.valid) {
03580                     TQT_DBusDataValueList valueList;
03581                     {
03582                         unsigned int count;
03583                         for (count=0; count<connection->eapConfig.phase2PrivateKey.count(); count++) {
03584                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2PrivateKey[count]));
03585                         }
03586                     }
03587                     if (valueList.count() > 0) settingsMap["phase2-private-key"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03588                     else settingsMap.remove("phase2-private-key");
03589                 }
03590                 else {
03591                     settingsMap.remove("phase2-private-key");
03592                 }
03593                 if (connection->eapConfig.valid) {
03594                     settingsMap["phase2-private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.phase2PrivateKeyPasswordFlags)));
03595                 }
03596                 else {
03597                     settingsMap.remove("phase2-private-key-password-flags");
03598                 }
03599                 if (connection->eapConfig.valid) {
03600                     settingsMap["system-ca-certs"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->eapConfig.forceSystemCaCertificates));
03601                 }
03602                 else {
03603                     settingsMap.remove("system-ca-certs");
03604                 }
03605                 if (connection->eapConfig.secretsValid) {
03606                     settingsMap["password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.password));
03607                 }
03608                 else {
03609                     settingsMap.remove("password");
03610                 }
03611                 if (connection->eapConfig.valid) {
03612                     TQT_DBusDataValueList valueList;
03613                     {
03614                         unsigned int count;
03615                         for (count=0; count<connection->eapConfig.binaryPassword.count(); count++) {
03616                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.binaryPassword[count]));
03617                         }
03618                     }
03619                     if (valueList.count() > 0) settingsMap["password-raw"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03620                     else settingsMap.remove("password-raw");
03621                 }
03622                 else {
03623                     settingsMap.remove("password-raw");
03624                 }
03625                 if (connection->eapConfig.secretsValid) {
03626                     settingsMap["private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.privateKeyPassword));
03627                     settingsMap["phase2-private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.phase2PrivateKeyPassword));
03628                 }
03629                 else {
03630                     settingsMap.remove("private-key-password");
03631                     settingsMap.remove("phase2-private-key-password");
03632                 }
03633             }
03634             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03635             groupValid = (settingsMap.count() > 0);
03636         }
03637         if (groupValid) outerMap.insert("802-1x", dbusData, TRUE); else outerMap.remove("802-1x");
03638 
03639         groupValid = false;
03640         dbusData = outerMap["802-3-ethernet"];
03641         if (ethernetConnection) {
03642             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03643             {
03644                 settingsMap["duplex"] = convertDBUSDataToVariantData(TQT_DBusData::fromString((connection->fullDuplex)?"full":"half"));
03645                 if (connection->lockedHWAddress.isValid()) {
03646                     TDENetworkByteList address = connection->lockedHWAddress.address();
03647                     TQT_DBusDataValueList valueList;
03648                     TDENetworkByteList::iterator it;
03649                     for (it = address.begin(); it != address.end(); ++it) {
03650                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03651                         valueList.append(innerDataValue);
03652                     }
03653                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03654                     settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03655                 }
03656                 else {
03657                     settingsMap.remove("mac-address");
03658                 }
03659                 if (connection->manualHWAddress.isValid()) {
03660                     TDENetworkByteList address = connection->manualHWAddress.address();
03661                     TQT_DBusDataValueList valueList;
03662                     TDENetworkByteList::iterator it;
03663                     for (it = address.begin(); it != address.end(); ++it) {
03664                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03665                         valueList.append(innerDataValue);
03666                     }
03667                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03668                     settingsMap["cloned-mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03669                 }
03670                 else {
03671                     settingsMap.remove("cloned-mac-address");
03672                 }
03673                 if (connection->mtu > 0) {
03674                     settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
03675                 }
03676                 else {
03677                     settingsMap.remove("mtu");
03678                 }
03679             }
03680             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03681             groupValid = (settingsMap.count() > 0);
03682         }
03683         if (groupValid) outerMap.insert("802-3-ethernet", dbusData, TRUE); else outerMap.remove("802-3-ethernet");
03684 
03685         groupValid = false;
03686         dbusData = outerMap["infiniband"];
03687         if (infinibandConnection) {
03688             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03689             {
03690                 if (connection->lockedHWAddress.isValid()) {
03691                     TDENetworkByteList address = connection->lockedHWAddress.address();
03692                     TQT_DBusDataValueList valueList;
03693                     TDENetworkByteList::iterator it;
03694                     for (it = address.begin(); it != address.end(); ++it) {
03695                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03696                         valueList.append(innerDataValue);
03697                     }
03698                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03699                     settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03700                 }
03701                 else {
03702                     settingsMap.remove("mac-address");
03703                 }
03704                 if (connection->mtu > 0) {
03705                     settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
03706                 }
03707                 else {
03708                     settingsMap.remove("mtu");
03709                 }
03710                 UPDATE_STRING_SETTING_IF_VALID(tdeIBTransportToNMIBTransport(infinibandConnection->transportMode), "transport-mode", settingsMap)
03711             }
03712             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03713             groupValid = (settingsMap.count() > 0);
03714         }
03715         if (groupValid) outerMap.insert("infiniband", dbusData, TRUE); else outerMap.remove("infiniband");
03716 
03717         groupValid = false;
03718         dbusData = outerMap["802-11-wireless"];
03719         if (wiFiConnection) {
03720             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03721             {
03722                 {
03723                     unsigned int i;
03724                     TQT_DBusDataValueList valueList;
03725                     for (i=0; i<wiFiConnection->SSID.count(); i++) {
03726                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(wiFiConnection->SSID[i]);
03727                         valueList.append(innerDataValue);
03728                     }
03729                     settingsMap["ssid"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03730                 }
03731                 if (connection->lockedHWAddress.isValid()) {
03732                     TDENetworkByteList address = connection->lockedHWAddress.address();
03733                     TQT_DBusDataValueList valueList;
03734                     TDENetworkByteList::iterator it;
03735                     for (it = address.begin(); it != address.end(); ++it) {
03736                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03737                         valueList.append(innerDataValue);
03738                     }
03739                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03740                     settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03741                 }
03742                 else {
03743                     settingsMap.remove("mac-address");
03744                 }
03745                 if (connection->manualHWAddress.isValid()) {
03746                     TDENetworkByteList address = connection->manualHWAddress.address();
03747                     TQT_DBusDataValueList valueList;
03748                     TDENetworkByteList::iterator it;
03749                     for (it = address.begin(); it != address.end(); ++it) {
03750                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03751                         valueList.append(innerDataValue);
03752                     }
03753                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03754                     settingsMap["cloned-mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03755                 }
03756                 else {
03757                     settingsMap.remove("cloned-mac-address");
03758                 }
03759                 if (connection->mtu > 0) {
03760                     settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
03761                 }
03762                 else {
03763                     settingsMap.remove("mtu");
03764                 }
03765                 UPDATE_STRING_SETTING_IF_VALID(tdeWiFiModeToNMWiFiMode(wiFiConnection->operatingMode), "mode", settingsMap)
03766                 UPDATE_STRING_SETTING_IF_VALID(tdeWiFiFrequencyBandToNMWiFiFrequencyBand(wiFiConnection->bandRestriction), "band", settingsMap)
03767                 if (wiFiConnection->channelRestriction > 0) {
03768                     settingsMap["channel"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->channelRestriction));
03769                 }
03770                 else {
03771                     settingsMap.remove("channel");
03772                 }
03773                 if (wiFiConnection->bitRateRestriction > 0) {
03774                     settingsMap["rate"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->bitRateRestriction/1000));
03775                 }
03776                 else {
03777                     settingsMap.remove("rate");
03778                 }
03779                 if (wiFiConnection->powerRestriction > 0) {
03780                     settingsMap["tx-power"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->powerRestriction));
03781                 }
03782                 else {
03783                     settingsMap.remove("tx-power");
03784                 }
03785                 if (wiFiConnection->accessPointRestriction.isValid()) {
03786                     TDENetworkByteList address = wiFiConnection->accessPointRestriction.address();
03787                     TQT_DBusDataValueList valueList;
03788                     TDENetworkByteList::iterator it;
03789                     for (it = address.begin(); it != address.end(); ++it) {
03790                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03791                         valueList.append(innerDataValue);
03792                     }
03793                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03794                     settingsMap["bssid"] = convertDBUSDataToVariantData(nmHWAddress);
03795                 }
03796                 else {
03797                     settingsMap.remove("bssid");
03798                 }
03799                 {
03800                     TQT_DBusDataValueList valueList;
03801                     TDEMACAddressList::iterator it;
03802                     for (it = wiFiConnection->blacklistedBSSIDs.begin(); it != wiFiConnection->blacklistedBSSIDs.end(); ++it) {
03803                         valueList.append(TQT_DBusData::fromString((*it).toString()));
03804                     }
03805                     if (valueList.count() > 0) settingsMap["mac-address-blacklist"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03806                 }
03807                 {
03808                     TQT_DBusDataValueList valueList;
03809                     TDEMACAddressList::iterator it;
03810                     for (it = wiFiConnection->heardBSSIDs.begin(); it != wiFiConnection->heardBSSIDs.end(); ++it) {
03811                         valueList.append(TQT_DBusData::fromString((*it).toString()));
03812                     }
03813                     if (valueList.count() > 0) settingsMap["seen-bssids"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03814                 }
03815                 {
03816                     if (wiFiConnection->securityRequired) {
03817                         settingsMap["security"] = convertDBUSDataToVariantData(TQT_DBusData::fromString("802-11-wireless-security"));
03818                     }
03819                     else {
03820                         settingsMap.remove("security");
03821                     }
03822                 }
03823                 {
03824                     if (wiFiConnection->isHiddenNetwork) {
03825                         settingsMap["hidden"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(true));
03826                     }
03827                     else {
03828                         settingsMap.remove("hidden");
03829                     }
03830                 }
03831             }
03832             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03833             groupValid = (settingsMap.count() > 0);
03834         }
03835         if (groupValid) outerMap.insert("802-11-wireless", dbusData, TRUE); else outerMap.remove("802-11-wireless");
03836 
03837         groupValid = false;
03838         dbusData = outerMap["802-11-wireless-security"];
03839         if (wiFiConnection) {
03840             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03841             {
03842                 if (wiFiConnection->securityRequired) {
03843                     if (wiFiConnection->securityRequired) {
03844                         settingsMap["key-mgmt"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeWiFiKeyTypeToNMWiFiKeyType(wiFiConnection->securitySettings.keyType)));
03845                     }
03846                     if (wiFiConnection->securitySettings.wepKeyIndex > 0) {
03847                         settingsMap["wep-tx-keyidx"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->securitySettings.wepKeyIndex));
03848                     }
03849                     else {
03850                         settingsMap.remove("wep-tx-keyidx");
03851                     }
03852                     UPDATE_STRING_SETTING_IF_VALID(tdeWiFiAuthTypeToNMWiFiAuthType(wiFiConnection->securitySettings.authType), "auth-alg", settingsMap)
03853                     {
03854                         TQT_DBusDataValueList valueList;
03855                         {
03856                             TQStringList strings = tdeWiFiWPAVersionToNMWiFiWPAVersion(wiFiConnection->securitySettings.wpaVersion);
03857                             for (TQStringList::Iterator it = strings.begin(); it != strings.end(); ++it) {
03858                                 valueList.append(TQT_DBusData::fromString(*it));
03859                             }
03860                         }
03861                         if (valueList.count() > 0) settingsMap["proto"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03862                         else settingsMap.remove("proto");
03863                     }
03864                     {
03865                         TQT_DBusDataValueList valueList;
03866                         {
03867                             if (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
03868                                 if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
03869                                 if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
03870                                 if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
03871                                 if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
03872                             }
03873                             for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedPairWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedPairWiseCiphers.end(); ++it) {
03874                                 valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
03875                             }
03876                         }
03877                         if (valueList.count() > 0) settingsMap["pairwise"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03878                         else settingsMap.remove("pairwise");
03879                     }
03880                     {
03881                         TQT_DBusDataValueList valueList;
03882                         {
03883                             if (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
03884                                 if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
03885                                 if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
03886                                 if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
03887                                 if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
03888                             }
03889                             for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedGroupWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedGroupWiseCiphers.end(); ++it) {
03890                                 valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
03891                             }
03892                         }
03893                         if (valueList.count() > 0) settingsMap["group"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03894                         else settingsMap.remove("group");
03895                     }
03896                     UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapUsername, "leap-username", settingsMap)
03897                     settingsMap["wep-key-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.wepKeyFlags)));
03898                     settingsMap["wep-key-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType)));
03899                     settingsMap["psk-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.pskFlags)));
03900                     settingsMap["leap-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.leapPasswordFlags)));
03901                     if (wiFiConnection->securitySettings.secretsValid) {
03902                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey0, "wep-key0", settingsMap)
03903                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey1, "wep-key1", settingsMap)
03904                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey2, "wep-key2", settingsMap)
03905                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey3, "wep-key3", settingsMap)
03906                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.psk, "psk", settingsMap)
03907                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapPassword, "leap-password", settingsMap)
03908                     }
03909                     else {
03910                         settingsMap.remove("wep-key0");
03911                         settingsMap.remove("wep-key1");
03912                         settingsMap.remove("wep-key2");
03913                         settingsMap.remove("wep-key3");
03914                         settingsMap.remove("psk");
03915                         settingsMap.remove("leap-password");
03916                     }
03917                 }
03918                 else {
03919                     settingsMap.remove("key-mgmt");
03920                     settingsMap.remove("wep-tx-keyidx");
03921                     settingsMap.remove("auth-alg");
03922                     settingsMap.remove("proto");
03923                     settingsMap.remove("pairwise");
03924                     settingsMap.remove("group");
03925                     settingsMap.remove("leap-username");
03926                     settingsMap.remove("wep-key-flags");
03927                     settingsMap.remove("wep-key-type");
03928                     settingsMap.remove("psk-flags");
03929                     settingsMap.remove("leap-password-flags");
03930                     settingsMap.remove("wep-key0");
03931                     settingsMap.remove("wep-key1");
03932                     settingsMap.remove("wep-key2");
03933                     settingsMap.remove("wep-key3");
03934                     settingsMap.remove("psk");
03935                     settingsMap.remove("leap-password");
03936                 }
03937             }
03938             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03939             groupValid = (settingsMap.count() > 0);
03940         }
03941         if (groupValid) outerMap.insert("802-11-wireless-security", dbusData, TRUE); else outerMap.remove("802-11-wireless-security");
03942 
03943         groupValid = false;
03944         dbusData = outerMap["vpn"];
03945         if (vpnConnection) {
03946             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03947             {
03948                 {
03949                     TQString pluginService = vpnConnection->vpnPluginID;
03950                     if (pluginService != "") {
03951                         pluginService = "org.freedesktop.NetworkManager." + pluginService;
03952                     }
03953                     UPDATE_STRING_SETTING_IF_VALID(pluginService, "service-type", settingsMap)
03954                 }
03955                 UPDATE_STRING_SETTING_IF_VALID(vpnConnection->lockedUserName, "user-name", settingsMap)
03956                 {
03957                     TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
03958                     TDENetworkSettingsMap::const_iterator it;
03959                     for (it = vpnConnection->pluginData.begin(); it != vpnConnection->pluginData.end(); ++it) {
03960                         nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
03961                     }
03962                     if (nestedConnectionSettingsMap.count() > 0) settingsMap["data"] = convertDBUSDataToVariantData(TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap)));
03963                     else settingsMap.remove("data");
03964                 }
03965                 if (vpnConnection->secretsValid) {
03966                     TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
03967                     TDENetworkSettingsMap::const_iterator it;
03968                     for (it = vpnConnection->pluginSecrets.begin(); it != vpnConnection->pluginSecrets.end(); ++it) {
03969                         nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
03970                     }
03971                     if (nestedConnectionSettingsMap.count() > 0) settingsMap["secrets"] = convertDBUSDataToVariantData(TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap)));
03972                     else settingsMap.remove("secrets");
03973                 }
03974             }
03975             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03976             groupValid = (settingsMap.count() > 0);
03977         }
03978         if (groupValid) outerMap.insert("vpn", dbusData, TRUE); else outerMap.remove("vpn");
03979 
03980         groupValid = false;
03981         dbusData = outerMap["wimax"];
03982         if (wiMaxConnection) {
03983             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03984             {
03985                 if (connection->lockedHWAddress.isValid()) {
03986                     TDENetworkByteList address = connection->lockedHWAddress.address();
03987                     TQT_DBusDataValueList valueList;
03988                     TDENetworkByteList::iterator it;
03989                     for (it = address.begin(); it != address.end(); ++it) {
03990                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03991                         valueList.append(innerDataValue);
03992                     }
03993                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03994                     settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03995                 }
03996                 else {
03997                     settingsMap.remove("mac-address");
03998                 }
03999                 UPDATE_STRING_SETTING_IF_VALID(wiMaxConnection->networkServiceProvider, "network-name", settingsMap)
04000             }
04001             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04002             groupValid = (settingsMap.count() > 0);
04003         }
04004         if (groupValid) outerMap.insert("wimax", dbusData, TRUE); else outerMap.remove("wimax");
04005 
04006         groupValid = false;
04007         dbusData = outerMap["vlan"];
04008         if (vlanConnection) {
04009             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04010             {
04011                 UPDATE_STRING_SETTING_IF_VALID(vlanConnection->kernelName, "interface-name", settingsMap)
04012                 UPDATE_STRING_SETTING_IF_VALID(vlanConnection->parentConnectionUUID, "parent", settingsMap)
04013                 settingsMap["id"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(vlanConnection->vlanID));
04014                 settingsMap["flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdeVLANFlagsToNMVLANFlags(vlanConnection->vlanFlags)));
04015                 {
04016                     TQT_DBusDataValueList valueList;
04017                     TDENetworkPriorityMap::const_iterator it;
04018                     for (it = vlanConnection->ingressPriorityMap.begin(); it != vlanConnection->ingressPriorityMap.end(); ++it) {
04019                         valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
04020                     }
04021                     if (valueList.count() > 0) settingsMap["ingress-priority-map"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04022                 }
04023                 {
04024                     TQT_DBusDataValueList valueList;
04025                     TDENetworkPriorityMap::const_iterator it;
04026                     for (it = vlanConnection->egressPriorityMap.begin(); it != vlanConnection->egressPriorityMap.end(); ++it) {
04027                         valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
04028                     }
04029                     if (valueList.count() > 0) settingsMap["egress-priority-map"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04030                 }
04031             }
04032             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04033             groupValid = (settingsMap.count() > 0);
04034         }
04035         if (groupValid) outerMap.insert("vlan", dbusData, TRUE); else outerMap.remove("vlan");
04036 
04037         groupValid = false;
04038         dbusData = outerMap["serial"];
04039         if (connection->serialConfig.valid) {
04040             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04041             {
04042                 settingsMap["baud"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.baudRate));
04043                 settingsMap["bits"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.byteWidth));
04044                 settingsMap["parity"] = convertDBUSDataToVariantData(TQT_DBusData::fromByte(tdeParityToNMParity(connection->serialConfig.parity)));
04045                 settingsMap["stopbits"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.stopBits));
04046                 settingsMap["send-delay"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt64(connection->serialConfig.txDelay));
04047             }
04048             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04049             groupValid = (settingsMap.count() > 0);
04050         }
04051         if (groupValid) outerMap.insert("serial", dbusData, TRUE); else outerMap.remove("serial");
04052 
04053         groupValid = false;
04054         dbusData = outerMap["ppp"];
04055         if (connection->pppConfig.valid) {
04056             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04057             {
04058                 settingsMap["noauth"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.requireServerAuthentication)));
04059                 settingsMap["refuse-eap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableEAP));
04060                 settingsMap["refuse-pap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisablePAP));
04061                 settingsMap["refuse-chap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableCHAP));
04062                 settingsMap["refuse-mschap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAP));
04063                 settingsMap["refuse-mschapv2"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAPv2));
04064                 settingsMap["nobsdcomp"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowBSDCompression)));
04065                 settingsMap["nodeflate"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowDeflateCompression)));
04066                 settingsMap["no-vj-comp"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowVJCompression)));
04067                 settingsMap["require-mppe"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE));
04068                 settingsMap["require-mppe-128"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE128));
04069                 settingsMap["mppe-stateful"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::StatefulMPPE));
04070                 settingsMap["crtscts"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::UseHardwareFlowControl));
04071                 settingsMap["baud"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.baudRate));
04072                 if (connection->pppConfig.mru > 0) {
04073                     settingsMap["mru"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.mru));
04074                 }
04075                 else {
04076                     settingsMap.remove("mru");
04077                 }
04078                 if (connection->pppConfig.mtu > 0) {
04079                     settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.mtu));
04080                 }
04081                 else {
04082                     settingsMap.remove("mtu");
04083                 }
04084                 if (connection->pppConfig.mtu > 0) {
04085                     settingsMap["lcp-echo-interval"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoPingInterval));
04086                 }
04087                 else {
04088                     settingsMap.remove("lcp-echo-interval");
04089                 }
04090                 if (connection->pppConfig.mtu > 0) {
04091                     settingsMap["lcp-echo-failure"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoFailureThreshold));
04092                 }
04093                 else {
04094                     settingsMap.remove("lcp-echo-failure");
04095                 }
04096             }
04097             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04098             groupValid = (settingsMap.count() > 0);
04099         }
04100         if (groupValid) outerMap.insert("ppp", dbusData, TRUE); else outerMap.remove("ppp");
04101 
04102         groupValid = false;
04103         dbusData = outerMap["pppoe"];
04104         if (connection->pppoeConfig.valid) {
04105             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04106             {
04107                 UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.networkServiceProvider, "service", settingsMap)
04108                 UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.username, "username", settingsMap)
04109                 if (connection->pppoeConfig.secretsValid) {
04110                     UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.password, "password", settingsMap)
04111                 }
04112                 settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->pppoeConfig.passwordFlags)));
04113             }
04114             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04115             groupValid = (settingsMap.count() > 0);
04116         }
04117         if (groupValid) outerMap.insert("pppoe", dbusData, TRUE); else outerMap.remove("pppoe");
04118 
04119         groupValid = false;
04120         dbusData = outerMap["802-11-olpc-mesh"];
04121         if (olpcMeshConnection) {
04122             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04123             {
04124                 {
04125                     unsigned int i;
04126                     TQT_DBusDataValueList valueList;
04127                     for (i=0; i<olpcMeshConnection->SSID.count(); i++) {
04128                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->SSID[i]);
04129                         valueList.append(innerDataValue);
04130                     }
04131                     settingsMap["ssid"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04132                 }
04133                 settingsMap["channel"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(olpcMeshConnection->channel));
04134                 {
04135                     unsigned int i;
04136                     TQT_DBusDataValueList valueList;
04137                     for (i=0; i<olpcMeshConnection->anycastDHCPHWAddress.count(); i++) {
04138                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->anycastDHCPHWAddress[i]);
04139                         valueList.append(innerDataValue);
04140                     }
04141                     settingsMap["dhcp-anycast-address"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04142                 }
04143             }
04144             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04145             groupValid = (settingsMap.count() > 0);
04146         }
04147         if (groupValid) outerMap.insert("802-11-olpc-mesh", dbusData, TRUE); else outerMap.remove("802-11-olpc-mesh");
04148 
04149         groupValid = false;
04150         dbusData = outerMap["bluetooth"];
04151         if (bluetoothConnection) {
04152             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04153             {
04154                 if (connection->lockedHWAddress.isValid()) {
04155                     TDENetworkByteList address = connection->lockedHWAddress.address();
04156                     TQT_DBusDataValueList valueList;
04157                     TDENetworkByteList::iterator it;
04158                     for (it = address.begin(); it != address.end(); ++it) {
04159                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
04160                         valueList.append(innerDataValue);
04161                     }
04162                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
04163                     settingsMap["bdaddr"] = convertDBUSDataToVariantData(nmHWAddress);
04164                 }
04165                 else {
04166                     settingsMap.remove("bdaddr");
04167                 }
04168                 UPDATE_STRING_SETTING_IF_VALID(tdeBluetoothModeToNMBluetoothMode(bluetoothConnection->type), "type", settingsMap)
04169             }
04170             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04171             groupValid = (settingsMap.count() > 0);
04172         }
04173         if (groupValid) outerMap.insert("bluetooth", dbusData, TRUE); else outerMap.remove("bluetooth");
04174 
04175         groupValid = false;
04176         dbusData = outerMap["cdma"];
04177         if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::CDMA)) {
04178             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04179             {
04180                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.providerDataNumber, "number", settingsMap)
04181                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.username, "username", settingsMap)
04182                 if (connection->pppoeConfig.secretsValid) {
04183                     UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.password, "password", settingsMap)
04184                 }
04185                 settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->cdmaConfig.passwordFlags)));
04186             }
04187             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04188             groupValid = (settingsMap.count() > 0);
04189         }
04190         if (groupValid) outerMap.insert("cdma", dbusData, TRUE); else outerMap.remove("cdma");
04191 
04192         groupValid = false;
04193         dbusData = outerMap["gsm"];
04194         if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::GSM)) {
04195             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04196             {
04197                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.providerDataNumber, "number", settingsMap)
04198                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.username, "username", settingsMap)
04199                 if (connection->pppoeConfig.secretsValid) {
04200                     UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.password, "password", settingsMap)
04201                 }
04202                 settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.passwordFlags)));
04203                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.accessPointName, "apn", settingsMap)
04204                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.networkID, "network-id", settingsMap)
04205                 settingsMap["network-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromInt32(tdeGSMModeToNMGSMMode(modemConnection->gsmConfig.networkType)));
04206                 if (connection->pppoeConfig.secretsValid) {
04207                     UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.pin, "pin", settingsMap)
04208                 }
04209                 settingsMap["pin-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.pinFlags)));
04210                 settingsMap["allowed-bands"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(modemConnection->gsmConfig.allowedFrequencyBands));
04211                 settingsMap["home-only"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(modemConnection->gsmConfig.allowRoaming)));
04212             }
04213             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04214             groupValid = (settingsMap.count() > 0);
04215         }
04216         if (groupValid) outerMap.insert("gsm", dbusData, TRUE); else outerMap.remove("gsm");
04217 
04218         groupValid = false;
04219         dbusData = outerMap["ipv4"];
04220         {
04221             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04222             {
04223                 {
04224                     TQT_DBusDataValueList valueList;
04225                     TDENetworkSingleIPConfigurationList::iterator it;
04226                     for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
04227                         if ((*it).isIPv4()) {
04228                             TQT_DBusDataValueList innerValueList;
04229                             // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04230                             // Address
04231                             innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
04232                             // Netmask
04233                             innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
04234                             // Gateway
04235                             innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
04236                             valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
04237                         }
04238                     }
04239                     if (valueList.count() <= 0) {
04240                         // Create an empty list with the correct DBUS type structure
04241                         TQT_DBusData valueList;
04242                         valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
04243                         settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
04244                     }
04245                     else {
04246                         settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04247                     }
04248                 }
04249                 {
04250                     if (!connection->ipConfig.dhcpClientIdentifier.isNull()) {
04251                         settingsMap["dhcp-client-id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->ipConfig.dhcpClientIdentifier));
04252                     }
04253                 }
04254                 {
04255                     TQT_DBusDataValueList valueList;
04256                     TDENetworkAddressList::iterator it;
04257                     for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
04258                         if ((*it).isIPv4Address()) {
04259                             valueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).toIPv4Address())));
04260                         }
04261                     }
04262                     if (valueList.count() <= 0) {
04263                         // Create an empty list with the correct DBUS type structure
04264                         settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32)));
04265                     }
04266                     else {
04267                         settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04268                     }
04269                 }
04270                 {
04271                     TQT_DBusDataValueList valueList;
04272                     TDENetworkSearchDomainList::iterator it;
04273                     for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
04274                         if ((*it).isIPv4()) {
04275                             valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
04276                         }
04277                     }
04278                     if (valueList.count() > 0) settingsMap["dns-search"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04279                 }
04280                 {
04281                     settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS)));
04282                 }
04283                 {
04284                     settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV4));
04285                 }
04286                 {
04287                     TQString method;
04288                     if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP) {
04289                         method = "auto";
04290                     }
04291                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4LocalOnly) {
04292                         method = "link-local";
04293                     }
04294                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer) {
04295                         method = "shared";
04296                     }
04297                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4Disabled) {
04298                         method = "disabled";
04299                     }
04300                     else {
04301                         method = "manual";
04302                     }
04303                     if (!method.isNull())
04304                         settingsMap["method"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method));
04305                 }
04306                 {
04307                     settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPRoutes)));
04308                 }
04309                 {
04310                     settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute)));
04311                 }
04312                 {
04313                     TQT_DBusDataValueList valueList;
04314                     TDENetworkSingleRouteConfigurationList::iterator it;
04315                     for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
04316                         if ((*it).isIPv4()) {
04317                             TQT_DBusDataValueList innerValueList;
04318                             // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04319                             // Address
04320                             innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
04321                             // Netmask
04322                             innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
04323                             // Gateway
04324                             innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
04325                             // Metric
04326                             innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
04327                             valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
04328                         }
04329                     }
04330                     if (valueList.count() <= 0) {
04331                         // Create an empty list with the correct DBUS type structure
04332                         TQT_DBusData valueList;
04333                         valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
04334                         settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
04335                     }
04336                     else {
04337                         settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04338                     }
04339                 }
04340             }
04341             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04342             groupValid = (settingsMap.count() > 0);
04343         }
04344         if (groupValid) outerMap.insert("ipv4", dbusData, TRUE); else outerMap.remove("ipv4");
04345 
04346         groupValid = false;
04347         dbusData = outerMap["ipv6"];
04348         {
04349             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04350             {
04351                 {
04352                     TQT_DBusDataValueList valueList;
04353                     TDENetworkSingleIPConfigurationList::iterator it;
04354                     for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
04355                         if ((*it).isIPv6()) {
04356                             int i;
04357                             Q_IPV6ADDR v6address;
04358                             TQT_DBusDataValueList innerValueList;
04359                             TQT_DBusDataValueList innerMostValueList;
04360                             // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04361                             // Address
04362                             innerMostValueList.clear();
04363                             v6address = (*it).ipAddress.toIPv6Address();
04364                             for (i=0; i<16; i++) {
04365                                 innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04366                             }
04367                             innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04368                             // Netmask
04369                             innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
04370                             // Gateway
04371                             innerMostValueList.clear();
04372                             v6address = (*it).gateway.toIPv6Address();
04373                             for (i=0; i<16; i++) {
04374                                 innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04375                             }
04376                             innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04377                             valueList.append(TQT_DBusData::fromStruct(innerValueList));
04378                         }
04379                     }
04380                     if (valueList.count() <= 0) {
04381                         // Create an empty list with the correct DBUS type structure
04382                         TQT_DBusDataValueList innerValueList;
04383                         TQT_DBusDataValueList innerMostValueList;
04384                         // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04385                         // Address
04386                         innerMostValueList.clear();
04387                         innerMostValueList.append(TQT_DBusData::fromByte(0));
04388                         innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04389                         // Netmask
04390                         innerValueList.append(TQT_DBusData::fromUInt32(0));
04391                         // Gateway
04392                         innerMostValueList.clear();
04393                         innerMostValueList.append(TQT_DBusData::fromByte(0));
04394                         innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04395                         settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList))));
04396                     }
04397                     else {
04398                         settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04399                     }
04400                 }
04401                 {
04402                     TQT_DBusDataValueList valueList;
04403                     TDENetworkAddressList::iterator it;
04404                     for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
04405                         if ((*it).isIPv6Address()) {
04406                             int i;
04407                             Q_IPV6ADDR v6address;
04408                             TQT_DBusDataValueList innerValueList;
04409                             v6address = (*it).toIPv6Address();
04410                             for (i=0; i<16; i++) {
04411                                 innerValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04412                             }
04413                             valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
04414                         }
04415                     }
04416                     if (valueList.count() <= 0) {
04417                         // Create an empty list with the correct DBUS type structure
04418                         TQT_DBusData valueList;
04419                         valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::Byte));
04420                         settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
04421                     }
04422                     else {
04423                         settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04424                     }
04425                 }
04426                 {
04427                     TQT_DBusDataValueList valueList;
04428                     TDENetworkSearchDomainList::iterator it;
04429                     for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
04430                         if ((*it).isIPv6()) {
04431                             valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
04432                         }
04433                     }
04434                     if (valueList.count() > 0) settingsMap["dns-search"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04435                 }
04436                 {
04437                     settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS)));
04438                 }
04439                 {
04440                     settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV6));
04441                 }
04442                 {
04443                     TQString method;
04444                     if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP) {
04445                         method = "auto";
04446                     }
04447                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6LocalOnly) {
04448                         method = "link-local";
04449                     }
04450                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer) {
04451                         method = "shared";
04452                     }
04453                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6Disabled) {
04454                         method = "ignore";
04455                     }
04456                     else {
04457                         method = "manual";
04458                     }
04459                     if (!method.isNull())
04460                         settingsMap["method"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method));
04461                 }
04462                 {
04463                     settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPRoutes)));
04464                 }
04465                 {
04466                     settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute)));
04467                 }
04468                 {
04469                     TQT_DBusDataValueList valueList;
04470                     TDENetworkSingleRouteConfigurationList::iterator it;
04471                     for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
04472                         if ((*it).isIPv6()) {
04473                             int i;
04474                             Q_IPV6ADDR v6address;
04475                             TQT_DBusDataValueList innerValueList;
04476                             TQT_DBusDataValueList innerMostValueList;
04477                             // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04478                             // Address
04479                             innerMostValueList.clear();
04480                             v6address = (*it).ipAddress.toIPv6Address();
04481                             for (i=0; i<16; i++) {
04482                                 innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04483                             }
04484                             innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04485                             // Netmask
04486                             innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
04487                             // Gateway
04488                             innerMostValueList.clear();
04489                             v6address = (*it).gateway.toIPv6Address();
04490                             for (i=0; i<16; i++) {
04491                                 innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04492                             }
04493                             innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04494                             // Metric
04495                             innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
04496                             valueList.append(TQT_DBusData::fromStruct(innerValueList));
04497                         }
04498                     }
04499                     if (valueList.count() <= 0) {
04500                         // Create an empty list with the correct DBUS type structure
04501                         TQT_DBusDataValueList innerValueList;
04502                         TQT_DBusDataValueList innerMostValueList;
04503                         // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04504                         // Address
04505                         innerMostValueList.clear();
04506                         innerMostValueList.append(TQT_DBusData::fromByte(0));
04507                         innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04508                         // Netmask
04509                         innerValueList.append(TQT_DBusData::fromUInt32(0));
04510                         // Gateway
04511                         innerMostValueList.clear();
04512                         innerMostValueList.append(TQT_DBusData::fromByte(0));
04513                         innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04514                         // Metric
04515                         innerValueList.append(TQT_DBusData::fromUInt32(0));
04516                         settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList))));
04517                     }
04518                     else {
04519                         settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04520                     }
04521                 }
04522             }
04523             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04524             groupValid = (settingsMap.count() > 0);
04525         }
04526         if (groupValid) outerMap.insert("ipv6", dbusData, TRUE); else outerMap.remove("ipv6");
04527     }
04528     connectionSettingsMap = TQT_DBusDataMap<TQString>(outerMap);
04529 
04530     // If existing==true, a connection already existed and simply needs to be updated
04531     // If existing==false, a new connection must be created
04532     // 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);'
04533     // To create new: Use 'd->m_networkManagerSettings' and call 'virtual bool AddConnectionAsync(int& asyncCallId, const TQT_DBusDataMap<TQString>& connection, TQT_DBusError& error);'
04534 
04535 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04536     printf("[network-manager comm debug] uploaded DBUS object structure map follows:\n"); fflush(stdout);
04537     printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
04538 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04539 
04540     if (existing) {
04541 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04542         printf("[network-manager comm debug] Updating existing connection\n"); fflush(stdout);
04543 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04544         // Save connection settings to the path specified
04545         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
04546         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
04547         connect(&connectionSettings, SIGNAL(UpdateAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
04548         int asyncCallID;
04549         ret = connectionSettings.UpdateAsync(asyncCallID, connectionSettingsMap, error);
04550         if (ret && error.isValid()) {
04551             ret = 0;
04552             PRINT_ERROR((error.name() + ": " + error.message()))
04553         }
04554         if (ret) {
04555             // Wait for the asynchronous call to return...
04556             d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
04557             TQTimer nmCallTimeoutTimer;
04558             nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
04559             while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
04560                 tqApp->processEvents();
04561                 if (!nmCallTimeoutTimer.isActive()) {
04562                     PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
04563                     timed_out = true;
04564                     break;
04565                 }
04566             }
04567             d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
04568             return !timed_out;
04569         }
04570         else {
04571             // Error!
04572             PRINT_ERROR((error.name() + ": " + error.message()))
04573             return FALSE;
04574         }
04575     }
04576     else {
04577 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04578         printf("[network-manager comm debug] Creating new connection\n"); fflush(stdout);
04579 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04580         // Create new connection
04581         connect(d->m_networkManagerSettings, SIGNAL(AddConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
04582         connect(d->m_networkManagerSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
04583         int asyncCallID;
04584         ret = d->m_networkManagerSettings->AddConnectionAsync(asyncCallID, connectionSettingsMap, error);
04585         if (ret && error.isValid()) {
04586             ret = 0;
04587             PRINT_ERROR((error.name() + ": " + error.message()))
04588         }
04589         if (ret) {
04590             // Wait for the asynchronous call to return...
04591             d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
04592             TQTimer nmCallTimeoutTimer;
04593             nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
04594             while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
04595                 if (!nmCallTimeoutTimer.isActive()) {
04596                     PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
04597                     timed_out = true;
04598                     break;
04599                 }
04600                 tqApp->processEvents();
04601             }
04602             if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
04603                 PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
04604                 d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
04605             }
04606             if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
04607                 PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
04608                 command_failed = true;
04609             }
04610             d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
04611             if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
04612                 d->nmAddConnectionAsyncResponse.remove(asyncCallID);
04613             }
04614             return ((!timed_out) && (!command_failed));
04615         }
04616         else {
04617             // Error!
04618             PRINT_ERROR((error.name() + ": " + error.message()))
04619             return FALSE;
04620         }
04621     }
04622 }
04623 
04624 bool TDENetworkConnectionManager_BackendNM::deleteConnection(TQString uuid) {
04625     TQT_DBusObjectPath existingConnection;
04626     TQT_DBusError error;
04627     bool timed_out = false;
04628     bool ret;
04629     if (d->m_networkManagerSettings) {
04630         ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
04631         if (ret) {
04632             // Obtain connection secrets from the path specified
04633             DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
04634             connectionSettings.setConnection(TQT_DBusConnection::systemBus());
04635             connect(&connectionSettings, SIGNAL(DeleteAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
04636             int asyncCallID;
04637             ret = connectionSettings.DeleteAsync(asyncCallID, error);
04638             if (ret && error.isValid()) {
04639                 ret = 0;
04640                 PRINT_ERROR((error.name() + ": " + error.message()))
04641             }
04642             if (ret) {
04643                 // Wait for the asynchronous call to return...
04644                 d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
04645                 TQTimer nmCallTimeoutTimer;
04646                 nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
04647                 while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
04648                     tqApp->processEvents();
04649                     if (!nmCallTimeoutTimer.isActive()) {
04650                         PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
04651                         timed_out = true;
04652                         break;
04653                     }
04654                 }
04655                 d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
04656                 return !timed_out;
04657             }
04658             else {
04659                 PRINT_ERROR(TQString("Unable to remove connection with uuid '%1'").arg(uuid))
04660                 return FALSE;
04661             }
04662         }
04663         else {
04664             PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
04665             return FALSE;
04666         }
04667     }
04668     else {
04669         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04670         return FALSE;
04671     }
04672 }
04673 
04674 bool TDENetworkConnectionManager_BackendNM::verifyConnectionSettings(TDENetworkConnection* connection, TDENetworkConnectionErrorFlags::TDENetworkConnectionErrorFlags* type, TDENetworkErrorStringMap* reason) {
04675     // FIXME
04676     // This should actually attempt to validate all the settings!
04677 
04678     if (!connection) {
04679         return false;
04680     }
04681 
04682     if (connection->friendlyName == "") {
04683         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidConnectionSetting] = i18n("Connection name is invalid");
04684         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidConnectionSetting;
04685         return false;
04686     }
04687 
04688     if (connection->ipConfig.valid) {
04689         // Iterate over all addresses
04690         TDENetworkSingleIPConfigurationList::iterator it;
04691         for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
04692             if ((*it).isIPv4()) {
04693                 if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP)) {
04694                     if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
04695                         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv4Setting] = i18n("IPv4 address is invalid");
04696                         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv4Setting;
04697                         return false;
04698                     }
04699                 }
04700             }
04701             else if ((*it).isIPv6()) {
04702                 if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP)) {
04703                     if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
04704                         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv6Setting] = i18n("IPv6 address is invalid");
04705                         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv6Setting;
04706                         return false;
04707                     }
04708                 }
04709             }
04710         }
04711     }
04712 
04713     TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
04714     if (wiFiConnection) {
04715         if (wiFiConnection->SSID.count() < 1) {
04716             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessSetting] = i18n("No SSID provided");
04717             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessSetting;
04718             return false;
04719         }
04720         if (wiFiConnection->securityRequired) {
04721             if (wiFiConnection->securitySettings.secretsValid) {
04722                 if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WEP) || ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && ((wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Open) || (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Shared)))) {
04723                     if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Hexadecimal) {
04724                         if (wiFiConnection->securitySettings.wepKey0 != "") {
04725                             if ((wiFiConnection->securitySettings.wepKey0.length() != 10) && (wiFiConnection->securitySettings.wepKey0.length() != 26)) {
04726                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
04727                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04728                                 return false;
04729                             }
04730                         }
04731                         if (wiFiConnection->securitySettings.wepKey1 != "") {
04732                             if ((wiFiConnection->securitySettings.wepKey1.length() != 10) && (wiFiConnection->securitySettings.wepKey1.length() != 26)) {
04733                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
04734                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04735                                 return false;
04736                             }
04737                         }
04738                         if (wiFiConnection->securitySettings.wepKey2 != "") {
04739                             if ((wiFiConnection->securitySettings.wepKey2.length() != 10) && (wiFiConnection->securitySettings.wepKey2.length() != 26)) {
04740                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
04741                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04742                                 return false;
04743                             }
04744                         }
04745                         if (wiFiConnection->securitySettings.wepKey3 != "") {
04746                             if ((wiFiConnection->securitySettings.wepKey3.length() != 10) && (wiFiConnection->securitySettings.wepKey3.length() != 26)) {
04747                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
04748                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04749                                 return false;
04750                             }
04751                         }
04752                         if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
04753                             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
04754                             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04755                             return false;
04756                         }
04757                     }
04758                     else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
04759                         if (wiFiConnection->securitySettings.wepKey0 != "") {
04760                             if ((wiFiConnection->securitySettings.wepKey0.length() != 5) && (wiFiConnection->securitySettings.wepKey0.length() != 13)) {
04761                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
04762                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04763                                 return false;
04764                             }
04765                         }
04766                         if (wiFiConnection->securitySettings.wepKey1 != "") {
04767                             if ((wiFiConnection->securitySettings.wepKey1.length() != 5) && (wiFiConnection->securitySettings.wepKey1.length() != 13)) {
04768                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
04769                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04770                                 return false;
04771                             }
04772                         }
04773                         if (wiFiConnection->securitySettings.wepKey2 != "") {
04774                             if ((wiFiConnection->securitySettings.wepKey2.length() != 5) && (wiFiConnection->securitySettings.wepKey2.length() != 13)) {
04775                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
04776                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04777                                 return false;
04778                             }
04779                         }
04780                         if (wiFiConnection->securitySettings.wepKey3 != "") {
04781                             if ((wiFiConnection->securitySettings.wepKey3.length() != 5) && (wiFiConnection->securitySettings.wepKey3.length() != 13)) {
04782                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
04783                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04784                                 return false;
04785                             }
04786                         }
04787                         if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
04788                             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
04789                             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04790                             return false;
04791                         }
04792                     }
04793                     else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
04794                         if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
04795                             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
04796                             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04797                             return false;
04798                         }
04799                     }
04800                 }
04801                 else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::LEAP)) {
04802                     if ((wiFiConnection->securitySettings.leapUsername.length() < 1) || (wiFiConnection->securitySettings.leapPassword.length() < 1)) {
04803                         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("LEAP username and/or password not provided");
04804                         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04805                         return false;
04806                     }
04807                 }
04808                 else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAAdHoc) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAInfrastructure) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAEnterprise)) {
04809                     if (wiFiConnection->securitySettings.psk.length() == 64) {
04810                         // Verify that only hex characters are present in the string
04811                         bool ok;
04812                         wiFiConnection->securitySettings.psk.toULongLong(&ok, 16);
04813                         if (!ok) {
04814                             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("Hexadecimal length PSK contains non-hexadecimal characters");
04815                             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04816                             return false;
04817                         }
04818                     }
04819                     else if ((wiFiConnection->securitySettings.psk.length() < 8) || (wiFiConnection->securitySettings.psk.length() > 63)) {
04820                         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No PSK provided");
04821                         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04822                         return false;
04823                     }
04824                 }
04825             }
04826         }
04827     }
04828 
04829     return TRUE;
04830 }
04831 
04832 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::initiateConnection(TQString uuid) {
04833     TQT_DBusObjectPath existingConnection;
04834     TQT_DBusError error;
04835     bool ret;
04836     if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
04837         ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
04838         if (ret) {
04839             if (!m_networkDevice) {
04840                 d->m_dbusDeviceString = "/";
04841             }
04842             else {
04843                 d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
04844             }
04845             if (d->m_dbusDeviceString.isEmpty()) {
04846                 PRINT_ERROR(TQString("Invalid empty DBUS device string"))
04847                 return TDENetworkConnectionStatus::Invalid;
04848             }
04849 #ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
04850             TQT_DBusObjectPath active_connection;
04851             ret = d->m_networkManagerProxy->ActivateConnection(existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), active_connection, error);
04852             if (ret && error.isValid()) {
04853                 ret = 0;
04854                 PRINT_ERROR((error.name() + ": " + error.message()))
04855             }
04856             return checkConnectionStatus(uuid);
04857 #else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
04858 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
04859             connect(d->m_networkManagerProxy, SIGNAL(ActivateConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
04860             connect(d->m_networkManagerProxy, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
04861 #endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
04862             int asyncCallID;
04863             ret = d->m_networkManagerProxy->ActivateConnectionAsync(asyncCallID, existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), error);
04864             if (ret && error.isValid()) {
04865                 ret = 0;
04866                 PRINT_ERROR((error.name() + ": " + error.message()))
04867             }
04868 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
04869             if (ret) {
04870                 // Wait for the asynchronous call to return...
04871                 d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
04872                 TQTimer nmCallTimeoutTimer;
04873                 nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
04874                 while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
04875                     if (!nmCallTimeoutTimer.isActive()) {
04876                         PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
04877                         break;
04878                     }
04879                     tqApp->processEvents();
04880                 }
04881                 d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
04882                 if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
04883                     PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
04884                     d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
04885                 }
04886                 if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
04887                     PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
04888                 }
04889                 if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
04890                     d->nmAddConnectionAsyncResponse.remove(asyncCallID);
04891                 }
04892                 return checkConnectionStatus(uuid);
04893             }
04894             else {
04895                 // Error!
04896                 PRINT_ERROR((error.name() + ": " + error.message()))
04897                 return checkConnectionStatus(uuid);
04898             }
04899 #else
04900             return checkConnectionStatus(uuid);
04901 #endif
04902 #endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
04903         }
04904         else {
04905             PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
04906             return TDENetworkConnectionStatus::Invalid;
04907         }
04908     }
04909     else {
04910         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04911         return TDENetworkConnectionStatus::Invalid;
04912     }
04913 }
04914 
04915 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::checkConnectionStatus(TQString uuid) {
04916     TQT_DBusObjectPath existingConnection;
04917     TQT_DBusError error;
04918     if (d->m_networkManagerProxy) {
04919         TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
04920         TQT_DBusObjectPathList::iterator it;
04921         for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
04922             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
04923             activeConnection.setConnection(TQT_DBusConnection::systemBus());
04924             if (activeConnection.getUuid(error) == uuid) {
04925                 return nmDeviceStateToTDEDeviceState(activeConnection.getState(error));
04926             }
04927         }
04928         PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
04929         return TDENetworkConnectionStatus::Invalid;
04930     }
04931     else {
04932         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04933         return TDENetworkConnectionStatus::Invalid;
04934     }
04935 }
04936 
04937 TQCString TDENetworkConnectionManager_BackendNM::getActiveConnectionPath(TQString uuid) {
04938     TQT_DBusObjectPath existingConnection;
04939     TQT_DBusError error;
04940     if (d->m_networkManagerProxy) {
04941         TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
04942         TQT_DBusObjectPathList::iterator it;
04943         for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
04944             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
04945             activeConnection.setConnection(TQT_DBusConnection::systemBus());
04946             if (activeConnection.getUuid(error) == uuid) {
04947                 return (*it);
04948             }
04949         }
04950         PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
04951         return TQT_DBusObjectPath();
04952     }
04953     else {
04954         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04955         return TQT_DBusObjectPath();
04956     }
04957 }
04958 
04959 TQStringList TDENetworkConnectionManager_BackendNM::connectionPhysicalDeviceUUIDs(TQString uuid) {
04960     if (deviceType() == TDENetworkDeviceType::BackendOnly) {
04961         return TQStringList();
04962     }
04963 
04964     TQT_DBusObjectPath existingConnection;
04965     TQT_DBusError error;
04966     if (d->m_networkManagerProxy) {
04967         TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
04968         TQT_DBusObjectPathList::iterator it;
04969         TQStringList ret;
04970         for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
04971             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
04972             activeConnection.setConnection(TQT_DBusConnection::systemBus());
04973             if (activeConnection.getUuid(error) == uuid) {
04974                 TQValueList<TQT_DBusObjectPath> deviceList = activeConnection.getDevices(error);
04975                 TQT_DBusObjectPathList::iterator it2;
04976                 for (it2 = deviceList.begin(); it2 != deviceList.end(); ++it2) {
04977                     TQString devUUID = tdeDeviceUUIDForGenericDevice(*it2);
04978                     if (devUUID != "") {
04979                         ret.append(devUUID);
04980                     }
04981                 }
04982             }
04983         }
04984         return ret;
04985     }
04986     else {
04987         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04988         return TQStringList();
04989     }
04990 }
04991 
04992 TDENetworkVPNTypeList TDENetworkConnectionManager_BackendNM::availableVPNTypes() {
04993     TDENetworkVPNTypeList ret;
04994 
04995     // Query NetworkManager to verify plugin availability before claiming support for a VPN type
04996     TQDir serviceDir(NM_PLUGIN_SERVICE_DIR, TQString(), TQDir::Name|TQDir::IgnoreCase, TQDir::Files);
04997     TQStringList services = serviceDir.entryList ().grep (".name", true);
04998 
04999     if (services.count () > 0) {
05000         // read in all available Services
05001         for (TQStringList::Iterator i = services.begin (); i != services.end (); ++i) {
05002             TQString service = NM_PLUGIN_SERVICE_DIR + TQString ("/") + *i;
05003             TDEConfig* tdeconfig = new TDEConfig (service, true, true, "config");
05004             tdeconfig->setGroup ("VPN Connection");
05005 
05006             TQString serviceName = tdeconfig->readEntry("name", TQString());
05007             serviceName = serviceName.lower();
05008 
05009             if (serviceName == "openvpn") {
05010                 ret.append(TDENetworkVPNType::OpenVPN);
05011             }
05012             if (serviceName == "pptp") {
05013                 ret.append(TDENetworkVPNType::PPTP);
05014             }
05015             if (serviceName == "strongswan") {
05016                 ret.append(TDENetworkVPNType::StrongSwan);
05017             }
05018             if (serviceName == "vpnc") {
05019                 ret.append(TDENetworkVPNType::VPNC);
05020             }
05021 
05022             delete tdeconfig;
05023         }
05024     }
05025 
05026     return ret;
05027 }
05028 
05029 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::deactivateConnection(TQString uuid) {
05030     TQT_DBusObjectPath existingConnection;
05031     TQT_DBusError error;
05032     bool ret;
05033     if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
05034         existingConnection = getActiveConnectionPath(uuid);
05035         if (existingConnection.isValid()) {
05036             if (!m_networkDevice) {
05037                 d->m_dbusDeviceString = "/";
05038             }
05039             else {
05040                 d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
05041             }
05042             if (d->m_dbusDeviceString.isEmpty()) {
05043                 PRINT_ERROR(TQString("Invalid empty DBUS device string"))
05044                 return TDENetworkConnectionStatus::Invalid;
05045             }
05046 #ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
05047             ret = d->m_networkManagerProxy->DeactivateConnection(existingConnection, error);
05048             if (ret && error.isValid()) {
05049                 ret = 0;
05050                 PRINT_ERROR((error.name() + ": " + error.message()))
05051             }
05052             return checkConnectionStatus(uuid);
05053 #else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
05054 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
05055             connect(d->m_networkManagerProxy, SIGNAL(DeactivateConnectionAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
05056 #endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
05057             int asyncCallID;
05058             ret = d->m_networkManagerProxy->DeactivateConnectionAsync(asyncCallID, existingConnection, error);
05059             if (ret && error.isValid()) {
05060                 ret = 0;
05061                 PRINT_ERROR((error.name() + ": " + error.message()))
05062             }
05063 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
05064             if (ret) {
05065                 // Wait for the asynchronous call to return...
05066                 d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
05067                 TQTimer nmCallTimeoutTimer;
05068                 nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
05069                 while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
05070                     if (!nmCallTimeoutTimer.isActive()) {
05071                         PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
05072                         break;
05073                     }
05074                     tqApp->processEvents();
05075                 }
05076                 d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
05077                 return checkConnectionStatus(uuid);
05078             }
05079             else {
05080                 // Error!
05081                 PRINT_ERROR((error.name() + ": " + error.message()))
05082                 return checkConnectionStatus(uuid);
05083             }
05084 #else
05085             return checkConnectionStatus(uuid);
05086 #endif
05087 #endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
05088         }
05089         else {
05090             PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
05091             return TDENetworkConnectionStatus::Invalid;
05092         }
05093     }
05094     else {
05095         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
05096         return TDENetworkConnectionStatus::Invalid;
05097     }
05098 }
05099 
05100 TQStringList TDENetworkConnectionManager_BackendNM::validSettings() {
05101     TQStringList ret;
05102 
05103     ret.append("TDENetworkSingleIPConfiguration::ipAddress");
05104     ret.append("TDENetworkSingleIPConfiguration::networkMask");
05105     ret.append("TDENetworkSingleIPConfiguration::gateway");
05106 
05107     ret.append("TDENetworkSingleRouteConfiguration::ipAddress");
05108     ret.append("TDENetworkSingleRouteConfiguration::networkMask");
05109     ret.append("TDENetworkSingleRouteConfiguration::gateway");
05110 
05111     ret.append("TDENetworkIEEE8021xConfiguration::valid");
05112     ret.append("TDENetworkIEEE8021xConfiguration::allowedValid");
05113     ret.append("TDENetworkIEEE8021xConfiguration::secretsValid");
05114     ret.append("TDENetworkIEEE8021xConfiguration::type");
05115     ret.append("TDENetworkIEEE8021xConfiguration::userName");
05116     ret.append("TDENetworkIEEE8021xConfiguration::anonymousUserName");
05117     ret.append("TDENetworkIEEE8021xConfiguration::pacFileName");
05118     ret.append("TDENetworkIEEE8021xConfiguration::caCertificate");
05119     ret.append("TDENetworkIEEE8021xConfiguration::additionalCAFilesPath");
05120     ret.append("TDENetworkIEEE8021xConfiguration::authServerCertSubjectMatch");
05121     ret.append("TDENetworkIEEE8021xConfiguration::alternateAuthServerCertSubjectMatch");
05122     ret.append("TDENetworkIEEE8021xConfiguration::clientCertificate");
05123     ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPVersion");
05124     ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPLabel");
05125     ret.append("TDENetworkIEEE8021xConfiguration::fastProvisioningFlags");
05126     ret.append("TDENetworkIEEE8021xConfiguration::phase2NonEAPAuthMethod");
05127     ret.append("TDENetworkIEEE8021xConfiguration::phase2EAPAuthMethod");
05128     ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2NonEAPMethods");
05129     ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2EAPMethods");
05130     ret.append("TDENetworkIEEE8021xConfiguration::phase2CaCertificate");
05131     ret.append("TDENetworkIEEE8021xConfiguration::phase2CaFilesPath");
05132     ret.append("TDENetworkIEEE8021xConfiguration::phase2AuthServerCertSubjectMatch");
05133     ret.append("TDENetworkIEEE8021xConfiguration::phase2AlternateAuthServerCertSubjectMatch");
05134     ret.append("TDENetworkIEEE8021xConfiguration::phase2ClientCertificate");
05135     ret.append("TDENetworkIEEE8021xConfiguration::password");
05136     ret.append("TDENetworkIEEE8021xConfiguration::passwordFlags");
05137     ret.append("TDENetworkIEEE8021xConfiguration::binaryPassword");
05138     ret.append("TDENetworkIEEE8021xConfiguration::binaryPasswordFlags");
05139     ret.append("TDENetworkIEEE8021xConfiguration::privateKey");
05140     ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPassword");
05141     ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPasswordFlags");
05142     ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKey");
05143     ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPassword");
05144     ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPasswordFlags");
05145     ret.append("TDENetworkIEEE8021xConfiguration::forceSystemCaCertificates");
05146 
05147     ret.append("TDENetworkPPPConfiguration::valid");
05148     ret.append("TDENetworkPPPConfiguration::requireServerAuthentication");
05149     ret.append("TDENetworkPPPConfiguration::flags");
05150     ret.append("TDENetworkPPPConfiguration::baudRate");
05151     ret.append("TDENetworkPPPConfiguration::mru");
05152     ret.append("TDENetworkPPPConfiguration::mtu");
05153     ret.append("TDENetworkPPPConfiguration::lcpEchoPingInterval");
05154     ret.append("TDENetworkPPPConfiguration::lcpEchoFailureThreshold");
05155 
05156     ret.append("TDENetworkPPPOEConfiguration::valid");
05157     ret.append("TDENetworkPPPOEConfiguration::secretsValid");
05158     ret.append("TDENetworkPPPOEConfiguration::networkServiceProvider");
05159     ret.append("TDENetworkPPPOEConfiguration::username");
05160     ret.append("TDENetworkPPPOEConfiguration::password");
05161     ret.append("TDENetworkPPPOEConfiguration::passwordFlags");
05162 
05163     ret.append("TDENetworkSerialConfiguration::valid");
05164     ret.append("TDENetworkSerialConfiguration::baudRate");
05165     ret.append("TDENetworkSerialConfiguration::byteWidth");
05166     ret.append("TDENetworkSerialConfiguration::parity");
05167     ret.append("TDENetworkSerialConfiguration::stopBits");
05168     ret.append("TDENetworkSerialConfiguration::txDelay");
05169 
05170     ret.append("TDENetworkCDMAConfiguration::valid");
05171     ret.append("TDENetworkCDMAConfiguration::secretsValid");
05172     ret.append("TDENetworkCDMAConfiguration::providerDataNumber");
05173     ret.append("TDENetworkCDMAConfiguration::username");
05174     ret.append("TDENetworkCDMAConfiguration::password");
05175     ret.append("TDENetworkCDMAConfiguration::passwordFlags");
05176 
05177     ret.append("TDENetworkGSMConfiguration::valid");
05178     ret.append("TDENetworkGSMConfiguration::secretsValid");
05179     ret.append("TDENetworkGSMConfiguration::providerDataNumber");
05180     ret.append("TDENetworkGSMConfiguration::username");
05181     ret.append("TDENetworkGSMConfiguration::password");
05182     ret.append("TDENetworkGSMConfiguration::passwordFlags");
05183     ret.append("TDENetworkGSMConfiguration::accessPointName");
05184     ret.append("TDENetworkGSMConfiguration::networkID");
05185     ret.append("TDENetworkGSMConfiguration::networkType");
05186     ret.append("TDENetworkGSMConfiguration::pin");
05187     ret.append("TDENetworkGSMConfiguration::pinFlags");
05188     ret.append("TDENetworkGSMConfiguration::allowedFrequencyBands");
05189     ret.append("TDENetworkGSMConfiguration::allowRoaming");
05190 
05191     ret.append("TDENetworkWiFiSecurityConfiguration::valid");
05192     ret.append("TDENetworkWiFiSecurityConfiguration::secretsValid");
05193     ret.append("TDENetworkWiFiSecurityConfiguration::keyType");
05194     ret.append("TDENetworkWiFiSecurityConfiguration::authType");
05195     ret.append("TDENetworkWiFiSecurityConfiguration::wpaVersion");
05196     ret.append("TDENetworkWiFiSecurityConfiguration::cipher");
05197     ret.append("TDENetworkWiFiSecurityConfiguration::wepKey0");
05198     ret.append("TDENetworkWiFiSecurityConfiguration::wepKey1");
05199     ret.append("TDENetworkWiFiSecurityConfiguration::wepKey2");
05200     ret.append("TDENetworkWiFiSecurityConfiguration::wepKey3");
05201     ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyFlags");
05202     ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyIndex");
05203     ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyType");
05204     ret.append("TDENetworkWiFiSecurityConfiguration::allowedPairWiseCiphers");
05205     ret.append("TDENetworkWiFiSecurityConfiguration::allowedGroupWiseCiphers");
05206     ret.append("TDENetworkWiFiSecurityConfiguration::psk");
05207     ret.append("TDENetworkWiFiSecurityConfiguration::pskFlags");
05208     ret.append("TDENetworkWiFiSecurityConfiguration::leapUsername");
05209     ret.append("TDENetworkWiFiSecurityConfiguration::leapPassword");
05210     ret.append("TDENetworkWiFiSecurityConfiguration::leapPasswordFlags");
05211 
05212     ret.append("TDENetworkIPConfiguration::valid");
05213     ret.append("TDENetworkIPConfiguration::connectionFlags");
05214     ret.append("TDENetworkIPConfiguration::ipConfigurations");
05215     ret.append("TDENetworkIPConfiguration::routeConfigurations");
05216     ret.append("TDENetworkIPConfiguration::broadcast");
05217     ret.append("TDENetworkIPConfiguration::destination");
05218     ret.append("TDENetworkIPConfiguration::resolvers");
05219     ret.append("TDENetworkIPConfiguration::searchDomains");
05220     ret.append("TDENetworkIPConfiguration::dhcpClientIdentifier");
05221 
05222     ret.append("TDENetworkConnection::UUID");
05223     ret.append("TDENetworkConnection::friendlyName");
05224     ret.append("TDENetworkConnection::ipConfig");
05225     ret.append("TDENetworkConnection::lockedHWAddress");
05226     ret.append("TDENetworkConnection::manualHWAddress");
05227     ret.append("TDENetworkConnection::readOnly");
05228     ret.append("TDENetworkConnection::autoConnect");
05229     ret.append("TDENetworkConnection::fullDuplex");
05230     ret.append("TDENetworkConnection::requireIPV4");
05231     ret.append("TDENetworkConnection::requireIPV6");
05232     ret.append("TDENetworkConnection::mtu");
05233     ret.append("TDENetworkConnection::eapConfig");
05234     ret.append("TDENetworkConnection::pppConfig");
05235     ret.append("TDENetworkConnection::pppoeConfig");
05236     ret.append("TDENetworkConnection::serialConfig");
05237     ret.append("TDENetworkConnection::authorizedUsers");
05238     ret.append("TDENetworkConnection::masterConnectionUUID");
05239     ret.append("TDENetworkConnection::slaveType");
05240     ret.append("TDENetworkConnection::lastKnownConnection");
05241 
05242     ret.append("TDEWiFiConnection::SSID");
05243     ret.append("TDEWiFiConnection::operatingMode");
05244     ret.append("TDEWiFiConnection::bandRestriction");
05245     ret.append("TDEWiFiConnection::channelRestriction");
05246     ret.append("TDEWiFiConnection::bitRateRestriction");
05247     ret.append("TDEWiFiConnection::powerRestriction");
05248     ret.append("TDEWiFiConnection::accessPointRestriction");
05249     ret.append("TDEWiFiConnection::blacklistedBSSIDs");
05250     ret.append("TDEWiFiConnection::heardBSSIDs");
05251     ret.append("TDEWiFiConnection::isHiddenNetwork");
05252     ret.append("TDEWiFiConnection::securityRequired");
05253     ret.append("TDEWiFiConnection::securitySettings");
05254 
05255     ret.append("TDEWiredInfinibandConnection::transportMode");
05256 
05257     ret.append("TDEVPNConnection::vpnPluginID");
05258     ret.append("TDEVPNConnection::lockedUserName");
05259     ret.append("TDEVPNConnection::pluginData");
05260     ret.append("TDEVPNConnection::secretsValid");
05261     ret.append("TDEVPNConnection::pluginSecrets");
05262 
05263     ret.append("TDEWiMaxConnection::networkServiceProvider");
05264 
05265     ret.append("TDEVLANConnection::kernelName");
05266     ret.append("TDEVLANConnection::parentConnectionUUID");
05267     ret.append("TDEVLANConnection::vlanID");
05268     ret.append("TDEVLANConnection::vlanFlags");
05269     ret.append("TDEVLANConnection::ingressPriorityMap");
05270     ret.append("TDEVLANConnection::egressPriorityMap");
05271 
05272     ret.append("TDEOLPCMeshConnection::SSID");
05273     ret.append("TDEOLPCMeshConnection::channel");
05274     ret.append("TDEOLPCMeshConnection::anycastDHCPHWAddress");
05275 
05276     ret.append("TDEBluetoothConnection::type");
05277 
05278     ret.append("TDEModemConnection::type");
05279     ret.append("TDEModemConnection::cdmaConfig");
05280     ret.append("TDEModemConnection::gsmConfig");
05281 
05282     ret.append("TDEWiredInfinibandConnection::transportMode");
05283 
05284     return ret;
05285 }
05286 
05287 TDENetworkWiFiAPInfo* TDENetworkConnectionManager_BackendNM::getAccessPointDetails(TQString dbusPath) {
05288     if (dbusPath == "") {
05289         return NULL;
05290     }
05291 
05292     TDENetworkWiFiAPInfo* apInfo = new TDENetworkWiFiAPInfo;
05293     TQT_DBusError error;
05294     unsigned int index;
05295     DBus::AccessPointProxy accessPoint(NM_DBUS_SERVICE, dbusPath);
05296     accessPoint.setConnection(TQT_DBusConnection::systemBus());
05297 
05298     TQValueList<TQ_UINT8> nmSSID = accessPoint.getSsid(error);
05299     if (error.isValid()) {
05300         delete apInfo;
05301         return NULL;
05302     }
05303     TQValueList<TQ_UINT8>::iterator it;
05304     index = 0;
05305     for (it = nmSSID.begin(); it != nmSSID.end(); ++it) {
05306         apInfo->SSID.resize(index+1);
05307         apInfo->SSID[index] = (*it);
05308         index++;
05309     }
05310 
05311     apInfo->wpaFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getWpaFlags(error));
05312     apInfo->rsnFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getRsnFlags(error));
05313     apInfo->frequency = accessPoint.getFrequency(error);
05314     apInfo->BSSID.fromString(accessPoint.getHwAddress(error));
05315     apInfo->maxBitrate = accessPoint.getMaxBitrate(error);
05316     apInfo->signalQuality = (accessPoint.getStrength(error)/100.0);
05317 
05318     apInfo->valid = true;
05319 
05320     return apInfo;
05321 }
05322 
05323 TDENetworkHWNeighborList* TDENetworkConnectionManager_BackendNM::siteSurvey() {
05324     TQT_DBusError error;
05325     bool ret;
05326 
05327     TDENetworkDeviceType::TDENetworkDeviceType myDeviceType = deviceType();
05328     d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
05329     clearTDENetworkHWNeighborList();
05330 
05331     if (myDeviceType == TDENetworkDeviceType::WiFi) {
05332         if (!d->m_dbusDeviceString.isEmpty()) {
05333             DBus::WiFiDeviceProxy wiFiDevice(NM_DBUS_SERVICE, d->m_dbusDeviceString);
05334             wiFiDevice.setConnection(TQT_DBusConnection::systemBus());
05335             // FIXME
05336             // Should call wiFiDevice.RequestScanAsync first to rescan all access points
05337             TQT_DBusObjectPathList accessPoints;
05338             ret = wiFiDevice.GetAccessPoints(accessPoints, error);
05339             if (ret) {
05340                 TQT_DBusObjectPathList::iterator it;
05341                 for (it = accessPoints.begin(); it != accessPoints.end(); ++it) {
05342                     TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(TQString(*it));
05343                     if (apInfo) {
05344                         m_hwNeighborList->append(apInfo);
05345                         // Ensure that this AP is monitored for changes
05346                         d->internalProcessWiFiAccessPointAdded(*it);
05347                     }
05348                 }
05349             }
05350         }
05351     }
05352 
05353     return m_hwNeighborList;
05354 }
05355 
05356 bool TDENetworkConnectionManager_BackendNM::networkingEnabled() {
05357     if (d->m_networkManagerProxy) {
05358         bool ret;
05359         TQT_DBusError error;
05360         ret = d->m_networkManagerProxy->getNetworkingEnabled(error);
05361         if (error.isValid()) {
05362             // Error!
05363             PRINT_ERROR((error.name() + ": " + error.message()))
05364             return FALSE;
05365         }
05366         else {
05367             return ret;
05368         }
05369     }
05370     else {
05371         return FALSE;
05372     }
05373 }
05374 
05375 bool TDENetworkConnectionManager_BackendNM::wiFiHardwareEnabled() {
05376     if (d->m_networkManagerProxy) {
05377         bool ret;
05378         TQT_DBusError error;
05379         ret = d->m_networkManagerProxy->getWirelessHardwareEnabled(error);
05380         if (error.isValid()) {
05381             // Error!
05382             PRINT_ERROR((error.name() + ": " + error.message()))
05383             return FALSE;
05384         }
05385         else {
05386             return ret;
05387         }
05388     }
05389     else {
05390         return FALSE;
05391     }
05392 }
05393 
05394 bool TDENetworkConnectionManager_BackendNM::enableNetworking(bool enable) {
05395     // FIXME
05396     // Yes, this abuses the Sleep command
05397     // Is there a better way to do it?
05398     if (d->m_networkManagerProxy) {
05399         int asynccallid;
05400         TQT_DBusError error;
05401         d->m_networkManagerProxy->SleepAsync(asynccallid, !enable, error);
05402         if (error.isValid()) {
05403             // Error!
05404             PRINT_ERROR((error.name() + ": " + error.message()))
05405             return FALSE;
05406         }
05407         else {
05408             // FIXME
05409             // Wait for async reply before returning...
05410             return TRUE;
05411         }
05412     }
05413     else {
05414         return FALSE;
05415     }
05416 }
05417 
05418 bool TDENetworkConnectionManager_BackendNM::enableWiFi(bool enable) {
05419     if (d->m_networkManagerProxy) {
05420         TQT_DBusError error;
05421         d->m_networkManagerProxy->setWirelessEnabled(enable, error);
05422         if (error.isValid()) {
05423             // Error!
05424             PRINT_ERROR((error.name() + ": " + error.message()))
05425             return FALSE;
05426         }
05427         else {
05428             return TRUE;
05429         }
05430     }
05431     else {
05432         return FALSE;
05433     }
05434 }
05435 
05436 bool TDENetworkConnectionManager_BackendNM::wiFiEnabled() {
05437     if (d->m_networkManagerProxy) {
05438         bool ret;
05439         TQT_DBusError error;
05440         ret = d->m_networkManagerProxy->getWirelessEnabled(error);
05441         if (error.isValid()) {
05442             // Error!
05443             PRINT_ERROR((error.name() + ": " + error.message()))
05444             return FALSE;
05445         }
05446         else {
05447             return ret;
05448         }
05449     }
05450     else {
05451         return FALSE;
05452     }
05453 }
05454 
05455 TQStringList TDENetworkConnectionManager_BackendNM::defaultNetworkDevices() {
05456     // Cycle through all available connections and see which one is default, then find all devices for that connection...
05457     TQStringList ret;
05458 
05459     TQT_DBusObjectPath existingConnection;
05460     TQT_DBusError error;
05461     if (d->m_networkManagerProxy) {
05462         TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
05463         TQT_DBusObjectPathList::iterator it;
05464         for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
05465             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
05466             activeConnection.setConnection(TQT_DBusConnection::systemBus());
05467             if (activeConnection.getDefault(error)) {
05468                 // This is the default ipv4 connection
05469                 TQString uuid = activeConnection.getUuid(error);
05470                 TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
05471                 for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
05472                     ret.append(*it);
05473                 }
05474             }
05475             else if (activeConnection.getDefault6(error)) {
05476                 // This is the default ipv6 connection
05477                 TQString uuid = activeConnection.getUuid(error);
05478                 TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
05479                 for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
05480                     ret.append(*it);
05481                 }
05482             }
05483         }
05484         return ret;
05485     }
05486     else {
05487         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
05488         return TQStringList();
05489     }
05490 }
05491 
05492 TDENetworkConnectionManager_BackendNMPrivate::TDENetworkConnectionManager_BackendNMPrivate(TDENetworkConnectionManager_BackendNM* parent) : m_networkManagerProxy(NULL), m_networkManagerSettings(NULL), m_networkDeviceProxy(NULL), m_wiFiDeviceProxy(NULL), m_vpnProxy(NULL), nonReentrantCallActive(false), vpn_service_error_notified(false), device_autoconnect_error_notified(false), m_parent(parent), m_prevDeviceState(-1) {
05493     // Set up global signal handler
05494     m_dbusSignalConnection = new TQT_DBusConnection(TQT_DBusConnection::systemBus());
05495     m_dbusSignalReceiver = new TDENetworkConnectionManager_BackendNM_DBusSignalReceiver(this);
05496     m_dbusSignalConnection->connect(m_dbusSignalReceiver, TQT_SLOT(dbusSignal(const TQT_DBusMessage&)));
05497 }
05498 
05499 TDENetworkConnectionManager_BackendNMPrivate::~TDENetworkConnectionManager_BackendNMPrivate() {
05500     // Destroy global signal handler
05501     if (m_dbusSignalConnection) delete m_dbusSignalConnection;
05502     if (m_dbusSignalReceiver) delete m_dbusSignalReceiver;
05503 
05504     // Destroy proxy objects
05505     TQMap<TQString, DBus::AccessPointProxy*>::iterator it;
05506     for (it = m_accessPointProxyList.begin(); it != m_accessPointProxyList.end(); ++it) {
05507         DBus::AccessPointProxy *apProxy = it.data();
05508         if (apProxy) {
05509             delete apProxy;
05510         }
05511     }
05512     m_accessPointProxyList.clear();
05513 }
05514 
05515 #include "network-manager.moc"
05516 #include "network-manager_p.moc"

tdecore

Skip menu "tdecore"
  • Main Page
  • Modules
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

tdecore

Skip menu "tdecore"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdecore by doxygen 1.7.6.1
This website is maintained by Timothy Pearson.