• 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 "";
01162         }
01163         else {
01164             // Error!
01165             PRINT_ERROR((error.name() + ": " + error.message()))
01166             return "";
01167         }
01168     }
01169     else {
01170         return "";
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 != "") {
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     else {
01573         if (d->m_dbusDeviceString != "") {
01574             // Query NM for the device type
01575             TQT_DBusError error;
01576             d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
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 DBUS device string '%1'").arg(d->m_dbusDeviceString))
01592             return TDENetworkDeviceType::Other;
01593         }
01594     }
01595 }
01596 
01597 TDENetworkConnectionType::TDENetworkConnectionType TDENetworkConnectionManager_BackendNM::connectionType(TQString dbusPath) {
01598     TDENetworkConnectionType::TDENetworkConnectionType connType = TDENetworkConnectionType::Other;
01599     TQ_UINT32 ret;
01600     TQT_DBusError error;
01601 
01602 #ifndef USE_ASYNC_DBUS_CALLS
01603     // Obtain connection settings from the path specified
01604     DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
01605     connectionSettings.setConnection(TQT_DBusConnection::systemBus());
01606     TQT_DBusTQStringDataMap connectionSettingsMap;
01607     ret = connectionSettings.GetSettings(connectionSettingsMap, error);
01608     if (ret && error.isValid()) {
01609         ret = 0;
01610         PRINT_ERROR((error.name() + ": " + error.message()))
01611     }
01612     if (ret) {
01613 #else // USE_ASYNC_DBUS_CALLS
01614     // Obtain connection settings from the path specified
01615     DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
01616     connectionSettings.setConnection(TQT_DBusConnection::systemBus());
01617     connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
01618     int asyncCallID;
01619     ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
01620     if (ret && error.isValid()) {
01621         ret = 0;
01622         PRINT_ERROR((error.name() + ": " + error.message()))
01623     }
01624     if (ret) {
01625         // Wait for the asynchronous call to return...
01626         d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
01627         TQTimer nmCallTimeoutTimer;
01628         nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
01629         while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
01630             tqApp->processEvents();
01631             if (!nmCallTimeoutTimer.isActive()) {
01632                 PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
01633                 break;
01634             }
01635         }
01636         TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
01637         if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
01638             PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
01639             d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
01640         }
01641         d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
01642         if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
01643             d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
01644         }
01645 #endif // USE_ASYNC_DBUS_CALLS
01646 
01647         // Parse settings to find connection type
01648         TQT_DBusTQStringDataMap::const_iterator it2;
01649         for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
01650             TQString outerKeyValue = it2.key();
01651             TQT_DBusData dataValue = it2.data();
01652 
01653             TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
01654             TQT_DBusTQStringDataMap::const_iterator it3;
01655             for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
01656                 TQString keyValue = it3.key();
01657                 TQT_DBusData dataValue = it3.data();
01658                 if (dataValue.type() == TQT_DBusData::Variant) {
01659                     TQT_DBusVariant dataValueVariant = dataValue.toVariant();
01660                     TQT_DBusData dataValue2 = dataValueVariant.value;
01661                     if (dataValue2.type() != TQT_DBusData::Variant) {
01662                         if (outerKeyValue.lower() == "connection") {
01663                             if (keyValue.lower() == "type") {
01664                                 connType = nmConnectionTypeToTDEConnectionType(dataValue2.toString());
01665                             }
01666                         }
01667                     }
01668                 }
01669             }
01670         }
01671     }
01672 
01673     return connType;
01674 }
01675 
01676 TQString TDENetworkConnectionManager_BackendNM::backendName() {
01677     return i18n("NetworkManager");
01678 }
01679 
01680 TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags TDENetworkConnectionManager_BackendNM::backendStatus() {
01681     if (d->m_networkManagerProxy) {
01682         TQ_UINT32 ret;
01683         TQT_DBusError error;
01684         ret = d->m_networkManagerProxy->getState(error);
01685         if (error.isValid()) {
01686             // Error!
01687             PRINT_ERROR((error.name() + ": " + error.message()))
01688             return TDENetworkGlobalManagerFlags::BackendUnavailable;
01689         }
01690         else {
01691             TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags globalFlags = nmGlobalStateToTDEGlobalState(ret);
01692             TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags vpnFlags = TDENetworkGlobalManagerFlags::Unknown;
01693             if (d->m_vpnProxy) {
01694                 ret = d->m_vpnProxy->getState(error);
01695                 if (error.isValid()) {
01696                     // Error!
01697                     bool print_error = true;
01698                     if (error.name() == "org.freedesktop.DBus.Error.ServiceUnknown") {
01699                         if (d->vpn_service_error_notified) {
01700                             print_error = false;
01701                         }
01702                         else {
01703                             d->vpn_service_error_notified = true;
01704                         }
01705                     }
01706                     if (print_error) {
01707                         PRINT_ERROR(TQString("Attempting to access the network-manager VPN service returned: %1").arg(error.name() + ": " + error.message()))
01708                     }
01709                     vpnFlags = TDENetworkGlobalManagerFlags::VPNUnknown;
01710                 }
01711                 else {
01712                     vpnFlags = nmVPNStateToTDEGlobalState(ret);
01713                 }
01714             }
01715             return globalFlags | vpnFlags;
01716         }
01717     }
01718     else {
01719         return TDENetworkGlobalManagerFlags::BackendUnavailable;
01720     }
01721 }
01722 
01723 TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceInformation() {
01724     TQT_DBusError error;
01725     TDENetworkDeviceInformation ret;
01726 
01727     if (d->m_networkDeviceProxy) {
01728         ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
01729         ret.UUID = d->m_networkDeviceProxy->getUdi(error);
01730         ret.backendDriver = d->m_networkDeviceProxy->getDriver(error);
01731         ret.backendDriverVersion = d->m_networkDeviceProxy->getDriverVersion(error);
01732         ret.firmwareVersion = d->m_networkDeviceProxy->getFirmwareVersion(error);
01733         ret.capabilityFlags = nmCapabilityFlagsToTDECapabilityFlags(d->m_networkDeviceProxy->getCapabilities(error));
01734         // ipConfiguration is not filled in, as the TDE HW library provides complementary functionality and is more reliable/easier to use and maintain
01735         ret.managed = d->m_networkDeviceProxy->getManaged(error);
01736         ret.autoConnect = d->m_networkDeviceProxy->getAutoconnect(error);
01737         ret.firmwareMissing = d->m_networkDeviceProxy->getFirmwareMissing(error);
01738         ret.deviceType = nmDeviceTypeToTDEDeviceType(d->m_networkDeviceProxy->getDeviceType(error));
01739         if (error.isValid()) {
01740             // Error!
01741             bool print_error = true;
01742             if (error.name() == "org.freedesktop.DBus.Error.AccessDenied") {
01743                 if (error.message().contains("org.freedesktop.NetworkManager.Device")) {
01744                     // Unable to determine if device allows autoconnect
01745                     // Assume true!
01746                     ret.autoConnect = true;
01747                     if (d->device_autoconnect_error_notified) {
01748                         print_error = false;
01749                     }
01750                     else {
01751                         d->device_autoconnect_error_notified = true;
01752                     }
01753                 }
01754             }
01755             if (print_error) {
01756                 PRINT_ERROR((error.name() + ": " + error.message()))
01757             }
01758 
01759             // Reset error object to avoid spurious error messages on the command line
01760             error = TQT_DBusError();
01761         }
01762 
01763         // Populate wiFiInfo
01764         if ((deviceType() == TDENetworkDeviceType::WiFi) && (d->m_wiFiDeviceProxy)) {
01765             ret.wiFiInfo.valid = true;
01766             ret.wiFiInfo.hwAddress.fromString(d->m_wiFiDeviceProxy->getHwAddress(error));
01767             ret.wiFiInfo.permanentHWAddress.fromString(d->m_wiFiDeviceProxy->getPermHwAddress(error));
01768             ret.wiFiInfo.operatingMode = nmWiFiModeToTDEWiFiMode(d->m_wiFiDeviceProxy->getMode(error));
01769             ret.wiFiInfo.bitrate = d->m_wiFiDeviceProxy->getBitrate(error);
01770             TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(d->m_wiFiDeviceProxy->getActiveAccessPoint(error));
01771             if (error.isValid()) {
01772                 PRINT_ERROR((error.name() + ": " + error.message()))
01773 
01774                 // Reset error object to avoid spurious error messages on the command line
01775                 error = TQT_DBusError();
01776             }
01777             if (apInfo) {
01778                 ret.wiFiInfo.activeAccessPointBSSID = apInfo->BSSID;
01779                 TDENetworkWiFiAPInfo* neighborListAPInfo = findAccessPointByBSSID(ret.wiFiInfo.activeAccessPointBSSID);
01780                 if (neighborListAPInfo) {
01781                     *neighborListAPInfo = *apInfo;
01782                 }
01783                 delete apInfo;
01784             }
01785             else {
01786                 ret.wiFiInfo.activeAccessPointBSSID = TDEMACAddress();
01787             }
01788             ret.wiFiInfo.wirelessFlags = tdeWiFiFlagsToNMWiFiFlags(d->m_wiFiDeviceProxy->getWirelessCapabilities(error));
01789         }
01790         else {
01791             ret.wiFiInfo.valid = false;
01792         }
01793 
01794         // Get active connection UUID
01795         TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
01796         if (!error.isValid()) {
01797             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
01798             activeConnection.setConnection(TQT_DBusConnection::systemBus());
01799             ret.activeConnectionUUID = activeConnection.getUuid(error);
01800             if (error.isValid()) {
01801                 ret.activeConnectionUUID = TQString::null;
01802             }
01803         }
01804 
01805         ret.valid = true;
01806     }
01807 
01808     return ret;
01809 }
01810 
01811 TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceStatus() {
01812     TQT_DBusError error;
01813     TDENetworkDeviceInformation ret;
01814 
01815     if (d->m_networkDeviceProxy) {
01816         ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
01817         ret.UUID = d->m_networkDeviceProxy->getUdi(error);
01818 
01819         // Get active connection UUID
01820         TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
01821         if (!error.isValid()) {
01822             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
01823             activeConnection.setConnection(TQT_DBusConnection::systemBus());
01824             ret.activeConnectionUUID = activeConnection.getUuid(error);
01825             if (error.isValid()) {
01826                 ret.activeConnectionUUID = TQString::null;
01827             }
01828         }
01829 
01830         ret.valid = true;
01831     }
01832 
01833     return ret;
01834 }
01835 
01836 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncReply(int asyncCallId, const TQT_DBusDataMap<TQString>& settings) {
01837     nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
01838     nmConnectionSettingsAsyncSettingsResponse[asyncCallId] = settings;
01839 }
01840 
01841 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncReply(int asyncCallId) {
01842     nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
01843 }
01844 
01845 void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncReply(int asyncCallId, const TQT_DBusObjectPath& path) {
01846     nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
01847     nmAddConnectionAsyncResponse[asyncCallId] = path;
01848 }
01849 
01850 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncError(int asyncCallId, const TQT_DBusError error) {
01851     nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallId] = error;
01852 }
01853 
01854 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncError(int asyncCallId, const TQT_DBusError error) {
01855     nmConnectionSettingsUpdateAsyncSettingsErrorResponse[asyncCallId] = error;
01856 }
01857 
01858 void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncError(int asyncCallId, const TQT_DBusError error) {
01859     nmAddConnectionAsyncErrorResponse[asyncCallId] = error;
01860 }
01861 
01862 void TDENetworkConnectionManager_BackendNM::loadConnectionInformation() {
01863     if (d->nonReentrantCallActive) return;
01864 
01865     d->nonReentrantCallActive = true;
01866 
01867     TDEMACAddress deviceMACAddress;
01868     deviceMACAddress.fromString(this->deviceMACAddress());
01869 
01870     if (d->m_networkManagerSettings) {
01871         clearTDENetworkConnectionList();
01872         TQT_DBusObjectPathList connections;
01873         TQT_DBusError error;
01874         bool ret;
01875         int state;
01876         ret = d->m_networkManagerSettings->ListConnections(connections, error);
01877         if (ret) {
01878             TQT_DBusObjectPathList::iterator it;
01879             for (it = connections.begin(); it != connections.end(); ++it) {
01880                 TDENetworkConnection* connection;
01881                 TDEWiredEthernetConnection* ethernetConnection = NULL;
01882                 TDEWiredInfinibandConnection* infinibandConnection = NULL;
01883                 TDEWiFiConnection* wiFiConnection = NULL;
01884                 TDEVPNConnection* vpnConnection = NULL;
01885                 TDEWiMaxConnection* wiMaxConnection = NULL;
01886                 TDEVLANConnection* vlanConnection = NULL;
01887                 TDEOLPCMeshConnection* olpcMeshConnection = NULL;
01888                 TDEBluetoothConnection* bluetoothConnection = NULL;
01889                 TDEModemConnection* modemConnection = NULL;
01890                 TDENetworkConnectionType::TDENetworkConnectionType connType = connectionType((*it));
01891                 if (connType == TDENetworkConnectionType::WiredEthernet) {
01892                     connection = ethernetConnection = new TDEWiredEthernetConnection;
01893                 }
01894                 else if (connType == TDENetworkConnectionType::Infiniband) {
01895                     connection = infinibandConnection = new TDEWiredInfinibandConnection;
01896                 }
01897                 else if (connType == TDENetworkConnectionType::WiFi) {
01898                     connection = wiFiConnection = new TDEWiFiConnection;
01899                 }
01900                 else if (connType == TDENetworkConnectionType::VPN) {
01901                     connection = vpnConnection = new TDEVPNConnection;
01902                 }
01903                 else if (connType == TDENetworkConnectionType::WiMax) {
01904                     connection = wiMaxConnection = new TDEWiMaxConnection;
01905                 }
01906                 else if (connType == TDENetworkConnectionType::VLAN) {
01907                     connection = vlanConnection = new TDEVLANConnection;
01908                 }
01909                 else if (connType == TDENetworkConnectionType::OLPCMesh) {
01910                     connection = olpcMeshConnection = new TDEOLPCMeshConnection;
01911                 }
01912                 else if (connType == TDENetworkConnectionType::Bluetooth) {
01913                     connection = bluetoothConnection = new TDEBluetoothConnection;
01914                 }
01915                 else if (connType == TDENetworkConnectionType::Modem) {
01916                     connection = modemConnection = new TDEModemConnection;
01917                 }
01918                 else {
01919                     connection = new TDENetworkConnection;
01920                 }
01921                 // Set up defaults
01922                 connection->ipConfig.connectionFlags =  TDENetworkIPConfigurationFlags::IPV4DHCPIP          | \
01923                                     TDENetworkIPConfigurationFlags::IPV4DHCPDNS         | \
01924                                     TDENetworkIPConfigurationFlags::IPV4DHCPRoutes          | \
01925                                     TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute    | \
01926                                     TDENetworkIPConfigurationFlags::IPV6DHCPIP          | \
01927                                     TDENetworkIPConfigurationFlags::IPV6DHCPDNS         | \
01928                                     TDENetworkIPConfigurationFlags::IPV6DHCPRoutes          | \
01929                                     TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
01930                 // Set up NM-specific defaults
01931                 // Keep in sync with latest NM default settings!
01932                 // NM 0.9 setting descriptions and default values are available at:
01933                 // http://projects.gnome.org/NetworkManager/developers/api/09/ref-settings.html
01934                 connection->autoConnect = true;
01935 
01936                 if (wiFiConnection) {
01937                     wiFiConnection->securitySettings.authType = TDENetworkWiFiAuthType::Open;
01938                 }
01939 
01940 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
01941                 printf("[network-manager comm debug] %s\n", (*it).data()); fflush(stdout);
01942 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
01943 
01944 #ifndef USE_ASYNC_DBUS_CALLS
01945                 // Obtain connection settings from the path specified
01946                 DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
01947                 connectionSettings.setConnection(TQT_DBusConnection::systemBus());
01948                 TQT_DBusTQStringDataMap connectionSettingsMap;
01949                 ret = connectionSettings.GetSettings(connectionSettingsMap, error);
01950                 if (ret && error.isValid()) {
01951                     ret = 0;
01952                     PRINT_ERROR((error.name() + ": " + error.message()))
01953                 }
01954                 if (ret) {
01955 #else // USE_ASYNC_DBUS_CALLS
01956                 // Obtain connection settings from the path specified
01957                 DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
01958                 connectionSettings.setConnection(TQT_DBusConnection::systemBus());
01959                 connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
01960                 connect(&connectionSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processConnectionSettingsAsyncError(int, const TQT_DBusError)));
01961                 int asyncCallID;
01962                 ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
01963                 if (ret && error.isValid()) {
01964                     ret = 0;
01965                     PRINT_ERROR((error.name() + ": " + error.message()))
01966                 }
01967                 if (ret) {
01968                     // Wait for the asynchronous call to return...
01969                     d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
01970                     TQTimer nmCallTimeoutTimer;
01971                     nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
01972                     while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
01973                         tqApp->processEvents();
01974                         if (!nmCallTimeoutTimer.isActive()) {
01975                             PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
01976                             break;
01977                         }
01978                     }
01979                     TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
01980                     if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
01981                         PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
01982                         d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
01983                     }
01984                     d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
01985                     if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
01986                         d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
01987                     }
01988 #endif // USE_ASYNC_DBUS_CALLS
01989 
01990 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
01991                     printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
01992                     printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
01993 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
01994 
01995                     // Parse settings
01996                     TQT_DBusTQStringDataMap::const_iterator it2;
01997                     for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
01998                         TQString outerKeyValue = it2.key();
01999                         TQT_DBusData dataValue = it2.data();
02000 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02001                         printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
02002 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02003                         TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
02004                         TQT_DBusTQStringDataMap::const_iterator it3;
02005                         for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
02006                             TQString keyValue = it3.key();
02007                             TQT_DBusData dataValue = it3.data();
02008                             if (dataValue.type() != TQT_DBusData::Variant) {
02009 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02010                                 printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
02011 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02012                                 // No NM settings are known which use this style
02013                             }
02014                             else {
02015                                 TQT_DBusVariant dataValueVariant = dataValue.toVariant();
02016                                 TQT_DBusData dataValue2 = dataValueVariant.value;
02017                                 if (dataValue2.type() != TQT_DBusData::Variant) {
02018 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02019                                     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);
02020 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
02021                                     // Most NM settings use this style
02022                                     if (outerKeyValue.lower() == "connection") {
02023                                         if (keyValue.lower() == "id") {
02024                                             connection->friendlyName = dataValue2.toString();
02025                                         }
02026                                         else if (keyValue.lower() == "uuid") {
02027                                             connection->UUID = dataValue2.toString().lower();
02028                                         }
02029                                         else if (keyValue.lower() == "permissions") {
02030                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02031                                             TQT_DBusDataValueList::const_iterator it4;
02032                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02033                                                 TQT_DBusData innerDataValue = *it4;
02034                                                 TQString authString = innerDataValue.toString();
02035                                                 TQStringList pieces = TQStringList::split(":", authString);
02036                                                 if (pieces[0].lower() == "user") {
02037                                                     connection->authorizedUsers.append(pieces[1]);
02038                                                 }
02039                                             }
02040                                         }
02041                                         else if (keyValue.lower() == "autoconnect") {
02042                                             connection->autoConnect = dataValue2.toBool();
02043                                         }
02044                                         else if (keyValue.lower() == "read-only") {
02045                                             connection->readOnly = dataValue2.toBool();
02046                                         }
02047                                         else if (keyValue.lower() == "master") {
02048                                             connection->masterConnectionUUID = dataValue2.toString().lower();
02049                                         }
02050                                         else if (keyValue.lower() == "slave-type") {
02051                                             connection->slaveType = nmSlaveTypeToTDESlaveType(dataValue2.toString());
02052                                         }
02053                                         else if (keyValue.lower() == "timestamp") {
02054                                             connection->lastKnownConnection.setTime_t(dataValue2.toUInt64());
02055                                         }
02056                                     }
02057                                     else if (outerKeyValue.lower() == "802-1x") {
02058                                         if (keyValue.lower() == "eap") {
02059                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02060                                             TQT_DBusDataValueList::const_iterator it4;
02061                                             state = 0;
02062                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02063                                                 TQT_DBusData innerDataValue = *it4;
02064                                                 if (state == 0) {
02065                                                     // EAP type
02066                                                     connection->eapConfig.type = nmEAPTypeToTDEEAPType(innerDataValue.toString());
02067                                                 }
02068                                                 state++;
02069                                             }
02070                                         }
02071                                         else if (keyValue.lower() == "identity") {
02072                                             connection->eapConfig.userName = dataValue2.toString();
02073                                         }
02074                                         else if (keyValue.lower() == "anonymous-identity") {
02075                                             connection->eapConfig.anonymousUserName = dataValue2.toString();
02076                                         }
02077                                         else if (keyValue.lower() == "pac-file") {
02078                                             connection->eapConfig.pacFileName = dataValue2.toString();
02079                                         }
02080                                         else if (keyValue.lower() == "ca-cert") {
02081                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02082                                             TQT_DBusDataValueList::const_iterator it4;
02083                                             int count=0;
02084                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02085                                                 TQT_DBusData innerDataValue = *it4;
02086                                                 count++;
02087                                                 connection->eapConfig.caCertificate.resize(count+1);
02088                                                 connection->eapConfig.caCertificate[count] = innerDataValue.toByte();
02089                                             }
02090                                         }
02091                                         else if (keyValue.lower() == "ca-path") {
02092                                             connection->eapConfig.additionalCAFilesPath = dataValue2.toString();
02093                                         }
02094                                         else if (keyValue.lower() == "subject-match") {
02095                                             connection->eapConfig.authServerCertSubjectMatch = dataValue2.toString();
02096                                         }
02097                                         else if (keyValue.lower() == "altsubject-matches") {
02098                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02099                                             TQT_DBusDataValueList::const_iterator it4;
02100                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02101                                                 TQT_DBusData innerDataValue = *it4;
02102                                                 connection->eapConfig.alternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
02103                                             }
02104                                         }
02105                                         else if (keyValue.lower() == "client-cert") {
02106                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02107                                             TQT_DBusDataValueList::const_iterator it4;
02108                                             int count=0;
02109                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02110                                                 TQT_DBusData innerDataValue = *it4;
02111                                                 count++;
02112                                                 connection->eapConfig.clientCertificate.resize(count+1);
02113                                                 connection->eapConfig.clientCertificate[count] = innerDataValue.toByte();
02114                                             }
02115                                         }
02116                                         else if (keyValue.lower() == "phase1-peapver") {
02117                                             connection->eapConfig.forcePEAPVersion = dataValue2.toString();
02118                                         }
02119                                         else if (keyValue.lower() == "phase1-peaplabel") {
02120                                             connection->eapConfig.forcePEAPLabel = dataValue2.toString();
02121                                         }
02122                                         else if (keyValue.lower() == "phase1-fast-provisioning") {
02123                                             connection->eapConfig.fastProvisioningFlags = nmEAPFastFlagsToTDEEAPFastFlags(dataValue2.toString());
02124                                         }
02125                                         else if (keyValue.lower() == "phase2-auth") {
02126                                             connection->eapConfig.phase2NonEAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
02127                                         }
02128                                         else if (keyValue.lower() == "phase2-autheap") {
02129                                             connection->eapConfig.phase2EAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
02130                                         }
02131                                         else if (keyValue.lower() == "phase2-ca-cert") {
02132                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02133                                             TQT_DBusDataValueList::const_iterator it4;
02134                                             int count=0;
02135                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02136                                                 TQT_DBusData innerDataValue = *it4;
02137                                                 count++;
02138                                                 connection->eapConfig.phase2CaCertificate.resize(count+1);
02139                                                 connection->eapConfig.phase2CaCertificate[count] = innerDataValue.toByte();
02140                                             }
02141                                         }
02142                                         else if (keyValue.lower() == "phase2-ca-path") {
02143                                             connection->eapConfig.phase2CaFilesPath = dataValue2.toString();
02144                                         }
02145                                         else if (keyValue.lower() == "phase2-subject-match") {
02146                                             connection->eapConfig.phase2AuthServerCertSubjectMatch = dataValue2.toString();
02147                                         }
02148                                         else if (keyValue.lower() == "phase2-altsubject-matches") {
02149                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02150                                             TQT_DBusDataValueList::const_iterator it4;
02151                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02152                                                 TQT_DBusData innerDataValue = *it4;
02153                                                 connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
02154                                             }
02155                                         }
02156                                         else if (keyValue.lower() == "phase2-client-cert") {
02157                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02158                                             TQT_DBusDataValueList::const_iterator it4;
02159                                             int count=0;
02160                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02161                                                 TQT_DBusData innerDataValue = *it4;
02162                                                 count++;
02163                                                 connection->eapConfig.phase2ClientCertificate.resize(count+1);
02164                                                 connection->eapConfig.phase2ClientCertificate[count] = innerDataValue.toByte();
02165                                             }
02166                                         }
02167                                         else if (keyValue.lower() == "password-flags") {
02168                                             connection->eapConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02169                                         }
02170                                         else if (keyValue.lower() == "password-raw-flags") {
02171                                             connection->eapConfig.binaryPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02172                                         }
02173                                         else if (keyValue.lower() == "private-key") {
02174                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02175                                             TQT_DBusDataValueList::const_iterator it4;
02176                                             int count=0;
02177                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02178                                                 TQT_DBusData innerDataValue = *it4;
02179                                                 count++;
02180                                                 connection->eapConfig.privateKey.resize(count+1);
02181                                                 connection->eapConfig.privateKey[count] = innerDataValue.toByte();
02182                                             }
02183                                         }
02184                                         else if (keyValue.lower() == "private-key-password-flags") {
02185                                             connection->eapConfig.privateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02186                                         }
02187                                         else if (keyValue.lower() == "phase2-private-key") {
02188                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02189                                             TQT_DBusDataValueList::const_iterator it4;
02190                                             int count=0;
02191                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02192                                                 TQT_DBusData innerDataValue = *it4;
02193                                                 count++;
02194                                                 connection->eapConfig.phase2PrivateKey.resize(count+1);
02195                                                 connection->eapConfig.phase2PrivateKey[count] = innerDataValue.toByte();
02196                                             }
02197                                         }
02198                                         else if (keyValue.lower() == "phase2-private-key-password-flags") {
02199                                             connection->eapConfig.phase2PrivateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02200                                         }
02201                                         else if (keyValue.lower() == "system-ca-certs") {
02202                                             connection->eapConfig.forceSystemCaCertificates = dataValue2.toBool();
02203                                         }
02204                                         connection->eapConfig.valid = true;
02205                                     }
02206                                     else if (outerKeyValue.lower() == "802-3-ethernet") {
02207                                         if (keyValue.lower() == "duplex") {
02208                                             connection->fullDuplex = (dataValue2.toString().lower() == "full")?true:false;
02209                                         }
02210                                         else if (keyValue.lower() == "mac-address") {
02211                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02212                                             TQT_DBusDataValueList::const_iterator it4;
02213                                             TDENetworkByteList macAddress;
02214                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02215                                                 TQT_DBusData innerDataValue = *it4;
02216                                                 macAddress.append(innerDataValue.toByte());
02217                                             }
02218                                             connection->lockedHWAddress.setAddress(macAddress);
02219                                         }
02220                                         else if (keyValue.lower() == "cloned-mac-address") {
02221                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02222                                             TQT_DBusDataValueList::const_iterator it4;
02223                                             TDENetworkByteList macAddress;
02224                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02225                                                 TQT_DBusData innerDataValue = *it4;
02226                                                 macAddress.append(innerDataValue.toByte());
02227                                             }
02228                                             connection->manualHWAddress.setAddress(macAddress);
02229                                         }
02230                                         else if (keyValue.lower() == "mtu") {
02231                                             connection->mtu = dataValue2.toUInt32();
02232                                         }
02233                                     }
02234                                     else if (outerKeyValue.lower() == "infiniband") {
02235                                         if (keyValue.lower() == "mac-address") {
02236                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02237                                             TQT_DBusDataValueList::const_iterator it4;
02238                                             TDENetworkByteList macAddress;
02239                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02240                                                 TQT_DBusData innerDataValue = *it4;
02241                                                 macAddress.append(innerDataValue.toByte());
02242                                             }
02243                                             connection->lockedHWAddress.setAddress(macAddress);
02244                                         }
02245                                         else if (keyValue.lower() == "mtu") {
02246                                             connection->mtu = dataValue2.toUInt32();
02247                                         }
02248                                         else if (keyValue.lower() == "transport-mode") {
02249                                             infinibandConnection->transportMode = nmIBTransportToTDEIBTransport(dataValue2.toString());
02250                                         }
02251                                     }
02252                                     else if (outerKeyValue.lower() == "802-11-wireless") {
02253                                         if (keyValue.lower() == "ssid") {
02254                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02255                                             TQT_DBusDataValueList::const_iterator it4;
02256                                             int count = 0;
02257                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02258                                                 TQT_DBusData innerDataValue = *it4;
02259                                                 wiFiConnection->SSID.resize(count+1);
02260                                                 wiFiConnection->SSID[count] = innerDataValue.toByte();
02261                                                 count++;
02262                                             }
02263                                         }
02264                                         else if (keyValue.lower() == "mac-address") {
02265                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02266                                             TQT_DBusDataValueList::const_iterator it4;
02267                                             TDENetworkByteList macAddress;
02268                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02269                                                 TQT_DBusData innerDataValue = *it4;
02270                                                 macAddress.append(innerDataValue.toByte());
02271                                             }
02272                                             connection->lockedHWAddress.setAddress(macAddress);
02273                                         }
02274                                         else if (keyValue.lower() == "cloned-mac-address") {
02275                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02276                                             TQT_DBusDataValueList::const_iterator it4;
02277                                             TDENetworkByteList macAddress;
02278                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02279                                                 TQT_DBusData innerDataValue = *it4;
02280                                                 macAddress.append(innerDataValue.toByte());
02281                                             }
02282                                             connection->manualHWAddress.setAddress(macAddress);
02283                                         }
02284                                         else if (keyValue.lower() == "mtu") {
02285                                             connection->mtu = dataValue2.toUInt32();
02286                                         }
02287                                         else if (keyValue.lower() == "mode") {
02288                                             wiFiConnection->operatingMode = nmWiFiModeToTDEWiFiMode(dataValue2.toString());
02289                                         }
02290                                         else if (keyValue.lower() == "band") {
02291                                             wiFiConnection->bandRestriction = nmWiFiFrequencyBandToTDEWiFiFrequencyBand(dataValue2.toString());
02292                                         }
02293                                         else if (keyValue.lower() == "channel") {
02294                                             wiFiConnection->channelRestriction = dataValue2.toUInt32();
02295                                             if (wiFiConnection->channelRestriction == 0) wiFiConnection->channelRestriction = -1;
02296                                         }
02297                                         else if (keyValue.lower() == "rate") {
02298                                             wiFiConnection->bitRateRestriction = dataValue2.toUInt32()*1000;
02299                                             if (wiFiConnection->bitRateRestriction == 0) wiFiConnection->bitRateRestriction = -1;
02300                                         }
02301                                         else if (keyValue.lower() == "tx-power") {
02302                                             wiFiConnection->powerRestriction = dataValue2.toUInt32();
02303                                             if (wiFiConnection->powerRestriction == 0) wiFiConnection->powerRestriction = -1;
02304                                         }
02305                                         else if (keyValue.lower() == "bssid") {
02306                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02307                                             TQT_DBusDataValueList::const_iterator it4;
02308                                             TDENetworkByteList macAddress;
02309                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02310                                                 TQT_DBusData innerDataValue = *it4;
02311                                                 macAddress.append(innerDataValue.toByte());
02312                                             }
02313                                             wiFiConnection->accessPointRestriction.setAddress(macAddress);
02314                                         }
02315                                         else if (keyValue.lower() == "mac-address-blacklist") {
02316                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02317                                             TQT_DBusDataValueList::const_iterator it4;
02318                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02319                                                 TQT_DBusData innerDataValue = *it4;
02320                                                 TDEMACAddress hwAddress;
02321                                                 hwAddress.fromString(innerDataValue.toString());
02322                                                 wiFiConnection->blacklistedBSSIDs.append(hwAddress);
02323                                             }
02324                                         }
02325                                         else if (keyValue.lower() == "seen-bssids") {
02326                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02327                                             TQT_DBusDataValueList::const_iterator it4;
02328                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02329                                                 TQT_DBusData innerDataValue = *it4;
02330                                                 TDEMACAddress hwAddress;
02331                                                 hwAddress.fromString(innerDataValue.toString());
02332                                                 wiFiConnection->heardBSSIDs.append(hwAddress);
02333                                             }
02334                                         }
02335                                         else if (keyValue.lower() == "security") {
02336                                             TQString setting;
02337                                             if (setting.lower() == "802-11-wireless-security") {
02338                                                 wiFiConnection->securityRequired = true;
02339                                             }
02340                                             else {
02341                                                 wiFiConnection->securityRequired = false;
02342                                             }
02343                                         }
02344                                         else if (keyValue.lower() == "hidden") {
02345                                             wiFiConnection->isHiddenNetwork = dataValue2.toBool();
02346                                         }
02347                                     }
02348                                     else if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
02349                                         if (keyValue.lower() == "key-mgmt") {
02350                                             wiFiConnection->securitySettings.keyType = nmWiFiKeyTypeToTDEWiFiKeyType(dataValue2.toString());
02351                                         }
02352                                         else if (keyValue.lower() == "wep-tx-keyidx") {
02353                                             wiFiConnection->securitySettings.wepKeyIndex = dataValue2.toUInt32();
02354                                         }
02355                                         else if (keyValue.lower() == "auth-alg") {
02356                                             wiFiConnection->securitySettings.authType = nmWiFiAuthTypeToTDEWiFiAuthType(dataValue2.toString());
02357                                         }
02358                                         else if (keyValue.lower() == "proto") {
02359                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02360                                             TQT_DBusDataValueList::const_iterator it4;
02361                                             TQStringList strings;
02362                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02363                                                 TQT_DBusData innerDataValue = *it4;
02364                                                 strings.append(innerDataValue.toString());
02365                                             }
02366                                             wiFiConnection->securitySettings.wpaVersion = nmWiFiWPAVersionToTDEWiFiWPAVersion(strings);
02367                                         }
02368                                         else if (keyValue.lower() == "pairwise") {
02369                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02370                                             TQT_DBusDataValueList::const_iterator it4;
02371                                             TQStringList strings;
02372                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02373                                                 TQT_DBusData innerDataValue = *it4;
02374                                                 wiFiConnection->securitySettings.allowedPairWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
02375                                             }
02376                                             if ((wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
02377                                                 || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
02378                                                 || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
02379                                                 || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
02380                                                 wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
02381                                             }
02382                                         }
02383                                         else if (keyValue.lower() == "group") {
02384                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02385                                             TQT_DBusDataValueList::const_iterator it4;
02386                                             TQStringList strings;
02387                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02388                                                 TQT_DBusData innerDataValue = *it4;
02389                                                 wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
02390                                             }
02391                                             if ((wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
02392                                                 || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
02393                                                 || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
02394                                                 || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
02395                                                 wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
02396                                             }
02397                                         }
02398                                         else if (keyValue.lower() == "leap-username") {
02399                                             wiFiConnection->securitySettings.leapUsername = dataValue2.toString();
02400                                         }
02401                                         else if (keyValue.lower() == "wep-key-flags") {
02402                                             wiFiConnection->securitySettings.wepKeyFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02403                                         }
02404                                         else if (keyValue.lower() == "wep-key-type") {
02405                                             wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(dataValue2.toUInt32());
02406                                         }
02407                                         else if (keyValue.lower() == "psk-flags") {
02408                                             wiFiConnection->securitySettings.pskFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02409                                         }
02410                                         else if (keyValue.lower() == "leap-password-flags") {
02411                                             wiFiConnection->securitySettings.leapPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02412                                         }
02413                                         wiFiConnection->securitySettings.valid = true;
02414                                     }
02415                                     else if (outerKeyValue.lower() == "vpn") {
02416                                         if (keyValue.lower() == "service-type") {
02417                                             TQString plugin = dataValue2.toString();
02418                                             plugin.replace("org.freedesktop.NetworkManager.", "");
02419                                             vpnConnection->vpnPluginID = plugin;
02420                                         }
02421                                         else if (keyValue.lower() == "user-name") {
02422                                             vpnConnection->lockedUserName = dataValue2.toString();
02423                                         }
02424                                         else if (keyValue.lower() == "data") {
02425                                             vpnConnection->pluginData.clear();
02426                                             TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
02427                                             TQT_DBusTQStringDataMap::const_iterator it4;
02428                                             for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
02429                                                 TQString keyValue4 = it4.key();
02430                                                 TQT_DBusData dataValue4 = it4.data();
02431                                                 if (dataValue4.type() == TQT_DBusData::String) {
02432                                                     vpnConnection->pluginData[keyValue4] = dataValue4.toString();
02433                                                 }
02434                                             }
02435                                         }
02436                                     }
02437                                     else if (outerKeyValue.lower() == "wimax") {
02438                                         if (keyValue.lower() == "mac-address") {
02439                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02440                                             TQT_DBusDataValueList::const_iterator it4;
02441                                             TDENetworkByteList macAddress;
02442                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02443                                                 TQT_DBusData innerDataValue = *it4;
02444                                                 macAddress.append(innerDataValue.toByte());
02445                                             }
02446                                             connection->lockedHWAddress.setAddress(macAddress);
02447                                         }
02448                                         else if (keyValue.lower() == "network-name") {
02449                                             wiMaxConnection->networkServiceProvider = dataValue2.toString();
02450                                         }
02451                                     }
02452                                     else if (outerKeyValue.lower() == "vlan") {
02453                                         if (keyValue.lower() == "interface-name") {
02454                                             vlanConnection->kernelName = dataValue2.toString();
02455                                         }
02456                                         else if (keyValue.lower() == "parent") {
02457                                             vlanConnection->parentConnectionUUID = dataValue2.toString();
02458                                         }
02459                                         else if (keyValue.lower() == "id") {
02460                                             vlanConnection->vlanID = dataValue2.toUInt32();
02461                                         }
02462                                         else if (keyValue.lower() == "flags") {
02463                                             vlanConnection->vlanFlags = nmVLANFlagsToTDEVLANFlags(dataValue2.toUInt32());
02464                                         }
02465                                         else if (keyValue.lower() == "ingress-priority-map") {
02466                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02467                                             TQT_DBusDataValueList::const_iterator it4;
02468                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02469                                                 TQT_DBusData innerDataValue = *it4;
02470                                                 TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
02471                                                 vlanConnection->ingressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
02472                                             }
02473                                         }
02474                                         else if (keyValue.lower() == "egress-priority-map") {
02475                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02476                                             TQT_DBusDataValueList::const_iterator it4;
02477                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02478                                                 TQT_DBusData innerDataValue = *it4;
02479                                                 TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
02480                                                 vlanConnection->egressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
02481                                             }
02482                                         }
02483                                     }
02484                                     else if (outerKeyValue.lower() == "serial") {
02485                                         if (keyValue.lower() == "baud") {
02486                                             connection->serialConfig.baudRate = dataValue2.toUInt32();
02487                                         }
02488                                         else if (keyValue.lower() == "bits") {
02489                                             connection->serialConfig.byteWidth = dataValue2.toUInt32();
02490                                         }
02491                                         else if (keyValue.lower() == "parity") {
02492                                             connection->serialConfig.parity = nmParityToTDEParity(dataValue2.toByte());
02493                                         }
02494                                         else if (keyValue.lower() == "stopbits") {
02495                                             connection->serialConfig.stopBits = dataValue2.toUInt32();
02496                                         }
02497                                         else if (keyValue.lower() == "send-delay") {
02498                                             connection->serialConfig.txDelay = dataValue2.toUInt64();
02499                                         }
02500                                         connection->serialConfig.valid = true;
02501                                     }
02502                                     else if (outerKeyValue.lower() == "ppp") {
02503                                         if (keyValue.lower() == "noauth") {
02504                                             connection->pppConfig.requireServerAuthentication = !(dataValue2.toBool());
02505                                         }
02506                                         else if (keyValue.lower() == "refuse-eap") {
02507                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableEAP;
02508                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableEAP;
02509                                         }
02510                                         else if (keyValue.lower() == "refuse-pap") {
02511                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisablePAP;
02512                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisablePAP;
02513                                         }
02514                                         else if (keyValue.lower() == "refuse-chap") {
02515                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableCHAP;
02516                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableCHAP;
02517                                         }
02518                                         else if (keyValue.lower() == "refuse-mschap") {
02519                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableMSCHAP;
02520                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAP;
02521                                         }
02522                                         else if (keyValue.lower() == "refuse-mschapv2") {
02523                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::DisableMSCHAPv2;
02524                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAPv2;
02525                                         }
02526                                         else if (keyValue.lower() == "nobsdcomp") {
02527                                             if (dataValue2.toBool())    connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowBSDCompression;
02528                                             else                connection->pppConfig.flags |=  TDENetworkPPPFlags::AllowBSDCompression;
02529                                         }
02530                                         else if (keyValue.lower() == "nodeflate") {
02531                                             if (dataValue2.toBool())    connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowDeflateCompression;
02532                                             else                connection->pppConfig.flags |=  TDENetworkPPPFlags::AllowDeflateCompression;
02533                                         }
02534                                         else if (keyValue.lower() == "no-vj-comp") {
02535                                             if (dataValue2.toBool())    connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowVJCompression;
02536                                             else                connection->pppConfig.flags |=  TDENetworkPPPFlags::AllowVJCompression;
02537                                         }
02538                                         else if (keyValue.lower() == "require-mppe") {
02539                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::RequireMPPE;
02540                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE;
02541                                         }
02542                                         else if (keyValue.lower() == "require-mppe-128") {
02543                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::RequireMPPE128;
02544                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE128;
02545                                         }
02546                                         else if (keyValue.lower() == "mppe-stateful") {
02547                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::StatefulMPPE;
02548                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::StatefulMPPE;
02549                                         }
02550                                         else if (keyValue.lower() == "crtscts") {
02551                                             if (dataValue2.toBool())    connection->pppConfig.flags |=  TDENetworkPPPFlags::UseHardwareFlowControl;
02552                                             else                connection->pppConfig.flags &= ~TDENetworkPPPFlags::UseHardwareFlowControl;
02553                                         }
02554                                         else if (keyValue.lower() == "baud") {
02555                                             connection->pppConfig.baudRate = dataValue2.toUInt32();
02556                                         }
02557                                         else if (keyValue.lower() == "mru") {
02558                                             connection->pppConfig.mru = dataValue2.toUInt32();
02559                                         }
02560                                         else if (keyValue.lower() == "mtu") {
02561                                             connection->pppConfig.mtu = dataValue2.toUInt32();
02562                                         }
02563                                         else if (keyValue.lower() == "lcp-echo-interval") {
02564                                             connection->pppConfig.lcpEchoPingInterval = dataValue2.toUInt32();
02565                                         }
02566                                         else if (keyValue.lower() == "lcp-echo-failure") {
02567                                             connection->pppConfig.lcpEchoFailureThreshold = dataValue2.toUInt32();
02568                                         }
02569                                         connection->pppConfig.valid = true;
02570                                     }
02571                                     else if (outerKeyValue.lower() == "pppoe") {
02572                                         if (keyValue.lower() == "service") {
02573                                             connection->pppoeConfig.networkServiceProvider = dataValue2.toString();
02574                                         }
02575                                         else if (keyValue.lower() == "username") {
02576                                             connection->pppoeConfig.username = dataValue2.toString();
02577                                         }
02578                                         else if (keyValue.lower() == "password-flags") {
02579                                             connection->pppoeConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02580                                         }
02581                                         connection->pppoeConfig.secretsValid = true;
02582                                     }
02583                                     else if ((outerKeyValue.lower() == "802-11-olpc-mesh") && (olpcMeshConnection)) {
02584                                         if (keyValue.lower() == "ssid") {
02585                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02586                                             TQT_DBusDataValueList::const_iterator it4;
02587                                             int count = 0;
02588                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02589                                                 TQT_DBusData innerDataValue = *it4;
02590                                                 olpcMeshConnection->SSID.resize(count+1);
02591                                                 olpcMeshConnection->SSID[count] = innerDataValue.toByte();
02592                                                 count++;
02593                                             }
02594                                         }
02595                                         else if (keyValue.lower() == "channel") {
02596                                             olpcMeshConnection->channel = dataValue2.toUInt32();
02597                                         }
02598                                         else if (keyValue.lower() == "dhcp-anycast-address") {
02599                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02600                                             TQT_DBusDataValueList::const_iterator it4;
02601                                             int count = 0;
02602                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02603                                                 TQT_DBusData innerDataValue = *it4;
02604                                                 olpcMeshConnection->anycastDHCPHWAddress.resize(count+1);
02605                                                 olpcMeshConnection->anycastDHCPHWAddress[count] = innerDataValue.toByte();
02606                                                 count++;
02607                                             }
02608                                         }
02609                                     }
02610                                     else if ((outerKeyValue.lower() == "bluetooth") && (bluetoothConnection)) {
02611                                         if (keyValue.lower() == "bdaddr") {
02612                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02613                                             TQT_DBusDataValueList::const_iterator it4;
02614                                             TDENetworkByteList macAddress;
02615                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02616                                                 TQT_DBusData innerDataValue = *it4;
02617                                                 macAddress.append(innerDataValue.toByte());
02618                                             }
02619                                             connection->lockedHWAddress.setAddress(macAddress);
02620                                         }
02621                                         else if (keyValue.lower() == "type") {
02622                                             bluetoothConnection->type = nmBluetoothModeToTDEBluetoothMode(dataValue2.toString());
02623                                         }
02624                                     }
02625                                     else if ((outerKeyValue.lower() == "cdma") && (modemConnection)) {
02626                                         if (keyValue.lower() == "number") {
02627                                             modemConnection->cdmaConfig.providerDataNumber = dataValue2.toString();
02628                                         }
02629                                         else if (keyValue.lower() == "username") {
02630                                             modemConnection->cdmaConfig.username = dataValue2.toString();
02631                                         }
02632                                         else if (keyValue.lower() == "password-flags") {
02633                                             modemConnection->cdmaConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02634                                         }
02635                                         modemConnection->type = TDEModemConnectionType::CDMA;
02636                                         modemConnection->cdmaConfig.valid = true;
02637                                     }
02638                                     else if ((outerKeyValue.lower() == "gsm") && (modemConnection)) {
02639                                         if (keyValue.lower() == "number") {
02640                                             modemConnection->gsmConfig.providerDataNumber = dataValue2.toString();
02641                                         }
02642                                         else if (keyValue.lower() == "username") {
02643                                             modemConnection->gsmConfig.username = dataValue2.toString();
02644                                         }
02645                                         else if (keyValue.lower() == "password-flags") {
02646                                             modemConnection->gsmConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02647                                         }
02648                                         else if (keyValue.lower() == "apn") {
02649                                             modemConnection->gsmConfig.accessPointName = dataValue2.toString();
02650                                         }
02651                                         else if (keyValue.lower() == "network-id") {
02652                                             modemConnection->gsmConfig.networkID = dataValue2.toString();
02653                                         }
02654                                         else if (keyValue.lower() == "network-type") {
02655                                             modemConnection->gsmConfig.networkType = nmGSMModeToTDEGSMMode(dataValue2.toInt32());
02656                                         }
02657                                         else if (keyValue.lower() == "pin-flags") {
02658                                             modemConnection->gsmConfig.pinFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
02659                                         }
02660                                         else if (keyValue.lower() == "allowed-bands") {
02661                                             modemConnection->gsmConfig.allowedFrequencyBands = dataValue2.toUInt32();
02662                                         }
02663                                         else if (keyValue.lower() == "home-only") {
02664                                             modemConnection->gsmConfig.allowRoaming = !dataValue2.toBool();
02665                                         }
02666                                         modemConnection->type = TDEModemConnectionType::GSM;
02667                                         modemConnection->gsmConfig.valid = true;
02668                                     }
02669                                     else if (outerKeyValue.lower() == "ipv4") {
02670                                         if (keyValue.lower() == "addresses") {
02671                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02672                                             TQT_DBusDataValueList::const_iterator it4;
02673                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02674                                                 TQT_DBusData innerDataValue = *it4;
02675                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
02676                                                 TQT_DBusDataValueList::const_iterator it5;
02677                                                 state = 0;
02678                                                 TDENetworkSingleIPConfiguration ipConfig;
02679                                                 for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
02680                                                     TQT_DBusData innerMostDataValue = *it5;
02681                                                     if (state == 0) {
02682                                                         // Address
02683                                                         ipConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
02684                                                     }
02685                                                     else if (state == 1) {
02686                                                         // Network mask
02687                                                         ipConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
02688                                                     }
02689                                                     else if (state == 2) {
02690                                                         // Gateway
02691                                                         ipConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
02692                                                     }
02693                                                     state++;
02694                                                 }
02695                                                 ipConfig.valid = true;
02696                                                 connection->ipConfig.ipConfigurations.append(ipConfig);
02697                                             }
02698                                         }
02699                                         else if (keyValue.lower() == "dhcp-client-id") {
02700                                             connection->ipConfig.dhcpClientIdentifier = dataValue2.toString();
02701                                         }
02702                                         else if (keyValue.lower() == "dns") {
02703                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02704                                             TQT_DBusDataValueList::const_iterator it4;
02705                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02706                                                 TQT_DBusData innerDataValue = *it4;
02707                                                 connection->ipConfig.resolvers.append(TQHostAddress(reverseIPV4ByteOrder(innerDataValue.toUInt32())));
02708                                             }
02709                                         }
02710                                         else if (keyValue.lower() == "dns-search") {
02711                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02712                                             TQT_DBusDataValueList::const_iterator it4;
02713                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02714                                                 TQT_DBusData innerDataValue = *it4;
02715                                                 connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), false));
02716                                             }
02717                                         }
02718                                         else if (keyValue.lower() == "ignore-auto-dns") {
02719                                             bool nm_static_dns = dataValue2.toBool();
02720                                             if (nm_static_dns) {
02721                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
02722                                             }
02723                                             else {
02724                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
02725                                             }
02726                                         }
02727                                         else if (keyValue.lower() == "may-fail") {
02728                                             bool nm_may_fail = dataValue2.toBool();
02729                                             connection->requireIPV4 = !nm_may_fail;
02730                                         }
02731                                         else if (keyValue.lower() == "method") {
02732                                             TQString nm_method = dataValue2.toString().lower();
02733                                             if (nm_method == "auto") {
02734                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPIP;
02735                                             }
02736                                             else if (nm_method == "manual") {
02737                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPIP;
02738                                             }
02739                                             else if (nm_method == "link-local") {
02740                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4LocalOnly;
02741                                             }
02742                                             else if (nm_method == "shared") {
02743                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer;
02744                                             }
02745                                             else if (nm_method == "disabled") {
02746                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4Disabled;
02747                                             }
02748                                         }
02749                                         else if (keyValue.lower() == "ignore-auto-routes") {
02750                                             bool nm_static_routes = dataValue2.toBool();
02751                                             if (nm_static_routes) {
02752                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
02753                                             }
02754                                             else {
02755                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
02756                                             }
02757                                         }
02758                                         else if (keyValue.lower() == "never-default") {
02759                                             bool nm_can_default_route = !dataValue2.toBool();
02760                                             if (nm_can_default_route) {
02761                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
02762                                             }
02763                                             else {
02764                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
02765                                             }
02766                                         }
02767                                         else if (keyValue.lower() == "routes") {
02768                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02769                                             TQT_DBusDataValueList::const_iterator it4;
02770                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02771                                                 TQT_DBusData innerDataValue = *it4;
02772                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
02773                                                 TQT_DBusDataValueList::const_iterator it5;
02774                                                 state = 0;
02775                                                 TDENetworkSingleRouteConfiguration routeConfig;
02776                                                 for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
02777                                                     TQT_DBusData innerMostDataValue = *it5;
02778                                                     if (state == 0) {
02779                                                         // Address
02780                                                         routeConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
02781                                                     }
02782                                                     else if (state == 1) {
02783                                                         // Network mask
02784                                                         routeConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
02785                                                     }
02786                                                     else if (state == 2) {
02787                                                         // Gateway
02788                                                         routeConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
02789                                                     }
02790                                                     else if (state == 3) {
02791                                                         // Metric
02792                                                         routeConfig.metric = innerMostDataValue.toUInt32();
02793                                                     }
02794                                                     state++;
02795                                                 }
02796                                                 routeConfig.valid = true;
02797                                                 connection->ipConfig.routeConfigurations.append(routeConfig);
02798                                             }
02799                                         }
02800                                         connection->ipConfig.valid = true;
02801                                     }
02802                                     else if (outerKeyValue.lower() == "ipv6") {
02803                                         if (keyValue.lower() == "addresses") {
02804                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02805                                             TQT_DBusDataValueList::const_iterator it4;
02806                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02807                                                 TQT_DBusData innerDataValue = *it4;
02808                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
02809                                                 TQT_DBusDataValueList::const_iterator it5;
02810                                                 TDENetworkSingleIPConfiguration ipConfig;
02811                                                 // Address
02812                                                 TQT_DBusDataValueList innerMostValueList;
02813                                                 innerMostValueList = innerValueList[0].toTQValueList();
02814                                                 TQ_UINT8 nm_v6address[16];
02815                                                 unsigned char nm_addr_ptr = 0;
02816                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02817                                                 for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
02818                                                     TQT_DBusData innerMostDataValue = *it5;
02819                                                     if (nm_addr_ptr < 16) {
02820                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02821                                                         nm_addr_ptr++;
02822                                                     }
02823                                                 }
02824                                                 ipConfig.ipAddress = TQHostAddress(nm_v6address);
02825 
02826                                                 // Netmask
02827                                                 ipConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);
02828 
02829                                                 // Gateway
02830                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02831                                                 for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
02832                                                     TQT_DBusData innerMostDataValue = *it5;
02833                                                     if (nm_addr_ptr < 16) {
02834                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02835                                                         nm_addr_ptr++;
02836                                                     }
02837                                                 }
02838                                                 ipConfig.gateway = TQHostAddress(nm_v6address);
02839 
02840                                                 ipConfig.valid = true;
02841                                                 connection->ipConfig.ipConfigurations.append(ipConfig);
02842                                             }
02843                                         }
02844                                         else if (keyValue.lower() == "dns") {
02845                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02846                                             TQT_DBusDataValueList::const_iterator it4;
02847                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02848                                                 TQT_DBusData innerDataValue = *it4;
02849                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
02850                                                 TQT_DBusDataValueList::const_iterator it5;
02851                                                 TQ_UINT8 nm_v6address[16];
02852                                                 unsigned char nm_addr_ptr = 0;
02853                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02854                                                 for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
02855                                                     TQT_DBusData innerMostDataValue = *it5;
02856                                                     if (nm_addr_ptr < 16) {
02857                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02858                                                         nm_addr_ptr++;
02859                                                     }
02860                                                 }
02861                                                 connection->ipConfig.resolvers.append(TQHostAddress(nm_v6address));
02862                                             }
02863                                         }
02864                                         else if (keyValue.lower() == "dns-search") {
02865                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02866                                             TQT_DBusDataValueList::const_iterator it4;
02867                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02868                                                 TQT_DBusData innerDataValue = *it4;
02869                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
02870                                                 TQT_DBusDataValueList::const_iterator it5;
02871                                                 connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), true));
02872                                             }
02873                                         }
02874                                         else if (keyValue.lower() == "ignore-auto-dns") {
02875                                             bool nm_static_dns = dataValue2.toBool();
02876                                             if (nm_static_dns) {
02877                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
02878                                             }
02879                                             else {
02880                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
02881                                             }
02882                                         }
02883                                         else if (keyValue.lower() == "may-fail") {
02884                                             bool nm_may_fail = dataValue2.toBool();
02885                                             connection->requireIPV6 = !nm_may_fail;
02886                                         }
02887                                         else if (keyValue.lower() == "method") {
02888                                             TQString nm_method = dataValue2.toString().lower();
02889                                             if (nm_method == "auto") {
02890                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPIP;
02891                                             }
02892                                             else if (nm_method == "manual") {
02893                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPIP;
02894                                             }
02895                                             else if (nm_method == "link-local") {
02896                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6LocalOnly;
02897                                             }
02898                                             else if (nm_method == "shared") {
02899                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer;
02900                                             }
02901                                             else if (nm_method == "ignore") {
02902                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6Disabled;
02903                                             }
02904                                         }
02905                                         else if (keyValue.lower() == "ignore-auto-routes") {
02906                                             bool nm_static_routes = dataValue2.toBool();
02907                                             if (nm_static_routes) {
02908                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
02909                                             }
02910                                             else {
02911                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
02912                                             }
02913                                         }
02914                                         else if (keyValue.lower() == "never-default") {
02915                                             bool nm_can_default_route = !dataValue2.toBool();
02916                                             if (nm_can_default_route) {
02917                                                 connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
02918                                             }
02919                                             else {
02920                                                 connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
02921                                             }
02922                                         }
02923                                         else if (keyValue.lower() == "routes") {
02924                                             TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
02925                                             TQT_DBusDataValueList::const_iterator it4;
02926                                             for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
02927                                                 TQT_DBusData innerDataValue = *it4;
02928                                                 TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
02929                                                 TQT_DBusDataValueList::const_iterator it5;
02930                                                 TDENetworkSingleRouteConfiguration routeConfig;
02931                                                 // Address
02932                                                 TQT_DBusDataValueList innerMostValueList;
02933                                                 innerMostValueList = innerValueList[0].toTQValueList();
02934                                                 TQ_UINT8 nm_v6address[16];
02935                                                 unsigned char nm_addr_ptr = 0;
02936                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02937                                                 for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
02938                                                     TQT_DBusData innerMostDataValue = *it5;
02939                                                     if (nm_addr_ptr < 16) {
02940                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02941                                                         nm_addr_ptr++;
02942                                                     }
02943                                                 }
02944                                                 routeConfig.ipAddress = TQHostAddress(nm_v6address);
02945 
02946                                                 // Netmask
02947                                                 routeConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);
02948 
02949                                                 // Gateway
02950                                                 innerMostValueList = innerValueList[2].toTQValueList();
02951                                                 nm_addr_ptr = 0;
02952                                                 memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
02953                                                 for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
02954                                                     TQT_DBusData innerMostDataValue = *it5;
02955                                                     if (nm_addr_ptr < 16) {
02956                                                         nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
02957                                                         nm_addr_ptr++;
02958                                                     }
02959                                                 }
02960                                                 routeConfig.gateway = TQHostAddress(nm_v6address);
02961 
02962                                                 // Metric
02963                                                 routeConfig.metric = innerValueList[3].toUInt32();
02964 
02965                                                 routeConfig.valid = true;
02966                                                 connection->ipConfig.routeConfigurations.append(routeConfig);
02967                                             }
02968                                         }
02969                                         connection->ipConfig.valid = true;
02970                                     }
02971                                 }
02972                                 else {
02973                                     // FIXME
02974                                     // There are several advanced properties which appear to use string maps
02975                                     // For example, s390-options
02976                                     // Support should eventually be added for these, e.g. in a backend-specific Advanced tab somewhere
02977                                 }
02978                             }
02979                         }
02980                     }
02981 
02982                     // If the connection's MAC matches my MAC, or if the connection is not locked to any MAC address,
02983                     // or if this manager object is not locked to a device, then add this connection to the list
02984                     if ((deviceMACAddress == connection->lockedHWAddress) || (!connection->lockedHWAddress.isValid()) || (!deviceMACAddress.isValid())) {
02985                         loadConnectionAllowedValues(connection);
02986                         m_connectionList->append(connection);
02987                     }
02988                 }
02989                 else {
02990                     // Error!
02991                     PRINT_ERROR((error.name() + ": " + error.message()))
02992                 }
02993             }
02994         }
02995         else {
02996             // Error!
02997             PRINT_ERROR((error.name() + ": " + error.message()))
02998         }
02999         internalNetworkManagementEvent(TDENetworkGlobalEventType::ConnectionListChanged);
03000     }
03001 
03002     d->nonReentrantCallActive = false;
03003 }
03004 
03005 void TDENetworkConnectionManager_BackendNM::loadConnectionAllowedValues(TDENetworkConnection* connection) {
03006     if (connection) {
03007         // Insert all allowed EAP phase 2 methods
03008         connection->eapConfig.allowedPhase2NonEAPMethods.clear();
03009         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MD5);
03010         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
03011         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::OTP);
03012         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::GTC);
03013         connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::TLS);
03014 
03015         connection->eapConfig.allowedPhase2EAPMethods.clear();
03016         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::PAP);
03017         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::CHAP);
03018         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAP);
03019         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
03020         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::OTP);
03021         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::GTC);
03022         connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::TLS);
03023 
03024         connection->eapConfig.allowedValid = true;
03025     }
03026 }
03027 
03028 // NOTE
03029 // While this separate separate routine is needed to get the secrets, note that secrets must
03030 // be saved using the same connection map save routine that all other settings use above.
03031 bool TDENetworkConnectionManager_BackendNM::loadConnectionSecrets(TQString uuid) {
03032     TDENetworkConnection* connection = findConnectionByUUID(uuid);
03033     if (!connection) {
03034         PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database.  Did you run loadConnectionInformation() first?"));
03035         return FALSE;
03036     }
03037     //TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
03038     //TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
03039     TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
03040     TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
03041     //TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
03042     //TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
03043     //TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
03044     //TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
03045     TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
03046 
03047     bool ret = TRUE;
03048     ret = ret && loadConnectionSecretsForGroup(uuid, "802-1x");
03049     if (wiFiConnection) {
03050         ret = ret && loadConnectionSecretsForGroup(uuid, "802-11-wireless-security");
03051     }
03052     if (vpnConnection) {
03053         ret = ret && loadConnectionSecretsForGroup(uuid, "vpn");
03054     }
03055     ret = ret && loadConnectionSecretsForGroup(uuid, "pppoe");
03056     if (modemConnection) {
03057         ret = ret && loadConnectionSecretsForGroup(uuid, "cdma");
03058         ret = ret && loadConnectionSecretsForGroup(uuid, "gsm");
03059     }
03060     return ret;
03061 }
03062 
03063 bool TDENetworkConnectionManager_BackendNM::loadConnectionSecretsForGroup(TQString uuid, TQString group) {
03064     TDENetworkConnection* connection = findConnectionByUUID(uuid);
03065     if (!connection) {
03066         PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database.  Did you run loadConnectionInformation() first?"));
03067         return FALSE;
03068     }
03069     //TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
03070     //TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
03071     TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
03072     TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
03073     //TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
03074     //TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
03075     //TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
03076     //TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
03077     TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
03078     TQT_DBusObjectPath existingConnection;
03079     TQT_DBusError error;
03080     bool ret;
03081     TQT_DBusTQStringDataMap connectionSecretsMap(TQT_DBusData::String);
03082     ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
03083     if (ret) {
03084 #ifndef USE_ASYNC_DBUS_CALLS
03085         // Obtain connection settings from the path specified
03086         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
03087         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
03088         ret = connectionSettings.GetSecrets(group, connectionSecretsMap, error);
03089         if (ret && error.isValid()) {
03090             ret = 0;
03091             PRINT_ERROR((error.name() + ": " + error.message()))
03092         }
03093         if (ret) {
03094 #else // USE_ASYNC_DBUS_CALLS
03095         // Obtain connection secrets from the path specified
03096         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
03097         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
03098         connect(&connectionSettings, SIGNAL(GetSecretsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
03099         int asyncCallID;
03100         ret = connectionSettings.GetSecretsAsync(asyncCallID, group, error);
03101         if (ret && error.isValid()) {
03102             ret = 0;
03103             PRINT_ERROR((error.name() + ": " + error.message()))
03104         }
03105         if (ret) {
03106             // Wait for the asynchronous call to return...
03107             d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
03108             TQTimer nmCallTimeoutTimer;
03109             nmCallTimeoutTimer.start(NM_ASYNC_SECRETS_INTERACTION_TIMEOUT_MS, TRUE);
03110             while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
03111                 tqApp->processEvents();
03112                 if (!nmCallTimeoutTimer.isActive()) {
03113                     PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
03114                     break;
03115                 }
03116             }
03117             connectionSecretsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
03118             if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
03119                 PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
03120                 d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
03121             }
03122             d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
03123             if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
03124                 d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
03125             }
03126 #endif // USE_ASYNC_DBUS_CALLS
03127 
03128 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03129             printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
03130             printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSecretsMap));
03131 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03132 
03133             // Parse settings
03134             TQT_DBusTQStringDataMap::const_iterator it2;
03135             for (it2 = connectionSecretsMap.begin(); it2 != connectionSecretsMap.end(); ++it2) {
03136                 TQString outerKeyValue = it2.key();
03137                 TQT_DBusData dataValue = it2.data();
03138 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03139                 printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
03140 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03141                 TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
03142                 TQT_DBusTQStringDataMap::const_iterator it3;
03143                 for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
03144                     TQString keyValue = it3.key();
03145                     TQT_DBusData dataValue = it3.data();
03146                     if (dataValue.type() != TQT_DBusData::Variant) {
03147 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03148                         printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
03149 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03150                         // No NM settings are known which use this style
03151                     }
03152                     else {
03153                         TQT_DBusVariant dataValueVariant = dataValue.toVariant();
03154                         TQT_DBusData dataValue2 = dataValueVariant.value;
03155                         if (dataValue2.type() != TQT_DBusData::Variant) {
03156 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03157                             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);
03158 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
03159                             // Most NM settings use this style
03160                             if (outerKeyValue.lower() == "802-1x") {
03161                                 if (keyValue.lower() == "password") {
03162                                     connection->eapConfig.password = dataValue2.toString();
03163                                 }
03164                                 else if (keyValue.lower() == "password-raw") {
03165                                     TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
03166                                     TQT_DBusDataValueList::const_iterator it4;
03167                                     int count=0;
03168                                     for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
03169                                         TQT_DBusData innerDataValue = *it4;
03170                                         count++;
03171                                         connection->eapConfig.binaryPassword.resize(count+1);
03172                                         connection->eapConfig.binaryPassword[count] = innerDataValue.toByte();
03173                                     }
03174                                 }
03175                                 else if (keyValue.lower() == "private-key-password") {
03176                                     connection->eapConfig.privateKeyPassword = dataValue2.toString();
03177                                 }
03178                                 else if (keyValue.lower() == "phase2-private-key-password") {
03179                                     connection->eapConfig.phase2PrivateKeyPassword = dataValue2.toString();
03180                                 }
03181                                 connection->eapConfig.secretsValid = true;
03182                             }
03183                             if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
03184                                 if (keyValue.lower() == "wep-key0") {
03185                                     wiFiConnection->securitySettings.wepKey0 = dataValue2.toString();
03186                                     wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey0);
03187                                 }
03188                                 else if (keyValue.lower() == "wep-key1") {
03189                                     wiFiConnection->securitySettings.wepKey1 = dataValue2.toString();
03190                                     wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey1);
03191                                 }
03192                                 else if (keyValue.lower() == "wep-key2") {
03193                                     wiFiConnection->securitySettings.wepKey2 = dataValue2.toString();
03194                                     wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey2);
03195                                 }
03196                                 else if (keyValue.lower() == "wep-key3") {
03197                                     wiFiConnection->securitySettings.wepKey3 = dataValue2.toString();
03198                                     wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey3);
03199                                 }
03200                                 else if (keyValue.lower() == "psk") {
03201                                     wiFiConnection->securitySettings.psk = dataValue2.toString();
03202                                 }
03203                                 else if (keyValue.lower() == "eap-password") {
03204                                     wiFiConnection->securitySettings.leapPassword = dataValue2.toString();
03205                                 }
03206                             }
03207                             if ((outerKeyValue.lower() == "vpn") && (vpnConnection)) {
03208                                 if (keyValue.lower() == "secrets") {
03209                                     TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
03210                                     TQT_DBusTQStringDataMap::const_iterator it4;
03211                                     for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
03212                                         vpnConnection->pluginSecrets.clear();
03213                                         TQString keyValue4 = it4.key();
03214                                         TQT_DBusData dataValue4 = it4.data();
03215                                         if (dataValue4.type() == TQT_DBusData::String) {
03216                                             vpnConnection->pluginSecrets[keyValue4] = dataValue4.toString();
03217                                         }
03218                                     }
03219                                     vpnConnection->secretsValid = true;
03220                                 }
03221                             }
03222                             if (outerKeyValue.lower() == "pppoe") {
03223                                 if (keyValue.lower() == "password") {
03224                                     connection->pppoeConfig.password = dataValue2.toString();
03225                                 }
03226                                 connection->pppoeConfig.secretsValid = true;
03227                             }
03228                             if (outerKeyValue.lower() == "cdma") {
03229                                 if (keyValue.lower() == "password") {
03230                                     modemConnection->cdmaConfig.password = dataValue2.toString();
03231                                 }
03232                                 modemConnection->cdmaConfig.secretsValid = true;
03233                             }
03234                             if (outerKeyValue.lower() == "gsm") {
03235                                 if (keyValue.lower() == "password") {
03236                                     modemConnection->gsmConfig.password = dataValue2.toString();
03237                                 }
03238                                 else if (keyValue.lower() == "pin") {
03239                                     modemConnection->gsmConfig.pin = dataValue2.toString();
03240                                 }
03241                                 modemConnection->gsmConfig.secretsValid = true;
03242                             }
03243                         }
03244                     }
03245                 }
03246             }
03247             return TRUE;
03248         }
03249         else {
03250             PRINT_ERROR(TQString("Unable to load secrets for connection with uuid '%1'").arg(uuid))
03251             return FALSE;
03252         }
03253     }
03254     else {
03255         PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
03256         return FALSE;
03257     }
03258 }
03259 
03260 bool TDENetworkConnectionManager_BackendNM::saveConnection(TDENetworkConnection* connection) {
03261     bool timed_out = FALSE;
03262     bool command_failed = FALSE;
03263 
03264     if (!connection) {
03265         PRINT_ERROR(TQString("connection cannot be NULL!"));
03266         return FALSE;
03267     }
03268 
03269     // If the UUID is blank, generate a new UUID for this connection and also guarantee that it it truly unique
03270     if (connection->UUID == "") {
03271         bool unique = false;
03272         while (!unique) {
03273             connection->UUID = TQUuid::createUuid().toString();
03274             connection->UUID.replace("{", "");
03275             connection->UUID.replace("}", "");
03276             if (!findConnectionByUUID(connection->UUID)) {
03277                 unique = true;
03278             }
03279         }
03280     }
03281 
03282     // Find path for connection with specified UUID, if it exists
03283     // This is so that any settings that we are not aware of can be loaded now and preserved through the update operation
03284     TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
03285     TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
03286     TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
03287     TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
03288     TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
03289     TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
03290     TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEOLPCMeshConnection*>(connection);
03291     TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
03292     TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
03293     TQT_DBusObjectPath existingConnection;
03294     TQT_DBusError error;
03295     bool ret;
03296     bool existing;
03297     TQT_DBusTQStringDataMap connectionSettingsMap(TQT_DBusData::String);
03298     existing = false;
03299     ret = d->m_networkManagerSettings->GetConnectionByUuid(connection->UUID, existingConnection, error);
03300     if (ret) {
03301 #ifndef USE_ASYNC_DBUS_CALLS
03302         // Obtain connection settings from the path specified
03303         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
03304         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
03305         ret = connectionSettings.GetSettings(connectionSettingsMap, error);
03306         if (ret && error.isValid()) {
03307             ret = 0;
03308             PRINT_ERROR((error.name() + ": " + error.message()))
03309         }
03310         if (ret) {
03311 #else // USE_ASYNC_DBUS_CALLS
03312         // Obtain connection settings from the path specified
03313         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
03314         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
03315         connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
03316         int asyncCallID;
03317         ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
03318         if (ret && error.isValid()) {
03319             ret = 0;
03320             PRINT_ERROR((error.name() + ": " + error.message()))
03321         }
03322         if (ret) {
03323             // Wait for the asynchronous call to return...
03324             d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
03325             TQTimer nmCallTimeoutTimer;
03326             nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
03327             while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
03328                 tqApp->processEvents();
03329                 if (!nmCallTimeoutTimer.isActive()) {
03330                     PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
03331                     timed_out = true;
03332                     break;
03333                 }
03334             }
03335             connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
03336             if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
03337                 PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
03338                 d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
03339             }
03340             d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
03341             if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
03342                 d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
03343             }
03344 #endif // USE_ASYNC_DBUS_CALLS
03345             existing = true;
03346         }
03347     }
03348 
03349     // Create and/or update settings map from provided connection information
03350     // We start at the outermost layer and work our way inwards, in a structure which should match the parser in loadConnectionInformation() very closely
03351     bool groupValid;
03352     TQT_DBusData dbusData;
03353     TQT_DBusData innerDbusData;
03354     TQMap<TQString, TQT_DBusData> outerMap = connectionSettingsMap.toTQMap();
03355     {
03356         groupValid = false;
03357         dbusData = outerMap["connection"];
03358         {
03359             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03360             {
03361                 settingsMap["id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->friendlyName));
03362                 {
03363                     TQString type;
03364                     if (ethernetConnection) type = "802-3-ethernet";
03365                     else if (infinibandConnection) type = "infiniband";
03366                     else if (wiFiConnection) type = "802-11-wireless";
03367                     else if (vpnConnection) type = "vpn";
03368                     else if (wiMaxConnection) type = "wimax";
03369                     else if (vlanConnection) type = "vlan";
03370                     else if (olpcMeshConnection) type = "802-11-olpc-mesh";
03371                     else if (bluetoothConnection) type = "bluetooth";
03372                     else if (modemConnection) {
03373                         if (modemConnection->type == TDEModemConnectionType::CDMA) {
03374                             type = "cdma";
03375                         }
03376                         else if (modemConnection->type == TDEModemConnectionType::GSM) {
03377                             type = "gsm";
03378                         }
03379                     }
03380                     if (!type.isNull()) settingsMap["type"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(type));
03381                 }
03382                 settingsMap["uuid"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->UUID));
03383                 {
03384                     TQT_DBusDataValueList valueList;
03385                     {
03386                         for (TQStringList::Iterator it = connection->authorizedUsers.begin(); it != connection->authorizedUsers.end(); ++it) {
03387                             TQString assembledString = TQString("user:%1:").arg(*it);
03388                             valueList.append(TQT_DBusData::fromString(assembledString));
03389                         }
03390                     }
03391                     if (valueList.count() > 0) settingsMap["permissions"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03392                     else settingsMap.remove("permissions");
03393                 }
03394                 settingsMap["autoconnect"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->autoConnect));
03395                 settingsMap["read-only"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->readOnly));
03396                 UPDATE_STRING_SETTING_IF_VALID(connection->masterConnectionUUID, "master", settingsMap)
03397                 {
03398                     TQString slaveType = tdeSlaveTypeToNMSlaveType(connection->slaveType);
03399                     if (slaveType != "") settingsMap["slave-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(slaveType));
03400                     else settingsMap.remove("slave-type");
03401                 }
03402                 // settingsMap["timestamp"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt64(connection->lastKnownConnection.toTime_t()));   // Probably read-only to us
03403             }
03404             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03405             groupValid = (settingsMap.count() > 0);
03406         }
03407         if (groupValid) outerMap.insert("connection", dbusData, TRUE); else outerMap.remove("connection");
03408 
03409         groupValid = false;
03410         dbusData = outerMap["802-1x"];
03411         {
03412             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03413             {
03414                 if (connection->eapConfig.valid) {
03415                     TQT_DBusDataValueList valueList;
03416                     {
03417                         // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
03418                         // EAP type
03419                         valueList.append(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.type)));
03420                     }
03421                     settingsMap["eap"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03422                 }
03423                 else {
03424                     settingsMap.remove("eap");
03425                 }
03426                 if (connection->eapConfig.valid) {
03427                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.userName, "identity", settingsMap)
03428                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.anonymousUserName, "anonymous-identity", settingsMap)
03429                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.pacFileName, "pac-file", settingsMap)
03430                 }
03431                 else {
03432                     settingsMap.remove("identity");
03433                     settingsMap.remove("anonymous-identity");
03434                     settingsMap.remove("pac-file");
03435                 }
03436                 if (connection->eapConfig.valid) {
03437                     TQT_DBusDataValueList valueList;
03438                     {
03439                         unsigned int count;
03440                         for (count=0; count<connection->eapConfig.caCertificate.count(); count++) {
03441                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.caCertificate[count]));
03442                         }
03443                     }
03444                     if (valueList.count() > 0) settingsMap["ca-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03445                     else settingsMap.remove("ca-cert");
03446                 }
03447                 else {
03448                     settingsMap.remove("ca-cert");
03449                 }
03450                 if (connection->eapConfig.valid) {
03451                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.additionalCAFilesPath, "ca-path", settingsMap)
03452                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.authServerCertSubjectMatch, "subject-match", settingsMap)
03453                 }
03454                 else {
03455                     settingsMap.remove("ca-path");
03456                     settingsMap.remove("subject-match");
03457                 }
03458                 if (connection->eapConfig.valid) {
03459                     TQT_DBusDataValueList valueList;
03460                     {
03461                         for (TQStringList::Iterator it = connection->eapConfig.alternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.alternateAuthServerCertSubjectMatch.end(); ++it) {
03462                             valueList.append(TQT_DBusData::fromString(*it));
03463                         }
03464                     }
03465                     if (valueList.count() > 0) settingsMap["altsubject-matches"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03466                     else settingsMap.remove("altsubject-matches");
03467                 }
03468                 else {
03469                     settingsMap.remove("altsubject-matches");
03470                 }
03471                 if (connection->eapConfig.valid) {
03472                     TQT_DBusDataValueList valueList;
03473                     {
03474                         unsigned int count;
03475                         for (count=0; count<connection->eapConfig.clientCertificate.count(); count++) {
03476                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.clientCertificate[count]));
03477                         }
03478                     }
03479                     if (valueList.count() > 0) settingsMap["client-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03480                     else settingsMap.remove("client-cert");
03481                 }
03482                 else {
03483                     settingsMap.remove("client-cert");
03484                 }
03485                 if (connection->eapConfig.valid) {
03486                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPVersion, "phase1-peapver", settingsMap)
03487                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPLabel, "phase1-peaplabel", settingsMap)
03488                     UPDATE_STRING_SETTING_IF_VALID(tdeEAPFastFlagsToNMEAPFastFlags(connection->eapConfig.fastProvisioningFlags), "phase1-fast-provisioning", settingsMap)
03489                 }
03490                 else {
03491                     settingsMap.remove("phase1-peapver");
03492                     settingsMap.remove("phase1-peaplabel");
03493                     settingsMap.remove("phase1-fast-provisioning");
03494                 }
03495                 if (connection->eapConfig.valid) {
03496                     settingsMap["phase2-auth"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2NonEAPAuthMethod)));
03497                     settingsMap["phase2-autheap"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2EAPAuthMethod)));
03498                 }
03499                 else {
03500                     settingsMap.remove("phase2-auth");
03501                     settingsMap.remove("phase2-autheap");
03502                 }
03503                 if (connection->eapConfig.valid) {
03504                     TQT_DBusDataValueList valueList;
03505                     {
03506                         unsigned int count;
03507                         for (count=0; count<connection->eapConfig.phase2CaCertificate.count(); count++) {
03508                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2CaCertificate[count]));
03509                         }
03510                     }
03511                     if (valueList.count() > 0) settingsMap["phase2-ca-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03512                     else settingsMap.remove("phase2-ca-cert");
03513                 }
03514                 else {
03515                     settingsMap.remove("phase2-ca-cert");
03516                 }
03517                 if (connection->eapConfig.valid) {
03518                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2CaFilesPath, "phase2-ca-path", settingsMap)
03519                     UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2AuthServerCertSubjectMatch, "phase2-subject-match", settingsMap)
03520                 }
03521                 else {
03522                     settingsMap.remove("phase2-ca-path");
03523                     settingsMap.remove("phase2-subject-match");
03524                 }
03525                 if (connection->eapConfig.valid) {
03526                     TQT_DBusDataValueList valueList;
03527                     {
03528                         for (TQStringList::Iterator it = connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.end(); ++it) {
03529                             valueList.append(TQT_DBusData::fromString(*it));
03530                         }
03531                     }
03532                     if (valueList.count() > 0) settingsMap["phase2-altsubject-matches"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03533                     else settingsMap.remove("phase2-altsubject-matches");
03534                 }
03535                 else {
03536                     settingsMap.remove("phase2-altsubject-matches");
03537                 }
03538                 if (connection->eapConfig.valid) {
03539                     TQT_DBusDataValueList valueList;
03540                     {
03541                         unsigned int count;
03542                         for (count=0; count<connection->eapConfig.phase2ClientCertificate.count(); count++) {
03543                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2ClientCertificate[count]));
03544                         }
03545                     }
03546                     if (valueList.count() > 0) settingsMap["phase2-client-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03547                     else settingsMap.remove("phase2-client-cert");
03548                 }
03549                 else {
03550                     settingsMap.remove("phase2-client-cert");
03551                 }
03552                 if (connection->eapConfig.valid) {
03553                     settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.passwordFlags)));
03554                     settingsMap["password-raw-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.binaryPasswordFlags)));
03555                 }
03556                 else {
03557                     settingsMap.remove("password-flags");
03558                     settingsMap.remove("password-raw-flags");
03559                 }
03560                 if (connection->eapConfig.valid) {
03561                     TQT_DBusDataValueList valueList;
03562                     {
03563                         unsigned int count;
03564                         for (count=0; count<connection->eapConfig.privateKey.count(); count++) {
03565                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.privateKey[count]));
03566                         }
03567                     }
03568                     if (valueList.count() > 0) settingsMap["private-key"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03569                     else settingsMap.remove("private-key");
03570                 }
03571                 else {
03572                     settingsMap.remove("private-key");
03573                 }
03574                 if (connection->eapConfig.valid) {
03575                     settingsMap["private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.privateKeyPasswordFlags)));
03576                 }
03577                 else {
03578                     settingsMap.remove("private-key-password-flags");
03579                 }
03580                 if (connection->eapConfig.valid) {
03581                     TQT_DBusDataValueList valueList;
03582                     {
03583                         unsigned int count;
03584                         for (count=0; count<connection->eapConfig.phase2PrivateKey.count(); count++) {
03585                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2PrivateKey[count]));
03586                         }
03587                     }
03588                     if (valueList.count() > 0) settingsMap["phase2-private-key"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03589                     else settingsMap.remove("phase2-private-key");
03590                 }
03591                 else {
03592                     settingsMap.remove("phase2-private-key");
03593                 }
03594                 if (connection->eapConfig.valid) {
03595                     settingsMap["phase2-private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.phase2PrivateKeyPasswordFlags)));
03596                 }
03597                 else {
03598                     settingsMap.remove("phase2-private-key-password-flags");
03599                 }
03600                 if (connection->eapConfig.valid) {
03601                     settingsMap["system-ca-certs"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->eapConfig.forceSystemCaCertificates));
03602                 }
03603                 else {
03604                     settingsMap.remove("system-ca-certs");
03605                 }
03606                 if (connection->eapConfig.secretsValid) {
03607                     settingsMap["password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.password));
03608                 }
03609                 else {
03610                     settingsMap.remove("password");
03611                 }
03612                 if (connection->eapConfig.valid) {
03613                     TQT_DBusDataValueList valueList;
03614                     {
03615                         unsigned int count;
03616                         for (count=0; count<connection->eapConfig.binaryPassword.count(); count++) {
03617                             valueList.append(TQT_DBusData::fromByte(connection->eapConfig.binaryPassword[count]));
03618                         }
03619                     }
03620                     if (valueList.count() > 0) settingsMap["password-raw"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03621                     else settingsMap.remove("password-raw");
03622                 }
03623                 else {
03624                     settingsMap.remove("password-raw");
03625                 }
03626                 if (connection->eapConfig.secretsValid) {
03627                     settingsMap["private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.privateKeyPassword));
03628                     settingsMap["phase2-private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.phase2PrivateKeyPassword));
03629                 }
03630                 else {
03631                     settingsMap.remove("private-key-password");
03632                     settingsMap.remove("phase2-private-key-password");
03633                 }
03634             }
03635             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03636             groupValid = (settingsMap.count() > 0);
03637         }
03638         if (groupValid) outerMap.insert("802-1x", dbusData, TRUE); else outerMap.remove("802-1x");
03639 
03640         groupValid = false;
03641         dbusData = outerMap["802-3-ethernet"];
03642         if (ethernetConnection) {
03643             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03644             {
03645                 settingsMap["duplex"] = convertDBUSDataToVariantData(TQT_DBusData::fromString((connection->fullDuplex)?"full":"half"));
03646                 if (connection->lockedHWAddress.isValid()) {
03647                     TDENetworkByteList address = connection->lockedHWAddress.address();
03648                     TQT_DBusDataValueList valueList;
03649                     TDENetworkByteList::iterator it;
03650                     for (it = address.begin(); it != address.end(); ++it) {
03651                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03652                         valueList.append(innerDataValue);
03653                     }
03654                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03655                     settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03656                 }
03657                 else {
03658                     settingsMap.remove("mac-address");
03659                 }
03660                 if (connection->manualHWAddress.isValid()) {
03661                     TDENetworkByteList address = connection->manualHWAddress.address();
03662                     TQT_DBusDataValueList valueList;
03663                     TDENetworkByteList::iterator it;
03664                     for (it = address.begin(); it != address.end(); ++it) {
03665                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03666                         valueList.append(innerDataValue);
03667                     }
03668                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03669                     settingsMap["cloned-mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03670                 }
03671                 else {
03672                     settingsMap.remove("cloned-mac-address");
03673                 }
03674                 if (connection->mtu > 0) {
03675                     settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
03676                 }
03677                 else {
03678                     settingsMap.remove("mtu");
03679                 }
03680             }
03681             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03682             groupValid = (settingsMap.count() > 0);
03683         }
03684         if (groupValid) outerMap.insert("802-3-ethernet", dbusData, TRUE); else outerMap.remove("802-3-ethernet");
03685 
03686         groupValid = false;
03687         dbusData = outerMap["infiniband"];
03688         if (infinibandConnection) {
03689             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03690             {
03691                 if (connection->lockedHWAddress.isValid()) {
03692                     TDENetworkByteList address = connection->lockedHWAddress.address();
03693                     TQT_DBusDataValueList valueList;
03694                     TDENetworkByteList::iterator it;
03695                     for (it = address.begin(); it != address.end(); ++it) {
03696                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03697                         valueList.append(innerDataValue);
03698                     }
03699                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03700                     settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03701                 }
03702                 else {
03703                     settingsMap.remove("mac-address");
03704                 }
03705                 if (connection->mtu > 0) {
03706                     settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
03707                 }
03708                 else {
03709                     settingsMap.remove("mtu");
03710                 }
03711                 UPDATE_STRING_SETTING_IF_VALID(tdeIBTransportToNMIBTransport(infinibandConnection->transportMode), "transport-mode", settingsMap)
03712             }
03713             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03714             groupValid = (settingsMap.count() > 0);
03715         }
03716         if (groupValid) outerMap.insert("infiniband", dbusData, TRUE); else outerMap.remove("infiniband");
03717 
03718         groupValid = false;
03719         dbusData = outerMap["802-11-wireless"];
03720         if (wiFiConnection) {
03721             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03722             {
03723                 {
03724                     unsigned int i;
03725                     TQT_DBusDataValueList valueList;
03726                     for (i=0; i<wiFiConnection->SSID.count(); i++) {
03727                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(wiFiConnection->SSID[i]);
03728                         valueList.append(innerDataValue);
03729                     }
03730                     settingsMap["ssid"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03731                 }
03732                 if (connection->lockedHWAddress.isValid()) {
03733                     TDENetworkByteList address = connection->lockedHWAddress.address();
03734                     TQT_DBusDataValueList valueList;
03735                     TDENetworkByteList::iterator it;
03736                     for (it = address.begin(); it != address.end(); ++it) {
03737                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03738                         valueList.append(innerDataValue);
03739                     }
03740                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03741                     settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03742                 }
03743                 else {
03744                     settingsMap.remove("mac-address");
03745                 }
03746                 if (connection->manualHWAddress.isValid()) {
03747                     TDENetworkByteList address = connection->manualHWAddress.address();
03748                     TQT_DBusDataValueList valueList;
03749                     TDENetworkByteList::iterator it;
03750                     for (it = address.begin(); it != address.end(); ++it) {
03751                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03752                         valueList.append(innerDataValue);
03753                     }
03754                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03755                     settingsMap["cloned-mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03756                 }
03757                 else {
03758                     settingsMap.remove("cloned-mac-address");
03759                 }
03760                 if (connection->mtu > 0) {
03761                     settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
03762                 }
03763                 else {
03764                     settingsMap.remove("mtu");
03765                 }
03766                 UPDATE_STRING_SETTING_IF_VALID(tdeWiFiModeToNMWiFiMode(wiFiConnection->operatingMode), "mode", settingsMap)
03767                 UPDATE_STRING_SETTING_IF_VALID(tdeWiFiFrequencyBandToNMWiFiFrequencyBand(wiFiConnection->bandRestriction), "band", settingsMap)
03768                 if (wiFiConnection->channelRestriction > 0) {
03769                     settingsMap["channel"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->channelRestriction));
03770                 }
03771                 else {
03772                     settingsMap.remove("channel");
03773                 }
03774                 if (wiFiConnection->bitRateRestriction > 0) {
03775                     settingsMap["rate"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->bitRateRestriction/1000));
03776                 }
03777                 else {
03778                     settingsMap.remove("rate");
03779                 }
03780                 if (wiFiConnection->powerRestriction > 0) {
03781                     settingsMap["tx-power"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->powerRestriction));
03782                 }
03783                 else {
03784                     settingsMap.remove("tx-power");
03785                 }
03786                 if (wiFiConnection->accessPointRestriction.isValid()) {
03787                     TDENetworkByteList address = wiFiConnection->accessPointRestriction.address();
03788                     TQT_DBusDataValueList valueList;
03789                     TDENetworkByteList::iterator it;
03790                     for (it = address.begin(); it != address.end(); ++it) {
03791                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03792                         valueList.append(innerDataValue);
03793                     }
03794                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03795                     settingsMap["bssid"] = convertDBUSDataToVariantData(nmHWAddress);
03796                 }
03797                 else {
03798                     settingsMap.remove("bssid");
03799                 }
03800                 {
03801                     TQT_DBusDataValueList valueList;
03802                     TDEMACAddressList::iterator it;
03803                     for (it = wiFiConnection->blacklistedBSSIDs.begin(); it != wiFiConnection->blacklistedBSSIDs.end(); ++it) {
03804                         valueList.append(TQT_DBusData::fromString((*it).toString()));
03805                     }
03806                     if (valueList.count() > 0) settingsMap["mac-address-blacklist"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03807                 }
03808                 {
03809                     TQT_DBusDataValueList valueList;
03810                     TDEMACAddressList::iterator it;
03811                     for (it = wiFiConnection->heardBSSIDs.begin(); it != wiFiConnection->heardBSSIDs.end(); ++it) {
03812                         valueList.append(TQT_DBusData::fromString((*it).toString()));
03813                     }
03814                     if (valueList.count() > 0) settingsMap["seen-bssids"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03815                 }
03816                 {
03817                     if (wiFiConnection->securityRequired) {
03818                         settingsMap["security"] = convertDBUSDataToVariantData(TQT_DBusData::fromString("802-11-wireless-security"));
03819                     }
03820                     else {
03821                         settingsMap.remove("security");
03822                     }
03823                 }
03824                 {
03825                     if (wiFiConnection->isHiddenNetwork) {
03826                         settingsMap["hidden"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(true));
03827                     }
03828                     else {
03829                         settingsMap.remove("hidden");
03830                     }
03831                 }
03832             }
03833             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03834             groupValid = (settingsMap.count() > 0);
03835         }
03836         if (groupValid) outerMap.insert("802-11-wireless", dbusData, TRUE); else outerMap.remove("802-11-wireless");
03837 
03838         groupValid = false;
03839         dbusData = outerMap["802-11-wireless-security"];
03840         if (wiFiConnection) {
03841             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03842             {
03843                 if (wiFiConnection->securityRequired) {
03844                     if (wiFiConnection->securityRequired) {
03845                         settingsMap["key-mgmt"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeWiFiKeyTypeToNMWiFiKeyType(wiFiConnection->securitySettings.keyType)));
03846                     }
03847                     if (wiFiConnection->securitySettings.wepKeyIndex > 0) {
03848                         settingsMap["wep-tx-keyidx"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->securitySettings.wepKeyIndex));
03849                     }
03850                     else {
03851                         settingsMap.remove("wep-tx-keyidx");
03852                     }
03853                     UPDATE_STRING_SETTING_IF_VALID(tdeWiFiAuthTypeToNMWiFiAuthType(wiFiConnection->securitySettings.authType), "auth-alg", settingsMap)
03854                     {
03855                         TQT_DBusDataValueList valueList;
03856                         {
03857                             TQStringList strings = tdeWiFiWPAVersionToNMWiFiWPAVersion(wiFiConnection->securitySettings.wpaVersion);
03858                             for (TQStringList::Iterator it = strings.begin(); it != strings.end(); ++it) {
03859                                 valueList.append(TQT_DBusData::fromString(*it));
03860                             }
03861                         }
03862                         if (valueList.count() > 0) settingsMap["proto"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03863                         else settingsMap.remove("proto");
03864                     }
03865                     {
03866                         TQT_DBusDataValueList valueList;
03867                         {
03868                             if (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
03869                                 if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
03870                                 if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
03871                                 if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
03872                                 if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
03873                             }
03874                             for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedPairWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedPairWiseCiphers.end(); ++it) {
03875                                 valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
03876                             }
03877                         }
03878                         if (valueList.count() > 0) settingsMap["pairwise"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03879                         else settingsMap.remove("pairwise");
03880                     }
03881                     {
03882                         TQT_DBusDataValueList valueList;
03883                         {
03884                             if (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
03885                                 if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
03886                                 if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
03887                                 if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
03888                                 if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
03889                             }
03890                             for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedGroupWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedGroupWiseCiphers.end(); ++it) {
03891                                 valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
03892                             }
03893                         }
03894                         if (valueList.count() > 0) settingsMap["group"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
03895                         else settingsMap.remove("group");
03896                     }
03897                     UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapUsername, "leap-username", settingsMap)
03898                     settingsMap["wep-key-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.wepKeyFlags)));
03899                     settingsMap["wep-key-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType)));
03900                     settingsMap["psk-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.pskFlags)));
03901                     settingsMap["leap-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.leapPasswordFlags)));
03902                     if (wiFiConnection->securitySettings.secretsValid) {
03903                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey0, "wep-key0", settingsMap)
03904                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey1, "wep-key1", settingsMap)
03905                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey2, "wep-key2", settingsMap)
03906                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey3, "wep-key3", settingsMap)
03907                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.psk, "psk", settingsMap)
03908                         UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapPassword, "leap-password", settingsMap)
03909                     }
03910                     else {
03911                         settingsMap.remove("wep-key0");
03912                         settingsMap.remove("wep-key1");
03913                         settingsMap.remove("wep-key2");
03914                         settingsMap.remove("wep-key3");
03915                         settingsMap.remove("psk");
03916                         settingsMap.remove("leap-password");
03917                     }
03918                 }
03919                 else {
03920                     settingsMap.remove("key-mgmt");
03921                     settingsMap.remove("wep-tx-keyidx");
03922                     settingsMap.remove("auth-alg");
03923                     settingsMap.remove("proto");
03924                     settingsMap.remove("pairwise");
03925                     settingsMap.remove("group");
03926                     settingsMap.remove("leap-username");
03927                     settingsMap.remove("wep-key-flags");
03928                     settingsMap.remove("wep-key-type");
03929                     settingsMap.remove("psk-flags");
03930                     settingsMap.remove("leap-password-flags");
03931                     settingsMap.remove("wep-key0");
03932                     settingsMap.remove("wep-key1");
03933                     settingsMap.remove("wep-key2");
03934                     settingsMap.remove("wep-key3");
03935                     settingsMap.remove("psk");
03936                     settingsMap.remove("leap-password");
03937                 }
03938             }
03939             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03940             groupValid = (settingsMap.count() > 0);
03941         }
03942         if (groupValid) outerMap.insert("802-11-wireless-security", dbusData, TRUE); else outerMap.remove("802-11-wireless-security");
03943 
03944         groupValid = false;
03945         dbusData = outerMap["vpn"];
03946         if (vpnConnection) {
03947             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03948             {
03949                 {
03950                     TQString pluginService = vpnConnection->vpnPluginID;
03951                     if (pluginService != "") {
03952                         pluginService = "org.freedesktop.NetworkManager." + pluginService;
03953                     }
03954                     UPDATE_STRING_SETTING_IF_VALID(pluginService, "service-type", settingsMap)
03955                 }
03956                 UPDATE_STRING_SETTING_IF_VALID(vpnConnection->lockedUserName, "user-name", settingsMap)
03957                 {
03958                     TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
03959                     TDENetworkSettingsMap::const_iterator it;
03960                     for (it = vpnConnection->pluginData.begin(); it != vpnConnection->pluginData.end(); ++it) {
03961                         nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
03962                     }
03963                     if (nestedConnectionSettingsMap.count() > 0) settingsMap["data"] = convertDBUSDataToVariantData(TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap)));
03964                     else settingsMap.remove("data");
03965                 }
03966                 if (vpnConnection->secretsValid) {
03967                     TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
03968                     TDENetworkSettingsMap::const_iterator it;
03969                     for (it = vpnConnection->pluginSecrets.begin(); it != vpnConnection->pluginSecrets.end(); ++it) {
03970                         nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
03971                     }
03972                     if (nestedConnectionSettingsMap.count() > 0) settingsMap["secrets"] = convertDBUSDataToVariantData(TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap)));
03973                     else settingsMap.remove("secrets");
03974                 }
03975             }
03976             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
03977             groupValid = (settingsMap.count() > 0);
03978         }
03979         if (groupValid) outerMap.insert("vpn", dbusData, TRUE); else outerMap.remove("vpn");
03980 
03981         groupValid = false;
03982         dbusData = outerMap["wimax"];
03983         if (wiMaxConnection) {
03984             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
03985             {
03986                 if (connection->lockedHWAddress.isValid()) {
03987                     TDENetworkByteList address = connection->lockedHWAddress.address();
03988                     TQT_DBusDataValueList valueList;
03989                     TDENetworkByteList::iterator it;
03990                     for (it = address.begin(); it != address.end(); ++it) {
03991                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
03992                         valueList.append(innerDataValue);
03993                     }
03994                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
03995                     settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
03996                 }
03997                 else {
03998                     settingsMap.remove("mac-address");
03999                 }
04000                 UPDATE_STRING_SETTING_IF_VALID(wiMaxConnection->networkServiceProvider, "network-name", settingsMap)
04001             }
04002             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04003             groupValid = (settingsMap.count() > 0);
04004         }
04005         if (groupValid) outerMap.insert("wimax", dbusData, TRUE); else outerMap.remove("wimax");
04006 
04007         groupValid = false;
04008         dbusData = outerMap["vlan"];
04009         if (vlanConnection) {
04010             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04011             {
04012                 UPDATE_STRING_SETTING_IF_VALID(vlanConnection->kernelName, "interface-name", settingsMap)
04013                 UPDATE_STRING_SETTING_IF_VALID(vlanConnection->parentConnectionUUID, "parent", settingsMap)
04014                 settingsMap["id"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(vlanConnection->vlanID));
04015                 settingsMap["flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdeVLANFlagsToNMVLANFlags(vlanConnection->vlanFlags)));
04016                 {
04017                     TQT_DBusDataValueList valueList;
04018                     TDENetworkPriorityMap::const_iterator it;
04019                     for (it = vlanConnection->ingressPriorityMap.begin(); it != vlanConnection->ingressPriorityMap.end(); ++it) {
04020                         valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
04021                     }
04022                     if (valueList.count() > 0) settingsMap["ingress-priority-map"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04023                 }
04024                 {
04025                     TQT_DBusDataValueList valueList;
04026                     TDENetworkPriorityMap::const_iterator it;
04027                     for (it = vlanConnection->egressPriorityMap.begin(); it != vlanConnection->egressPriorityMap.end(); ++it) {
04028                         valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
04029                     }
04030                     if (valueList.count() > 0) settingsMap["egress-priority-map"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04031                 }
04032             }
04033             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04034             groupValid = (settingsMap.count() > 0);
04035         }
04036         if (groupValid) outerMap.insert("vlan", dbusData, TRUE); else outerMap.remove("vlan");
04037 
04038         groupValid = false;
04039         dbusData = outerMap["serial"];
04040         if (connection->serialConfig.valid) {
04041             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04042             {
04043                 settingsMap["baud"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.baudRate));
04044                 settingsMap["bits"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.byteWidth));
04045                 settingsMap["parity"] = convertDBUSDataToVariantData(TQT_DBusData::fromByte(tdeParityToNMParity(connection->serialConfig.parity)));
04046                 settingsMap["stopbits"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.stopBits));
04047                 settingsMap["send-delay"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt64(connection->serialConfig.txDelay));
04048             }
04049             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04050             groupValid = (settingsMap.count() > 0);
04051         }
04052         if (groupValid) outerMap.insert("serial", dbusData, TRUE); else outerMap.remove("serial");
04053 
04054         groupValid = false;
04055         dbusData = outerMap["ppp"];
04056         if (connection->pppConfig.valid) {
04057             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04058             {
04059                 settingsMap["noauth"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.requireServerAuthentication)));
04060                 settingsMap["refuse-eap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableEAP));
04061                 settingsMap["refuse-pap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisablePAP));
04062                 settingsMap["refuse-chap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableCHAP));
04063                 settingsMap["refuse-mschap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAP));
04064                 settingsMap["refuse-mschapv2"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAPv2));
04065                 settingsMap["nobsdcomp"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowBSDCompression)));
04066                 settingsMap["nodeflate"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowDeflateCompression)));
04067                 settingsMap["no-vj-comp"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowVJCompression)));
04068                 settingsMap["require-mppe"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE));
04069                 settingsMap["require-mppe-128"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE128));
04070                 settingsMap["mppe-stateful"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::StatefulMPPE));
04071                 settingsMap["crtscts"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::UseHardwareFlowControl));
04072                 settingsMap["baud"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.baudRate));
04073                 if (connection->pppConfig.mru > 0) {
04074                     settingsMap["mru"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.mru));
04075                 }
04076                 else {
04077                     settingsMap.remove("mru");
04078                 }
04079                 if (connection->pppConfig.mtu > 0) {
04080                     settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.mtu));
04081                 }
04082                 else {
04083                     settingsMap.remove("mtu");
04084                 }
04085                 if (connection->pppConfig.mtu > 0) {
04086                     settingsMap["lcp-echo-interval"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoPingInterval));
04087                 }
04088                 else {
04089                     settingsMap.remove("lcp-echo-interval");
04090                 }
04091                 if (connection->pppConfig.mtu > 0) {
04092                     settingsMap["lcp-echo-failure"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoFailureThreshold));
04093                 }
04094                 else {
04095                     settingsMap.remove("lcp-echo-failure");
04096                 }
04097             }
04098             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04099             groupValid = (settingsMap.count() > 0);
04100         }
04101         if (groupValid) outerMap.insert("ppp", dbusData, TRUE); else outerMap.remove("ppp");
04102 
04103         groupValid = false;
04104         dbusData = outerMap["pppoe"];
04105         if (connection->pppoeConfig.valid) {
04106             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04107             {
04108                 UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.networkServiceProvider, "service", settingsMap)
04109                 UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.username, "username", settingsMap)
04110                 if (connection->pppoeConfig.secretsValid) {
04111                     UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.password, "password", settingsMap)
04112                 }
04113                 settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->pppoeConfig.passwordFlags)));
04114             }
04115             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04116             groupValid = (settingsMap.count() > 0);
04117         }
04118         if (groupValid) outerMap.insert("pppoe", dbusData, TRUE); else outerMap.remove("pppoe");
04119 
04120         groupValid = false;
04121         dbusData = outerMap["802-11-olpc-mesh"];
04122         if (olpcMeshConnection) {
04123             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04124             {
04125                 {
04126                     unsigned int i;
04127                     TQT_DBusDataValueList valueList;
04128                     for (i=0; i<olpcMeshConnection->SSID.count(); i++) {
04129                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->SSID[i]);
04130                         valueList.append(innerDataValue);
04131                     }
04132                     settingsMap["ssid"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04133                 }
04134                 settingsMap["channel"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(olpcMeshConnection->channel));
04135                 {
04136                     unsigned int i;
04137                     TQT_DBusDataValueList valueList;
04138                     for (i=0; i<olpcMeshConnection->anycastDHCPHWAddress.count(); i++) {
04139                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->anycastDHCPHWAddress[i]);
04140                         valueList.append(innerDataValue);
04141                     }
04142                     settingsMap["dhcp-anycast-address"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04143                 }
04144             }
04145             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04146             groupValid = (settingsMap.count() > 0);
04147         }
04148         if (groupValid) outerMap.insert("802-11-olpc-mesh", dbusData, TRUE); else outerMap.remove("802-11-olpc-mesh");
04149 
04150         groupValid = false;
04151         dbusData = outerMap["bluetooth"];
04152         if (bluetoothConnection) {
04153             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04154             {
04155                 if (connection->lockedHWAddress.isValid()) {
04156                     TDENetworkByteList address = connection->lockedHWAddress.address();
04157                     TQT_DBusDataValueList valueList;
04158                     TDENetworkByteList::iterator it;
04159                     for (it = address.begin(); it != address.end(); ++it) {
04160                         TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
04161                         valueList.append(innerDataValue);
04162                     }
04163                     TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
04164                     settingsMap["bdaddr"] = convertDBUSDataToVariantData(nmHWAddress);
04165                 }
04166                 else {
04167                     settingsMap.remove("bdaddr");
04168                 }
04169                 UPDATE_STRING_SETTING_IF_VALID(tdeBluetoothModeToNMBluetoothMode(bluetoothConnection->type), "type", settingsMap)
04170             }
04171             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04172             groupValid = (settingsMap.count() > 0);
04173         }
04174         if (groupValid) outerMap.insert("bluetooth", dbusData, TRUE); else outerMap.remove("bluetooth");
04175 
04176         groupValid = false;
04177         dbusData = outerMap["cdma"];
04178         if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::CDMA)) {
04179             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04180             {
04181                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.providerDataNumber, "number", settingsMap)
04182                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.username, "username", settingsMap)
04183                 if (connection->pppoeConfig.secretsValid) {
04184                     UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.password, "password", settingsMap)
04185                 }
04186                 settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->cdmaConfig.passwordFlags)));
04187             }
04188             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04189             groupValid = (settingsMap.count() > 0);
04190         }
04191         if (groupValid) outerMap.insert("cdma", dbusData, TRUE); else outerMap.remove("cdma");
04192 
04193         groupValid = false;
04194         dbusData = outerMap["gsm"];
04195         if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::GSM)) {
04196             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04197             {
04198                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.providerDataNumber, "number", settingsMap)
04199                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.username, "username", settingsMap)
04200                 if (connection->pppoeConfig.secretsValid) {
04201                     UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.password, "password", settingsMap)
04202                 }
04203                 settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.passwordFlags)));
04204                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.accessPointName, "apn", settingsMap)
04205                 UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.networkID, "network-id", settingsMap)
04206                 settingsMap["network-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromInt32(tdeGSMModeToNMGSMMode(modemConnection->gsmConfig.networkType)));
04207                 if (connection->pppoeConfig.secretsValid) {
04208                     UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.pin, "pin", settingsMap)
04209                 }
04210                 settingsMap["pin-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.pinFlags)));
04211                 settingsMap["allowed-bands"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(modemConnection->gsmConfig.allowedFrequencyBands));
04212                 settingsMap["home-only"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(modemConnection->gsmConfig.allowRoaming)));
04213             }
04214             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04215             groupValid = (settingsMap.count() > 0);
04216         }
04217         if (groupValid) outerMap.insert("gsm", dbusData, TRUE); else outerMap.remove("gsm");
04218 
04219         groupValid = false;
04220         dbusData = outerMap["ipv4"];
04221         {
04222             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04223             {
04224                 {
04225                     TQT_DBusDataValueList valueList;
04226                     TDENetworkSingleIPConfigurationList::iterator it;
04227                     for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
04228                         if ((*it).isIPv4()) {
04229                             TQT_DBusDataValueList innerValueList;
04230                             // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04231                             // Address
04232                             innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
04233                             // Netmask
04234                             innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
04235                             // Gateway
04236                             innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
04237                             valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
04238                         }
04239                     }
04240                     if (valueList.count() <= 0) {
04241                         // Create an empty list with the correct DBUS type structure
04242                         TQT_DBusData valueList;
04243                         valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
04244                         settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
04245                     }
04246                     else {
04247                         settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04248                     }
04249                 }
04250                 {
04251                     if (!connection->ipConfig.dhcpClientIdentifier.isNull()) {
04252                         settingsMap["dhcp-client-id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->ipConfig.dhcpClientIdentifier));
04253                     }
04254                 }
04255                 {
04256                     TQT_DBusDataValueList valueList;
04257                     TDENetworkAddressList::iterator it;
04258                     for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
04259                         if ((*it).isIPv4Address()) {
04260                             valueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).toIPv4Address())));
04261                         }
04262                     }
04263                     if (valueList.count() <= 0) {
04264                         // Create an empty list with the correct DBUS type structure
04265                         settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32)));
04266                     }
04267                     else {
04268                         settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04269                     }
04270                 }
04271                 {
04272                     TQT_DBusDataValueList valueList;
04273                     TDENetworkSearchDomainList::iterator it;
04274                     for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
04275                         if ((*it).isIPv4()) {
04276                             valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
04277                         }
04278                     }
04279                     if (valueList.count() > 0) settingsMap["dns-search"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04280                 }
04281                 {
04282                     settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS)));
04283                 }
04284                 {
04285                     settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV4));
04286                 }
04287                 {
04288                     TQString method;
04289                     if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP) {
04290                         method = "auto";
04291                     }
04292                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4LocalOnly) {
04293                         method = "link-local";
04294                     }
04295                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer) {
04296                         method = "shared";
04297                     }
04298                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4Disabled) {
04299                         method = "disabled";
04300                     }
04301                     else {
04302                         method = "manual";
04303                     }
04304                     if (!method.isNull())
04305                         settingsMap["method"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method));
04306                 }
04307                 {
04308                     settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPRoutes)));
04309                 }
04310                 {
04311                     settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute)));
04312                 }
04313                 {
04314                     TQT_DBusDataValueList valueList;
04315                     TDENetworkSingleRouteConfigurationList::iterator it;
04316                     for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
04317                         if ((*it).isIPv4()) {
04318                             TQT_DBusDataValueList innerValueList;
04319                             // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04320                             // Address
04321                             innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
04322                             // Netmask
04323                             innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
04324                             // Gateway
04325                             innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
04326                             // Metric
04327                             innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
04328                             valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
04329                         }
04330                     }
04331                     if (valueList.count() <= 0) {
04332                         // Create an empty list with the correct DBUS type structure
04333                         TQT_DBusData valueList;
04334                         valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
04335                         settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
04336                     }
04337                     else {
04338                         settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04339                     }
04340                 }
04341             }
04342             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04343             groupValid = (settingsMap.count() > 0);
04344         }
04345         if (groupValid) outerMap.insert("ipv4", dbusData, TRUE); else outerMap.remove("ipv4");
04346 
04347         groupValid = false;
04348         dbusData = outerMap["ipv6"];
04349         {
04350             TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
04351             {
04352                 {
04353                     TQT_DBusDataValueList valueList;
04354                     TDENetworkSingleIPConfigurationList::iterator it;
04355                     for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
04356                         if ((*it).isIPv6()) {
04357                             int i;
04358                             Q_IPV6ADDR v6address;
04359                             TQT_DBusDataValueList innerValueList;
04360                             TQT_DBusDataValueList innerMostValueList;
04361                             // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04362                             // Address
04363                             innerMostValueList.clear();
04364                             v6address = (*it).ipAddress.toIPv6Address();
04365                             for (i=0; i<16; i++) {
04366                                 innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04367                             }
04368                             innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04369                             // Netmask
04370                             innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
04371                             // Gateway
04372                             innerMostValueList.clear();
04373                             v6address = (*it).gateway.toIPv6Address();
04374                             for (i=0; i<16; i++) {
04375                                 innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04376                             }
04377                             innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04378                             valueList.append(TQT_DBusData::fromStruct(innerValueList));
04379                         }
04380                     }
04381                     if (valueList.count() <= 0) {
04382                         // Create an empty list with the correct DBUS type structure
04383                         TQT_DBusDataValueList innerValueList;
04384                         TQT_DBusDataValueList innerMostValueList;
04385                         // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04386                         // Address
04387                         innerMostValueList.clear();
04388                         innerMostValueList.append(TQT_DBusData::fromByte(0));
04389                         innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04390                         // Netmask
04391                         innerValueList.append(TQT_DBusData::fromUInt32(0));
04392                         // Gateway
04393                         innerMostValueList.clear();
04394                         innerMostValueList.append(TQT_DBusData::fromByte(0));
04395                         innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04396                         settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList))));
04397                     }
04398                     else {
04399                         settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04400                     }
04401                 }
04402                 {
04403                     TQT_DBusDataValueList valueList;
04404                     TDENetworkAddressList::iterator it;
04405                     for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
04406                         if ((*it).isIPv6Address()) {
04407                             int i;
04408                             Q_IPV6ADDR v6address;
04409                             TQT_DBusDataValueList innerValueList;
04410                             v6address = (*it).toIPv6Address();
04411                             for (i=0; i<16; i++) {
04412                                 innerValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04413                             }
04414                             valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
04415                         }
04416                     }
04417                     if (valueList.count() <= 0) {
04418                         // Create an empty list with the correct DBUS type structure
04419                         TQT_DBusData valueList;
04420                         valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::Byte));
04421                         settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
04422                     }
04423                     else {
04424                         settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04425                     }
04426                 }
04427                 {
04428                     TQT_DBusDataValueList valueList;
04429                     TDENetworkSearchDomainList::iterator it;
04430                     for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
04431                         if ((*it).isIPv6()) {
04432                             valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
04433                         }
04434                     }
04435                     if (valueList.count() > 0) settingsMap["dns-search"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04436                 }
04437                 {
04438                     settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS)));
04439                 }
04440                 {
04441                     settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV6));
04442                 }
04443                 {
04444                     TQString method;
04445                     if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP) {
04446                         method = "auto";
04447                     }
04448                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6LocalOnly) {
04449                         method = "link-local";
04450                     }
04451                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer) {
04452                         method = "shared";
04453                     }
04454                     else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6Disabled) {
04455                         method = "ignore";
04456                     }
04457                     else {
04458                         method = "manual";
04459                     }
04460                     if (!method.isNull())
04461                         settingsMap["method"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method));
04462                 }
04463                 {
04464                     settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPRoutes)));
04465                 }
04466                 {
04467                     settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute)));
04468                 }
04469                 {
04470                     TQT_DBusDataValueList valueList;
04471                     TDENetworkSingleRouteConfigurationList::iterator it;
04472                     for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
04473                         if ((*it).isIPv6()) {
04474                             int i;
04475                             Q_IPV6ADDR v6address;
04476                             TQT_DBusDataValueList innerValueList;
04477                             TQT_DBusDataValueList innerMostValueList;
04478                             // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04479                             // Address
04480                             innerMostValueList.clear();
04481                             v6address = (*it).ipAddress.toIPv6Address();
04482                             for (i=0; i<16; i++) {
04483                                 innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04484                             }
04485                             innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04486                             // Netmask
04487                             innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
04488                             // Gateway
04489                             innerMostValueList.clear();
04490                             v6address = (*it).gateway.toIPv6Address();
04491                             for (i=0; i<16; i++) {
04492                                 innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
04493                             }
04494                             innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04495                             // Metric
04496                             innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
04497                             valueList.append(TQT_DBusData::fromStruct(innerValueList));
04498                         }
04499                     }
04500                     if (valueList.count() <= 0) {
04501                         // Create an empty list with the correct DBUS type structure
04502                         TQT_DBusDataValueList innerValueList;
04503                         TQT_DBusDataValueList innerMostValueList;
04504                         // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
04505                         // Address
04506                         innerMostValueList.clear();
04507                         innerMostValueList.append(TQT_DBusData::fromByte(0));
04508                         innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04509                         // Netmask
04510                         innerValueList.append(TQT_DBusData::fromUInt32(0));
04511                         // Gateway
04512                         innerMostValueList.clear();
04513                         innerMostValueList.append(TQT_DBusData::fromByte(0));
04514                         innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
04515                         // Metric
04516                         innerValueList.append(TQT_DBusData::fromUInt32(0));
04517                         settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList))));
04518                     }
04519                     else {
04520                         settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
04521                     }
04522                 }
04523             }
04524             dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
04525             groupValid = (settingsMap.count() > 0);
04526         }
04527         if (groupValid) outerMap.insert("ipv6", dbusData, TRUE); else outerMap.remove("ipv6");
04528     }
04529     connectionSettingsMap = TQT_DBusDataMap<TQString>(outerMap);
04530 
04531     // If existing==true, a connection already existed and simply needs to be updated
04532     // If existing==false, a new connection must be created
04533     // 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);'
04534     // To create new: Use 'd->m_networkManagerSettings' and call 'virtual bool AddConnectionAsync(int& asyncCallId, const TQT_DBusDataMap<TQString>& connection, TQT_DBusError& error);'
04535 
04536 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04537     printf("[network-manager comm debug] uploaded DBUS object structure map follows:\n"); fflush(stdout);
04538     printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
04539 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04540 
04541     if (existing) {
04542 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04543         printf("[network-manager comm debug] Updating existing connection\n"); fflush(stdout);
04544 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04545         // Save connection settings to the path specified
04546         DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
04547         connectionSettings.setConnection(TQT_DBusConnection::systemBus());
04548         connect(&connectionSettings, SIGNAL(UpdateAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
04549         int asyncCallID;
04550         ret = connectionSettings.UpdateAsync(asyncCallID, connectionSettingsMap, error);
04551         if (ret && error.isValid()) {
04552             ret = 0;
04553             PRINT_ERROR((error.name() + ": " + error.message()))
04554         }
04555         if (ret) {
04556             // Wait for the asynchronous call to return...
04557             d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
04558             TQTimer nmCallTimeoutTimer;
04559             nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
04560             while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
04561                 tqApp->processEvents();
04562                 if (!nmCallTimeoutTimer.isActive()) {
04563                     PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
04564                     timed_out = true;
04565                     break;
04566                 }
04567             }
04568             d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
04569             return !timed_out;
04570         }
04571         else {
04572             // Error!
04573             PRINT_ERROR((error.name() + ": " + error.message()))
04574             return FALSE;
04575         }
04576     }
04577     else {
04578 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04579         printf("[network-manager comm debug] Creating new connection\n"); fflush(stdout);
04580 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
04581         // Create new connection
04582         connect(d->m_networkManagerSettings, SIGNAL(AddConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
04583         connect(d->m_networkManagerSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
04584         int asyncCallID;
04585         ret = d->m_networkManagerSettings->AddConnectionAsync(asyncCallID, connectionSettingsMap, error);
04586         if (ret && error.isValid()) {
04587             ret = 0;
04588             PRINT_ERROR((error.name() + ": " + error.message()))
04589         }
04590         if (ret) {
04591             // Wait for the asynchronous call to return...
04592             d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
04593             TQTimer nmCallTimeoutTimer;
04594             nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
04595             while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
04596                 if (!nmCallTimeoutTimer.isActive()) {
04597                     PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
04598                     timed_out = true;
04599                     break;
04600                 }
04601                 tqApp->processEvents();
04602             }
04603             if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
04604                 PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
04605                 d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
04606             }
04607             if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
04608                 PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
04609                 command_failed = true;
04610             }
04611             d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
04612             if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
04613                 d->nmAddConnectionAsyncResponse.remove(asyncCallID);
04614             }
04615             return ((!timed_out) && (!command_failed));
04616         }
04617         else {
04618             // Error!
04619             PRINT_ERROR((error.name() + ": " + error.message()))
04620             return FALSE;
04621         }
04622     }
04623 }
04624 
04625 bool TDENetworkConnectionManager_BackendNM::deleteConnection(TQString uuid) {
04626     TQT_DBusObjectPath existingConnection;
04627     TQT_DBusError error;
04628     bool timed_out = false;
04629     bool ret;
04630     if (d->m_networkManagerSettings) {
04631         ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
04632         if (ret) {
04633             // Obtain connection secrets from the path specified
04634             DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
04635             connectionSettings.setConnection(TQT_DBusConnection::systemBus());
04636             connect(&connectionSettings, SIGNAL(DeleteAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
04637             int asyncCallID;
04638             ret = connectionSettings.DeleteAsync(asyncCallID, error);
04639             if (ret && error.isValid()) {
04640                 ret = 0;
04641                 PRINT_ERROR((error.name() + ": " + error.message()))
04642             }
04643             if (ret) {
04644                 // Wait for the asynchronous call to return...
04645                 d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
04646                 TQTimer nmCallTimeoutTimer;
04647                 nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
04648                 while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
04649                     tqApp->processEvents();
04650                     if (!nmCallTimeoutTimer.isActive()) {
04651                         PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
04652                         timed_out = true;
04653                         break;
04654                     }
04655                 }
04656                 d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
04657                 return !timed_out;
04658             }
04659             else {
04660                 PRINT_ERROR(TQString("Unable to remove connection with uuid '%1'").arg(uuid))
04661                 return FALSE;
04662             }
04663         }
04664         else {
04665             PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
04666             return FALSE;
04667         }
04668     }
04669     else {
04670         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04671         return FALSE;
04672     }
04673 }
04674 
04675 bool TDENetworkConnectionManager_BackendNM::verifyConnectionSettings(TDENetworkConnection* connection, TDENetworkConnectionErrorFlags::TDENetworkConnectionErrorFlags* type, TDENetworkErrorStringMap* reason) {
04676     // FIXME
04677     // This should actually attempt to validate all the settings!
04678 
04679     if (!connection) {
04680         return false;
04681     }
04682 
04683     if (connection->friendlyName == "") {
04684         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidConnectionSetting] = i18n("Connection name is invalid");
04685         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidConnectionSetting;
04686         return false;
04687     }
04688 
04689     if (connection->ipConfig.valid) {
04690         // Iterate over all addresses
04691         TDENetworkSingleIPConfigurationList::iterator it;
04692         for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
04693             if ((*it).isIPv4()) {
04694                 if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP)) {
04695                     if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
04696                         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv4Setting] = i18n("IPv4 address is invalid");
04697                         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv4Setting;
04698                         return false;
04699                     }
04700                 }
04701             }
04702             else if ((*it).isIPv6()) {
04703                 if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP)) {
04704                     if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
04705                         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv6Setting] = i18n("IPv6 address is invalid");
04706                         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv6Setting;
04707                         return false;
04708                     }
04709                 }
04710             }
04711         }
04712     }
04713 
04714     TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
04715     if (wiFiConnection) {
04716         if (wiFiConnection->SSID.count() < 1) {
04717             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessSetting] = i18n("No SSID provided");
04718             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessSetting;
04719             return false;
04720         }
04721         if (wiFiConnection->securityRequired) {
04722             if (wiFiConnection->securitySettings.secretsValid) {
04723                 if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WEP) || ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && ((wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Open) || (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Shared)))) {
04724                     if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Hexadecimal) {
04725                         if (wiFiConnection->securitySettings.wepKey0 != "") {
04726                             if ((wiFiConnection->securitySettings.wepKey0.length() != 10) && (wiFiConnection->securitySettings.wepKey0.length() != 26)) {
04727                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
04728                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04729                                 return false;
04730                             }
04731                         }
04732                         if (wiFiConnection->securitySettings.wepKey1 != "") {
04733                             if ((wiFiConnection->securitySettings.wepKey1.length() != 10) && (wiFiConnection->securitySettings.wepKey1.length() != 26)) {
04734                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
04735                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04736                                 return false;
04737                             }
04738                         }
04739                         if (wiFiConnection->securitySettings.wepKey2 != "") {
04740                             if ((wiFiConnection->securitySettings.wepKey2.length() != 10) && (wiFiConnection->securitySettings.wepKey2.length() != 26)) {
04741                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
04742                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04743                                 return false;
04744                             }
04745                         }
04746                         if (wiFiConnection->securitySettings.wepKey3 != "") {
04747                             if ((wiFiConnection->securitySettings.wepKey3.length() != 10) && (wiFiConnection->securitySettings.wepKey3.length() != 26)) {
04748                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
04749                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04750                                 return false;
04751                             }
04752                         }
04753                         if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
04754                             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
04755                             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04756                             return false;
04757                         }
04758                     }
04759                     else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
04760                         if (wiFiConnection->securitySettings.wepKey0 != "") {
04761                             if ((wiFiConnection->securitySettings.wepKey0.length() != 5) && (wiFiConnection->securitySettings.wepKey0.length() != 13)) {
04762                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
04763                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04764                                 return false;
04765                             }
04766                         }
04767                         if (wiFiConnection->securitySettings.wepKey1 != "") {
04768                             if ((wiFiConnection->securitySettings.wepKey1.length() != 5) && (wiFiConnection->securitySettings.wepKey1.length() != 13)) {
04769                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
04770                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04771                                 return false;
04772                             }
04773                         }
04774                         if (wiFiConnection->securitySettings.wepKey2 != "") {
04775                             if ((wiFiConnection->securitySettings.wepKey2.length() != 5) && (wiFiConnection->securitySettings.wepKey2.length() != 13)) {
04776                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
04777                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04778                                 return false;
04779                             }
04780                         }
04781                         if (wiFiConnection->securitySettings.wepKey3 != "") {
04782                             if ((wiFiConnection->securitySettings.wepKey3.length() != 5) && (wiFiConnection->securitySettings.wepKey3.length() != 13)) {
04783                                 if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
04784                                 if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04785                                 return false;
04786                             }
04787                         }
04788                         if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
04789                             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
04790                             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04791                             return false;
04792                         }
04793                     }
04794                     else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
04795                         if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
04796                             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
04797                             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04798                             return false;
04799                         }
04800                     }
04801                 }
04802                 else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::LEAP)) {
04803                     if ((wiFiConnection->securitySettings.leapUsername.length() < 1) || (wiFiConnection->securitySettings.leapPassword.length() < 1)) {
04804                         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("LEAP username and/or password not provided");
04805                         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04806                         return false;
04807                     }
04808                 }
04809                 else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAAdHoc) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAInfrastructure) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAEnterprise)) {
04810                     if (wiFiConnection->securitySettings.psk.length() == 64) {
04811                         // Verify that only hex characters are present in the string
04812                         bool ok;
04813                         wiFiConnection->securitySettings.psk.toULongLong(&ok, 16);
04814                         if (!ok) {
04815                             if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("Hexadecimal length PSK contains non-hexadecimal characters");
04816                             if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04817                             return false;
04818                         }
04819                     }
04820                     else if ((wiFiConnection->securitySettings.psk.length() < 8) || (wiFiConnection->securitySettings.psk.length() > 63)) {
04821                         if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No PSK provided");
04822                         if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
04823                         return false;
04824                     }
04825                 }
04826             }
04827         }
04828     }
04829 
04830     return TRUE;
04831 }
04832 
04833 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::initiateConnection(TQString uuid) {
04834     TQT_DBusObjectPath existingConnection;
04835     TQT_DBusError error;
04836     bool ret;
04837     if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
04838         ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
04839         if (ret) {
04840             if (!m_networkDevice) {
04841                 d->m_dbusDeviceString = "/";
04842             }
04843             else {
04844                 d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
04845             }
04846 #ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
04847             TQT_DBusObjectPath active_connection;
04848             ret = d->m_networkManagerProxy->ActivateConnection(existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), active_connection, error);
04849             if (ret && error.isValid()) {
04850                 ret = 0;
04851                 PRINT_ERROR((error.name() + ": " + error.message()))
04852             }
04853             return checkConnectionStatus(uuid);
04854 #else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
04855 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
04856             connect(d->m_networkManagerProxy, SIGNAL(ActivateConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
04857             connect(d->m_networkManagerProxy, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
04858 #endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
04859             int asyncCallID;
04860             ret = d->m_networkManagerProxy->ActivateConnectionAsync(asyncCallID, existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), error);
04861             if (ret && error.isValid()) {
04862                 ret = 0;
04863                 PRINT_ERROR((error.name() + ": " + error.message()))
04864             }
04865 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
04866             if (ret) {
04867                 // Wait for the asynchronous call to return...
04868                 d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
04869                 TQTimer nmCallTimeoutTimer;
04870                 nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
04871                 while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
04872                     if (!nmCallTimeoutTimer.isActive()) {
04873                         PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
04874                         break;
04875                     }
04876                     tqApp->processEvents();
04877                 }
04878                 d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
04879                 if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
04880                     PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
04881                     d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
04882                 }
04883                 if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
04884                     PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
04885                 }
04886                 if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
04887                     d->nmAddConnectionAsyncResponse.remove(asyncCallID);
04888                 }
04889                 return checkConnectionStatus(uuid);
04890             }
04891             else {
04892                 // Error!
04893                 PRINT_ERROR((error.name() + ": " + error.message()))
04894                 return checkConnectionStatus(uuid);
04895             }
04896 #else
04897             return checkConnectionStatus(uuid);
04898 #endif
04899 #endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
04900         }
04901         else {
04902             PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
04903             return TDENetworkConnectionStatus::Invalid;
04904         }
04905     }
04906     else {
04907         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04908         return TDENetworkConnectionStatus::Invalid;
04909     }
04910 }
04911 
04912 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::checkConnectionStatus(TQString uuid) {
04913     TQT_DBusObjectPath existingConnection;
04914     TQT_DBusError error;
04915     if (d->m_networkManagerProxy) {
04916         TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
04917         TQT_DBusObjectPathList::iterator it;
04918         for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
04919             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
04920             activeConnection.setConnection(TQT_DBusConnection::systemBus());
04921             if (activeConnection.getUuid(error) == uuid) {
04922                 return nmDeviceStateToTDEDeviceState(activeConnection.getState(error));
04923             }
04924         }
04925         PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
04926         return TDENetworkConnectionStatus::Invalid;
04927     }
04928     else {
04929         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04930         return TDENetworkConnectionStatus::Invalid;
04931     }
04932 }
04933 
04934 TQCString TDENetworkConnectionManager_BackendNM::getActiveConnectionPath(TQString uuid) {
04935     TQT_DBusObjectPath existingConnection;
04936     TQT_DBusError error;
04937     if (d->m_networkManagerProxy) {
04938         TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
04939         TQT_DBusObjectPathList::iterator it;
04940         for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
04941             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
04942             activeConnection.setConnection(TQT_DBusConnection::systemBus());
04943             if (activeConnection.getUuid(error) == uuid) {
04944                 return (*it);
04945             }
04946         }
04947         PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
04948         return TQT_DBusObjectPath();
04949     }
04950     else {
04951         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04952         return TQT_DBusObjectPath();
04953     }
04954 }
04955 
04956 TQStringList TDENetworkConnectionManager_BackendNM::connectionPhysicalDeviceUUIDs(TQString uuid) {
04957     if (deviceType() == TDENetworkDeviceType::BackendOnly) {
04958         return TQStringList();
04959     }
04960 
04961     TQT_DBusObjectPath existingConnection;
04962     TQT_DBusError error;
04963     if (d->m_networkManagerProxy) {
04964         TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
04965         TQT_DBusObjectPathList::iterator it;
04966         TQStringList ret;
04967         for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
04968             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
04969             activeConnection.setConnection(TQT_DBusConnection::systemBus());
04970             if (activeConnection.getUuid(error) == uuid) {
04971                 TQValueList<TQT_DBusObjectPath> deviceList = activeConnection.getDevices(error);
04972                 TQT_DBusObjectPathList::iterator it2;
04973                 for (it2 = deviceList.begin(); it2 != deviceList.end(); ++it2) {
04974                     TQString devUUID = tdeDeviceUUIDForGenericDevice(*it2);
04975                     if (devUUID != "") {
04976                         ret.append(devUUID);
04977                     }
04978                 }
04979             }
04980         }
04981         return ret;
04982     }
04983     else {
04984         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
04985         return TQStringList();
04986     }
04987 }
04988 
04989 TDENetworkVPNTypeList TDENetworkConnectionManager_BackendNM::availableVPNTypes() {
04990     TDENetworkVPNTypeList ret;
04991 
04992     // Query NetworkManager to verify plugin availability before claiming support for a VPN type
04993     TQDir serviceDir(NM_PLUGIN_SERVICE_DIR, TQString(), TQDir::Name|TQDir::IgnoreCase, TQDir::Files);
04994     TQStringList services = serviceDir.entryList ().grep (".name", true);
04995 
04996     if (services.count () > 0) {
04997         // read in all available Services
04998         for (TQStringList::Iterator i = services.begin (); i != services.end (); ++i) {
04999             TQString service = NM_PLUGIN_SERVICE_DIR + TQString ("/") + *i;
05000             TDEConfig* tdeconfig = new TDEConfig (service, true, true, "config");
05001             tdeconfig->setGroup ("VPN Connection");
05002 
05003             TQString serviceName = tdeconfig->readEntry("name", TQString());
05004             serviceName = serviceName.lower();
05005 
05006             if (serviceName == "openvpn") {
05007                 ret.append(TDENetworkVPNType::OpenVPN);
05008             }
05009             if (serviceName == "pptp") {
05010                 ret.append(TDENetworkVPNType::PPTP);
05011             }
05012             if (serviceName == "strongswan") {
05013                 ret.append(TDENetworkVPNType::StrongSwan);
05014             }
05015             if (serviceName == "vpnc") {
05016                 ret.append(TDENetworkVPNType::VPNC);
05017             }
05018 
05019             delete tdeconfig;
05020         }
05021     }
05022 
05023     return ret;
05024 }
05025 
05026 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::deactivateConnection(TQString uuid) {
05027     TQT_DBusObjectPath existingConnection;
05028     TQT_DBusError error;
05029     bool ret;
05030     if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
05031         existingConnection = getActiveConnectionPath(uuid);
05032         if (existingConnection.isValid()) {
05033             if (!m_networkDevice) {
05034                 d->m_dbusDeviceString = "/";
05035             }
05036             else {
05037                 d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
05038             }
05039 #ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
05040             ret = d->m_networkManagerProxy->DeactivateConnection(existingConnection, error);
05041             if (ret && error.isValid()) {
05042                 ret = 0;
05043                 PRINT_ERROR((error.name() + ": " + error.message()))
05044             }
05045             return checkConnectionStatus(uuid);
05046 #else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
05047 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
05048             connect(d->m_networkManagerProxy, SIGNAL(DeactivateConnectionAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
05049 #endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
05050             int asyncCallID;
05051             ret = d->m_networkManagerProxy->DeactivateConnectionAsync(asyncCallID, existingConnection, error);
05052             if (ret && error.isValid()) {
05053                 ret = 0;
05054                 PRINT_ERROR((error.name() + ": " + error.message()))
05055             }
05056 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
05057             if (ret) {
05058                 // Wait for the asynchronous call to return...
05059                 d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
05060                 TQTimer nmCallTimeoutTimer;
05061                 nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
05062                 while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
05063                     if (!nmCallTimeoutTimer.isActive()) {
05064                         PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
05065                         break;
05066                     }
05067                     tqApp->processEvents();
05068                 }
05069                 d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
05070                 return checkConnectionStatus(uuid);
05071             }
05072             else {
05073                 // Error!
05074                 PRINT_ERROR((error.name() + ": " + error.message()))
05075                 return checkConnectionStatus(uuid);
05076             }
05077 #else
05078             return checkConnectionStatus(uuid);
05079 #endif
05080 #endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
05081         }
05082         else {
05083             PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
05084             return TDENetworkConnectionStatus::Invalid;
05085         }
05086     }
05087     else {
05088         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
05089         return TDENetworkConnectionStatus::Invalid;
05090     }
05091 }
05092 
05093 TQStringList TDENetworkConnectionManager_BackendNM::validSettings() {
05094     TQStringList ret;
05095 
05096     ret.append("TDENetworkSingleIPConfiguration::ipAddress");
05097     ret.append("TDENetworkSingleIPConfiguration::networkMask");
05098     ret.append("TDENetworkSingleIPConfiguration::gateway");
05099 
05100     ret.append("TDENetworkSingleRouteConfiguration::ipAddress");
05101     ret.append("TDENetworkSingleRouteConfiguration::networkMask");
05102     ret.append("TDENetworkSingleRouteConfiguration::gateway");
05103 
05104     ret.append("TDENetworkIEEE8021xConfiguration::valid");
05105     ret.append("TDENetworkIEEE8021xConfiguration::allowedValid");
05106     ret.append("TDENetworkIEEE8021xConfiguration::secretsValid");
05107     ret.append("TDENetworkIEEE8021xConfiguration::type");
05108     ret.append("TDENetworkIEEE8021xConfiguration::userName");
05109     ret.append("TDENetworkIEEE8021xConfiguration::anonymousUserName");
05110     ret.append("TDENetworkIEEE8021xConfiguration::pacFileName");
05111     ret.append("TDENetworkIEEE8021xConfiguration::caCertificate");
05112     ret.append("TDENetworkIEEE8021xConfiguration::additionalCAFilesPath");
05113     ret.append("TDENetworkIEEE8021xConfiguration::authServerCertSubjectMatch");
05114     ret.append("TDENetworkIEEE8021xConfiguration::alternateAuthServerCertSubjectMatch");
05115     ret.append("TDENetworkIEEE8021xConfiguration::clientCertificate");
05116     ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPVersion");
05117     ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPLabel");
05118     ret.append("TDENetworkIEEE8021xConfiguration::fastProvisioningFlags");
05119     ret.append("TDENetworkIEEE8021xConfiguration::phase2NonEAPAuthMethod");
05120     ret.append("TDENetworkIEEE8021xConfiguration::phase2EAPAuthMethod");
05121     ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2NonEAPMethods");
05122     ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2EAPMethods");
05123     ret.append("TDENetworkIEEE8021xConfiguration::phase2CaCertificate");
05124     ret.append("TDENetworkIEEE8021xConfiguration::phase2CaFilesPath");
05125     ret.append("TDENetworkIEEE8021xConfiguration::phase2AuthServerCertSubjectMatch");
05126     ret.append("TDENetworkIEEE8021xConfiguration::phase2AlternateAuthServerCertSubjectMatch");
05127     ret.append("TDENetworkIEEE8021xConfiguration::phase2ClientCertificate");
05128     ret.append("TDENetworkIEEE8021xConfiguration::password");
05129     ret.append("TDENetworkIEEE8021xConfiguration::passwordFlags");
05130     ret.append("TDENetworkIEEE8021xConfiguration::binaryPassword");
05131     ret.append("TDENetworkIEEE8021xConfiguration::binaryPasswordFlags");
05132     ret.append("TDENetworkIEEE8021xConfiguration::privateKey");
05133     ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPassword");
05134     ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPasswordFlags");
05135     ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKey");
05136     ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPassword");
05137     ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPasswordFlags");
05138     ret.append("TDENetworkIEEE8021xConfiguration::forceSystemCaCertificates");
05139 
05140     ret.append("TDENetworkPPPConfiguration::valid");
05141     ret.append("TDENetworkPPPConfiguration::requireServerAuthentication");
05142     ret.append("TDENetworkPPPConfiguration::flags");
05143     ret.append("TDENetworkPPPConfiguration::baudRate");
05144     ret.append("TDENetworkPPPConfiguration::mru");
05145     ret.append("TDENetworkPPPConfiguration::mtu");
05146     ret.append("TDENetworkPPPConfiguration::lcpEchoPingInterval");
05147     ret.append("TDENetworkPPPConfiguration::lcpEchoFailureThreshold");
05148 
05149     ret.append("TDENetworkPPPOEConfiguration::valid");
05150     ret.append("TDENetworkPPPOEConfiguration::secretsValid");
05151     ret.append("TDENetworkPPPOEConfiguration::networkServiceProvider");
05152     ret.append("TDENetworkPPPOEConfiguration::username");
05153     ret.append("TDENetworkPPPOEConfiguration::password");
05154     ret.append("TDENetworkPPPOEConfiguration::passwordFlags");
05155 
05156     ret.append("TDENetworkSerialConfiguration::valid");
05157     ret.append("TDENetworkSerialConfiguration::baudRate");
05158     ret.append("TDENetworkSerialConfiguration::byteWidth");
05159     ret.append("TDENetworkSerialConfiguration::parity");
05160     ret.append("TDENetworkSerialConfiguration::stopBits");
05161     ret.append("TDENetworkSerialConfiguration::txDelay");
05162 
05163     ret.append("TDENetworkCDMAConfiguration::valid");
05164     ret.append("TDENetworkCDMAConfiguration::secretsValid");
05165     ret.append("TDENetworkCDMAConfiguration::providerDataNumber");
05166     ret.append("TDENetworkCDMAConfiguration::username");
05167     ret.append("TDENetworkCDMAConfiguration::password");
05168     ret.append("TDENetworkCDMAConfiguration::passwordFlags");
05169 
05170     ret.append("TDENetworkGSMConfiguration::valid");
05171     ret.append("TDENetworkGSMConfiguration::secretsValid");
05172     ret.append("TDENetworkGSMConfiguration::providerDataNumber");
05173     ret.append("TDENetworkGSMConfiguration::username");
05174     ret.append("TDENetworkGSMConfiguration::password");
05175     ret.append("TDENetworkGSMConfiguration::passwordFlags");
05176     ret.append("TDENetworkGSMConfiguration::accessPointName");
05177     ret.append("TDENetworkGSMConfiguration::networkID");
05178     ret.append("TDENetworkGSMConfiguration::networkType");
05179     ret.append("TDENetworkGSMConfiguration::pin");
05180     ret.append("TDENetworkGSMConfiguration::pinFlags");
05181     ret.append("TDENetworkGSMConfiguration::allowedFrequencyBands");
05182     ret.append("TDENetworkGSMConfiguration::allowRoaming");
05183 
05184     ret.append("TDENetworkWiFiSecurityConfiguration::valid");
05185     ret.append("TDENetworkWiFiSecurityConfiguration::secretsValid");
05186     ret.append("TDENetworkWiFiSecurityConfiguration::keyType");
05187     ret.append("TDENetworkWiFiSecurityConfiguration::authType");
05188     ret.append("TDENetworkWiFiSecurityConfiguration::wpaVersion");
05189     ret.append("TDENetworkWiFiSecurityConfiguration::cipher");
05190     ret.append("TDENetworkWiFiSecurityConfiguration::wepKey0");
05191     ret.append("TDENetworkWiFiSecurityConfiguration::wepKey1");
05192     ret.append("TDENetworkWiFiSecurityConfiguration::wepKey2");
05193     ret.append("TDENetworkWiFiSecurityConfiguration::wepKey3");
05194     ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyFlags");
05195     ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyIndex");
05196     ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyType");
05197     ret.append("TDENetworkWiFiSecurityConfiguration::allowedPairWiseCiphers");
05198     ret.append("TDENetworkWiFiSecurityConfiguration::allowedGroupWiseCiphers");
05199     ret.append("TDENetworkWiFiSecurityConfiguration::psk");
05200     ret.append("TDENetworkWiFiSecurityConfiguration::pskFlags");
05201     ret.append("TDENetworkWiFiSecurityConfiguration::leapUsername");
05202     ret.append("TDENetworkWiFiSecurityConfiguration::leapPassword");
05203     ret.append("TDENetworkWiFiSecurityConfiguration::leapPasswordFlags");
05204 
05205     ret.append("TDENetworkIPConfiguration::valid");
05206     ret.append("TDENetworkIPConfiguration::connectionFlags");
05207     ret.append("TDENetworkIPConfiguration::ipConfigurations");
05208     ret.append("TDENetworkIPConfiguration::routeConfigurations");
05209     ret.append("TDENetworkIPConfiguration::broadcast");
05210     ret.append("TDENetworkIPConfiguration::destination");
05211     ret.append("TDENetworkIPConfiguration::resolvers");
05212     ret.append("TDENetworkIPConfiguration::searchDomains");
05213     ret.append("TDENetworkIPConfiguration::dhcpClientIdentifier");
05214 
05215     ret.append("TDENetworkConnection::UUID");
05216     ret.append("TDENetworkConnection::friendlyName");
05217     ret.append("TDENetworkConnection::ipConfig");
05218     ret.append("TDENetworkConnection::lockedHWAddress");
05219     ret.append("TDENetworkConnection::manualHWAddress");
05220     ret.append("TDENetworkConnection::readOnly");
05221     ret.append("TDENetworkConnection::autoConnect");
05222     ret.append("TDENetworkConnection::fullDuplex");
05223     ret.append("TDENetworkConnection::requireIPV4");
05224     ret.append("TDENetworkConnection::requireIPV6");
05225     ret.append("TDENetworkConnection::mtu");
05226     ret.append("TDENetworkConnection::eapConfig");
05227     ret.append("TDENetworkConnection::pppConfig");
05228     ret.append("TDENetworkConnection::pppoeConfig");
05229     ret.append("TDENetworkConnection::serialConfig");
05230     ret.append("TDENetworkConnection::authorizedUsers");
05231     ret.append("TDENetworkConnection::masterConnectionUUID");
05232     ret.append("TDENetworkConnection::slaveType");
05233     ret.append("TDENetworkConnection::lastKnownConnection");
05234 
05235     ret.append("TDEWiFiConnection::SSID");
05236     ret.append("TDEWiFiConnection::operatingMode");
05237     ret.append("TDEWiFiConnection::bandRestriction");
05238     ret.append("TDEWiFiConnection::channelRestriction");
05239     ret.append("TDEWiFiConnection::bitRateRestriction");
05240     ret.append("TDEWiFiConnection::powerRestriction");
05241     ret.append("TDEWiFiConnection::accessPointRestriction");
05242     ret.append("TDEWiFiConnection::blacklistedBSSIDs");
05243     ret.append("TDEWiFiConnection::heardBSSIDs");
05244     ret.append("TDEWiFiConnection::isHiddenNetwork");
05245     ret.append("TDEWiFiConnection::securityRequired");
05246     ret.append("TDEWiFiConnection::securitySettings");
05247 
05248     ret.append("TDEWiredInfinibandConnection::transportMode");
05249 
05250     ret.append("TDEVPNConnection::vpnPluginID");
05251     ret.append("TDEVPNConnection::lockedUserName");
05252     ret.append("TDEVPNConnection::pluginData");
05253     ret.append("TDEVPNConnection::secretsValid");
05254     ret.append("TDEVPNConnection::pluginSecrets");
05255 
05256     ret.append("TDEWiMaxConnection::networkServiceProvider");
05257 
05258     ret.append("TDEVLANConnection::kernelName");
05259     ret.append("TDEVLANConnection::parentConnectionUUID");
05260     ret.append("TDEVLANConnection::vlanID");
05261     ret.append("TDEVLANConnection::vlanFlags");
05262     ret.append("TDEVLANConnection::ingressPriorityMap");
05263     ret.append("TDEVLANConnection::egressPriorityMap");
05264 
05265     ret.append("TDEOLPCMeshConnection::SSID");
05266     ret.append("TDEOLPCMeshConnection::channel");
05267     ret.append("TDEOLPCMeshConnection::anycastDHCPHWAddress");
05268 
05269     ret.append("TDEBluetoothConnection::type");
05270 
05271     ret.append("TDEModemConnection::type");
05272     ret.append("TDEModemConnection::cdmaConfig");
05273     ret.append("TDEModemConnection::gsmConfig");
05274 
05275     ret.append("TDEWiredInfinibandConnection::transportMode");
05276 
05277     return ret;
05278 }
05279 
05280 TDENetworkWiFiAPInfo* TDENetworkConnectionManager_BackendNM::getAccessPointDetails(TQString dbusPath) {
05281     if (dbusPath == "") {
05282         return NULL;
05283     }
05284 
05285     TDENetworkWiFiAPInfo* apInfo = new TDENetworkWiFiAPInfo;
05286     TQT_DBusError error;
05287     unsigned int index;
05288     DBus::AccessPointProxy accessPoint(NM_DBUS_SERVICE, dbusPath);
05289     accessPoint.setConnection(TQT_DBusConnection::systemBus());
05290 
05291     TQValueList<TQ_UINT8> nmSSID = accessPoint.getSsid(error);
05292     if (error.isValid()) {
05293         delete apInfo;
05294         return NULL;
05295     }
05296     TQValueList<TQ_UINT8>::iterator it;
05297     index = 0;
05298     for (it = nmSSID.begin(); it != nmSSID.end(); ++it) {
05299         apInfo->SSID.resize(index+1);
05300         apInfo->SSID[index] = (*it);
05301         index++;
05302     }
05303 
05304     apInfo->wpaFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getWpaFlags(error));
05305     apInfo->rsnFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getRsnFlags(error));
05306     apInfo->frequency = accessPoint.getFrequency(error);
05307     apInfo->BSSID.fromString(accessPoint.getHwAddress(error));
05308     apInfo->maxBitrate = accessPoint.getMaxBitrate(error);
05309     apInfo->signalQuality = (accessPoint.getStrength(error)/100.0);
05310 
05311     apInfo->valid = true;
05312 
05313     return apInfo;
05314 }
05315 
05316 TDENetworkHWNeighborList* TDENetworkConnectionManager_BackendNM::siteSurvey() {
05317     TQT_DBusError error;
05318     bool ret;
05319 
05320     TDENetworkDeviceType::TDENetworkDeviceType myDeviceType = deviceType();
05321     d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
05322     clearTDENetworkHWNeighborList();
05323 
05324     if (myDeviceType == TDENetworkDeviceType::WiFi) {
05325         DBus::WiFiDeviceProxy wiFiDevice(NM_DBUS_SERVICE, d->m_dbusDeviceString);
05326         wiFiDevice.setConnection(TQT_DBusConnection::systemBus());
05327         // FIXME
05328         // Should call wiFiDevice.RequestScanAsync first to rescan all access points
05329         TQT_DBusObjectPathList accessPoints;
05330         ret = wiFiDevice.GetAccessPoints(accessPoints, error);
05331         if (ret) {
05332             TQT_DBusObjectPathList::iterator it;
05333             for (it = accessPoints.begin(); it != accessPoints.end(); ++it) {
05334                 TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(TQString(*it));
05335                 if (apInfo) {
05336                     m_hwNeighborList->append(apInfo);
05337                     // Ensure that this AP is monitored for changes
05338                     d->internalProcessWiFiAccessPointAdded(*it);
05339                 }
05340             }
05341         }
05342     }
05343 
05344     return m_hwNeighborList;
05345 }
05346 
05347 bool TDENetworkConnectionManager_BackendNM::networkingEnabled() {
05348     if (d->m_networkManagerProxy) {
05349         bool ret;
05350         TQT_DBusError error;
05351         ret = d->m_networkManagerProxy->getNetworkingEnabled(error);
05352         if (error.isValid()) {
05353             // Error!
05354             PRINT_ERROR((error.name() + ": " + error.message()))
05355             return FALSE;
05356         }
05357         else {
05358             return ret;
05359         }
05360     }
05361     else {
05362         return FALSE;
05363     }
05364 }
05365 
05366 bool TDENetworkConnectionManager_BackendNM::wiFiHardwareEnabled() {
05367     if (d->m_networkManagerProxy) {
05368         bool ret;
05369         TQT_DBusError error;
05370         ret = d->m_networkManagerProxy->getWirelessHardwareEnabled(error);
05371         if (error.isValid()) {
05372             // Error!
05373             PRINT_ERROR((error.name() + ": " + error.message()))
05374             return FALSE;
05375         }
05376         else {
05377             return ret;
05378         }
05379     }
05380     else {
05381         return FALSE;
05382     }
05383 }
05384 
05385 bool TDENetworkConnectionManager_BackendNM::enableNetworking(bool enable) {
05386     // FIXME
05387     // Yes, this abuses the Sleep command
05388     // Is there a better way to do it?
05389     if (d->m_networkManagerProxy) {
05390         int asynccallid;
05391         TQT_DBusError error;
05392         d->m_networkManagerProxy->SleepAsync(asynccallid, !enable, error);
05393         if (error.isValid()) {
05394             // Error!
05395             PRINT_ERROR((error.name() + ": " + error.message()))
05396             return FALSE;
05397         }
05398         else {
05399             // FIXME
05400             // Wait for async reply before returning...
05401             return TRUE;
05402         }
05403     }
05404     else {
05405         return FALSE;
05406     }
05407 }
05408 
05409 bool TDENetworkConnectionManager_BackendNM::enableWiFi(bool enable) {
05410     if (d->m_networkManagerProxy) {
05411         TQT_DBusError error;
05412         d->m_networkManagerProxy->setWirelessEnabled(enable, error);
05413         if (error.isValid()) {
05414             // Error!
05415             PRINT_ERROR((error.name() + ": " + error.message()))
05416             return FALSE;
05417         }
05418         else {
05419             return TRUE;
05420         }
05421     }
05422     else {
05423         return FALSE;
05424     }
05425 }
05426 
05427 bool TDENetworkConnectionManager_BackendNM::wiFiEnabled() {
05428     if (d->m_networkManagerProxy) {
05429         bool ret;
05430         TQT_DBusError error;
05431         ret = d->m_networkManagerProxy->getWirelessEnabled(error);
05432         if (error.isValid()) {
05433             // Error!
05434             PRINT_ERROR((error.name() + ": " + error.message()))
05435             return FALSE;
05436         }
05437         else {
05438             return ret;
05439         }
05440     }
05441     else {
05442         return FALSE;
05443     }
05444 }
05445 
05446 TQStringList TDENetworkConnectionManager_BackendNM::defaultNetworkDevices() {
05447     // Cycle through all available connections and see which one is default, then find all devices for that connection...
05448     TQStringList ret;
05449 
05450     TQT_DBusObjectPath existingConnection;
05451     TQT_DBusError error;
05452     if (d->m_networkManagerProxy) {
05453         TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
05454         TQT_DBusObjectPathList::iterator it;
05455         for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
05456             DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
05457             activeConnection.setConnection(TQT_DBusConnection::systemBus());
05458             if (activeConnection.getDefault(error)) {
05459                 // This is the default ipv4 connection
05460                 TQString uuid = activeConnection.getUuid(error);
05461                 TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
05462                 for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
05463                     ret.append(*it);
05464                 }
05465             }
05466             else if (activeConnection.getDefault6(error)) {
05467                 // This is the default ipv6 connection
05468                 TQString uuid = activeConnection.getUuid(error);
05469                 TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
05470                 for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
05471                     ret.append(*it);
05472                 }
05473             }
05474         }
05475         return ret;
05476     }
05477     else {
05478         PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
05479         return TQStringList();
05480     }
05481 }
05482 
05483 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) {
05484     // Set up global signal handler
05485     m_dbusSignalConnection = new TQT_DBusConnection(TQT_DBusConnection::systemBus());
05486     m_dbusSignalReceiver = new TDENetworkConnectionManager_BackendNM_DBusSignalReceiver(this);
05487     m_dbusSignalConnection->connect(m_dbusSignalReceiver, TQT_SLOT(dbusSignal(const TQT_DBusMessage&)));
05488 }
05489 
05490 TDENetworkConnectionManager_BackendNMPrivate::~TDENetworkConnectionManager_BackendNMPrivate() {
05491     // Destroy global signal handler
05492     if (m_dbusSignalConnection) delete m_dbusSignalConnection;
05493     if (m_dbusSignalReceiver) delete m_dbusSignalReceiver;
05494 
05495     // Destroy proxy objects
05496     TQMap<TQString, DBus::AccessPointProxy*>::iterator it;
05497     for (it = m_accessPointProxyList.begin(); it != m_accessPointProxyList.end(); ++it) {
05498         DBus::AccessPointProxy *apProxy = it.data();
05499         if (apProxy) {
05500             delete apProxy;
05501         }
05502     }
05503     m_accessPointProxyList.clear();
05504 }
05505 
05506 #include "network-manager.moc"
05507 #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.6.3
This website is maintained by Timothy Pearson.