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