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