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

tdecore

  • tdecore
  • tdehw
  • networkbackends
  • network-manager
network-manager.cpp
1 /* This file is part of the TDE libraries
2  Copyright (C) 2012 Timothy Pearson <kb9vqf@pearsoncomputing.net>
3 
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Library General Public
6  License version 2 as published by the Free Software Foundation.
7 
8  This library is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  Library General Public License for more details.
12 
13  You should have received a copy of the GNU Library General Public License
14  along with this library; see the file COPYING.LIB. If not, write to
15  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
16  Boston, MA 02110-1301, USA.
17 */
18 
19 #include <tqdir.h>
20 
21 #include <tqdbusmessage.h>
22 
23 #include "tdeconfig.h"
24 #include "tdehardwaredevices.h"
25 #include "tdenetworkdevice.h"
26 
27 #include "network-manager.h"
28 #include "network-manager_p.h"
29 
30 // #define DEBUG_NETWORK_MANAGER_COMMUNICATIONS
31 
32 #define PRINT_ERROR(x) printf("[TDE NM Backend ERROR] [%s:%d] %s\n", __FILE__, __LINE__, x.ascii());
33 
34 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
35 #define PRINT_WARNING(x) printf("[TDE NM Backend WARNING] [%s:%d] %s\n", __FILE__, __LINE__, x.ascii());
36 #else
37 #define PRINT_WARNING(x)
38 #endif
39 
40 #define UPDATE_STRING_SETTING_IF_VALID(string, key, settingsMap) if (!string.isNull()) settingsMap[key] = convertDBUSDataToVariantData(TQT_DBusData::fromString(string)); \
41  else settingsMap.remove(key);
42 
43 #define NM_ASYNC_TIMEOUT_MS 1000
44 // Give the user 5 minutes to authenticate to DBUS before timing out
45 #define NM_ASYNC_SECRETS_INTERACTION_TIMEOUT_MS (5*60*1000)
46 
47 // #define WAIT_FOR_OPERATION_BEFORE_RETURNING 1
48 #define USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS 1
49 
50 // Defined in tdehardwaredevices.cpp
51 TQT_DBusData convertDBUSDataToVariantData(TQT_DBusData);
52 
53 TQ_UINT32 reverseIPV4ByteOrder(TQ_UINT32 address) {
54  TQ_UINT32 ret;
55  unsigned char valuearray[4];
56  valuearray[0] = (address & 0xff000000) >> 24;
57  valuearray[1] = (address & 0x00ff0000) >> 16;
58  valuearray[2] = (address & 0x0000ff00) >> 8;
59  valuearray[3] = (address & 0x000000ff) >> 0;
60  ret = 0;
61  ret = ret | (valuearray[0] << 0);
62  ret = ret | (valuearray[1] << 8);
63  ret = ret | (valuearray[2] << 16);
64  ret = ret | (valuearray[3] << 24);
65  return ret;
66 }
67 
68 void printDBUSObjectStructure(TQT_DBusData object, int level=0, TQString mapKey=TQString::null) {
69  int i;
70  TQString levelIndent = "";
71  for (i=0; i<level; i++) {
72  levelIndent = levelIndent + " ";
73  }
74  TQCString signature = object.buildDBusSignature();
75 
76  if (object.type() == TQT_DBusData::String) {
77  printf("%s%s\t%s%s'%s'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toString().ascii()); fflush(stdout);
78  }
79  else if (object.type() == TQT_DBusData::Bool) {
80  printf("%s%s\t%s%s'%s'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", (object.toBool())?"true":"false"); fflush(stdout);
81  }
82  else if (object.type() == TQT_DBusData::Byte) {
83  printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toByte()); fflush(stdout);
84  }
85  else if (object.type() == TQT_DBusData::Int16) {
86  printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toInt16()); fflush(stdout);
87  }
88  else if (object.type() == TQT_DBusData::UInt16) {
89  printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toUInt16()); fflush(stdout);
90  }
91  else if (object.type() == TQT_DBusData::Int32) {
92  printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toInt32()); fflush(stdout);
93  }
94  else if (object.type() == TQT_DBusData::UInt32) {
95  printf("%s%s\t%s%s'%d'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toUInt32()); fflush(stdout);
96  }
97  else if (object.type() == TQT_DBusData::Int64) {
98  printf("%s%s\t%s%s'%lld'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toInt64()); fflush(stdout);
99  }
100  else if (object.type() == TQT_DBusData::UInt64) {
101  printf("%s%s\t%s%s'%lld'\n", levelIndent.ascii(), signature.data(), (mapKey.isNull())?"":mapKey.ascii(), (mapKey.isNull())?"":" = ", object.toUInt64()); fflush(stdout);
102  }
103  else {
104  printf("%s%s\n", levelIndent.ascii(), signature.data()); fflush(stdout);
105  }
106 
107  if (object.type() == TQT_DBusData::Map) {
108  // HACK
109  // NetworkManager currently uses string key maps exclusively as far as I can tell, so this should be adequate for the time being
110  TQMap<TQString, TQT_DBusData> outerMap = object.toStringKeyMap().toTQMap();
111  TQMap<TQString, TQT_DBusData>::const_iterator it;
112  for (it = outerMap.begin(); it != outerMap.end(); ++it) {
113  printDBUSObjectStructure(*it, level+1, it.key());
114  }
115  }
116  else if (object.type() == TQT_DBusData::List) {
117  TQT_DBusDataValueList valueList = object.toTQValueList();
118  TQT_DBusDataValueList::const_iterator it;
119  for (it = valueList.begin(); it != valueList.end(); ++it) {
120  printDBUSObjectStructure(*it, level+1);
121  }
122  }
123  else if (object.type() == TQT_DBusData::Variant) {
124  TQT_DBusVariant dataValueVariant = object.toVariant();
125  TQT_DBusData dataValue = dataValueVariant.value;
126  printDBUSObjectStructure(dataValue, level+1, mapKey);
127  }
128 }
129 
130 TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags nmGlobalStateToTDEGlobalState(TQ_UINT32 nmType) {
131  TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags ret = TDENetworkGlobalManagerFlags::Unknown;
132 
133  if (nmType == NM_STATE_UNKNOWN) {
134  ret |= TDENetworkGlobalManagerFlags::Unknown;
135  }
136  else if (nmType == NM_STATE_ASLEEP) {
137  ret |= TDENetworkGlobalManagerFlags::Disconnected;
138  ret |= TDENetworkGlobalManagerFlags::Sleeping;
139  }
140  else if (nmType == NM_STATE_DISCONNECTED) {
141  ret |= TDENetworkGlobalManagerFlags::Disconnected;
142  }
143  else if (nmType == NM_STATE_DISCONNECTING) {
144  ret |= TDENetworkGlobalManagerFlags::Connected;
145  ret |= TDENetworkGlobalManagerFlags::DeactivatingLink;
146  }
147  else if (nmType == NM_STATE_CONNECTING) {
148  ret |= TDENetworkGlobalManagerFlags::Disconnected;
149  ret |= TDENetworkGlobalManagerFlags::EstablishingLink;
150  }
151  else if (nmType == NM_STATE_CONNECTED_LOCAL) {
152  ret |= TDENetworkGlobalManagerFlags::Connected;
153  ret |= TDENetworkGlobalManagerFlags::LinkLocalAccess;
154  }
155  else if (nmType == NM_STATE_CONNECTED_SITE) {
156  ret |= TDENetworkGlobalManagerFlags::Connected;
157  ret |= TDENetworkGlobalManagerFlags::SiteLocalAccess;
158  }
159  else if (nmType == NM_STATE_CONNECTED_GLOBAL) {
160  ret |= TDENetworkGlobalManagerFlags::Connected;
161  ret |= TDENetworkGlobalManagerFlags::GlobalAccess;
162  }
163 
164  return ret;
165 }
166 
167 TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags nmVPNStateToTDEGlobalState(TQ_UINT32 nmType) {
168  TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags ret = TDENetworkGlobalManagerFlags::Unknown;
169 
170  if (nmType == NM_VPN_STATE_UNKNOWN) {
171  ret |= TDENetworkGlobalManagerFlags::VPNUnknown;
172  }
173  else if (nmType == NM_VPN_STATE_PREPARE) {
174  ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
175  ret |= TDENetworkGlobalManagerFlags::VPNEstablishingLink;
176  }
177  else if (nmType == NM_VPN_STATE_NEED_AUTH) {
178  ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
179  ret |= TDENetworkGlobalManagerFlags::VPNNeedAuthorization;
180  }
181  else if (nmType == NM_VPN_STATE_CONNECT) {
182  ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
183  ret |= TDENetworkGlobalManagerFlags::VPNConfiguringProtocols;
184  }
185  else if (nmType == NM_VPN_STATE_IP_CONFIG_GET) {
186  ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
187  ret |= TDENetworkGlobalManagerFlags::VPNVerifyingProtocols;
188  }
189  else if (nmType == NM_VPN_STATE_ACTIVATED) {
190  ret |= TDENetworkGlobalManagerFlags::VPNConnected;
191  }
192  else if (nmType == NM_VPN_STATE_FAILED) {
193  ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
194  ret |= TDENetworkGlobalManagerFlags::VPNFailed;
195  }
196  else if (nmType == NM_VPN_STATE_DISCONNECTED) {
197  ret |= TDENetworkGlobalManagerFlags::VPNDisconnected;
198  }
199 
200  return ret;
201 }
202 
203 TDENetworkConnectionStatus::TDENetworkConnectionStatus nmDeviceStateToTDEDeviceState(TQ_UINT32 nmType) {
204  TDENetworkConnectionStatus::TDENetworkConnectionStatus ret = TDENetworkConnectionStatus::None;
205 
206  if (nmType == NM_DEVICE_STATE_UNKNOWN) {
207  ret |= TDENetworkConnectionStatus::Invalid;
208  }
209  else if (nmType == NM_DEVICE_STATE_UNMANAGED) {
210  ret |= TDENetworkConnectionStatus::UnManaged;
211  }
212  else if (nmType == NM_DEVICE_STATE_UNAVAILABLE) {
213  ret |= TDENetworkConnectionStatus::Disconnected;
214  ret |= TDENetworkConnectionStatus::LinkUnavailable;
215  }
216  else if (nmType == NM_DEVICE_STATE_DISCONNECTED) {
217  ret |= TDENetworkConnectionStatus::Disconnected;
218  }
219  else if (nmType == NM_DEVICE_STATE_PREPARE) {
220  ret |= TDENetworkConnectionStatus::Disconnected;
221  ret |= TDENetworkConnectionStatus::EstablishingLink;
222  }
223  else if (nmType == NM_DEVICE_STATE_CONFIG) {
224  ret |= TDENetworkConnectionStatus::Disconnected;
225  ret |= TDENetworkConnectionStatus::EstablishingLink;
226  }
227  else if (nmType == NM_DEVICE_STATE_NEED_AUTH) {
228  ret |= TDENetworkConnectionStatus::Disconnected;
229  ret |= TDENetworkConnectionStatus::NeedAuthorization;
230  }
231  else if (nmType == NM_DEVICE_STATE_IP_CONFIG) {
232  ret |= TDENetworkConnectionStatus::Disconnected;
233  ret |= TDENetworkConnectionStatus::ConfiguringProtocols;
234  }
235  else if (nmType == NM_DEVICE_STATE_IP_CHECK) {
236  ret |= TDENetworkConnectionStatus::Disconnected;
237  ret |= TDENetworkConnectionStatus::VerifyingProtocols;
238  }
239  else if (nmType == NM_DEVICE_STATE_SECONDARIES) {
240  ret |= TDENetworkConnectionStatus::Disconnected;
241  ret |= TDENetworkConnectionStatus::DependencyWait;
242  }
243  else if (nmType == NM_DEVICE_STATE_ACTIVATED) {
244  ret |= TDENetworkConnectionStatus::Connected;
245  }
246  else if (nmType == NM_DEVICE_STATE_DEACTIVATING) {
247  ret |= TDENetworkConnectionStatus::Connected;
248  ret |= TDENetworkConnectionStatus::DeactivatingLink;
249  }
250  else if (nmType == NM_DEVICE_STATE_FAILED) {
251  ret |= TDENetworkConnectionStatus::Disconnected;
252  ret |= TDENetworkConnectionStatus::Failed;
253  }
254 
255  return ret;
256 }
257 
258 TDENetworkDeviceType::TDENetworkDeviceType TDENetworkConnectionManager_BackendNM::nmDeviceTypeToTDEDeviceType(TQ_UINT32 nmType) {
259  TDENetworkDeviceType::TDENetworkDeviceType ret = TDENetworkDeviceType::Other;
260 
261  if (nmType == NM_DEVICE_TYPE_UNKNOWN) {
262  ret = TDENetworkDeviceType::Other;
263  }
264  else if (nmType == NM_DEVICE_TYPE_ETHERNET) {
265  ret = TDENetworkDeviceType::WiredEthernet;
266  }
267  else if (nmType == NM_DEVICE_TYPE_WIFI) {
268  ret = TDENetworkDeviceType::WiFi;
269  }
270  else if (nmType == NM_DEVICE_TYPE_UNUSED1) {
271  }
272  else if (nmType == NM_DEVICE_TYPE_UNUSED2) {
273  }
274  else if (nmType == NM_DEVICE_TYPE_BT) {
275  ret = TDENetworkDeviceType::Bluetooth;
276  }
277  else if (nmType == NM_DEVICE_TYPE_OLPC_MESH) {
278  ret = TDENetworkDeviceType::OLPCMesh;
279  }
280  else if (nmType == NM_DEVICE_TYPE_WIMAX) {
281  ret = TDENetworkDeviceType::WiMax;
282  }
283  else if (nmType == NM_DEVICE_TYPE_MODEM) {
284  ret = TDENetworkDeviceType::Modem;
285  }
286  else if (nmType == NM_DEVICE_TYPE_INFINIBAND) {
287  ret = TDENetworkDeviceType::Infiniband;
288  }
289  else if (nmType == NM_DEVICE_TYPE_BOND) {
290  ret = TDENetworkDeviceType::Bond;
291  }
292  else if (nmType == NM_DEVICE_TYPE_VLAN) {
293  ret = TDENetworkDeviceType::VLAN;
294  }
295  else if (nmType == NM_DEVICE_TYPE_ADSL) {
296  ret = TDENetworkDeviceType::ADSL;
297  }
298 
299  return ret;
300 }
301 
302 TDENetworkConnectionType::TDENetworkConnectionType nmConnectionTypeToTDEConnectionType(TQString nm) {
303  TDENetworkConnectionType::TDENetworkConnectionType ret = TDENetworkConnectionType::Other;
304 
305  if (nm.lower() == "802-3-ethernet") {
306  ret = TDENetworkConnectionType::WiredEthernet;
307  }
308  else if (nm.lower() == "infiniband") {
309  ret = TDENetworkConnectionType::Infiniband;
310  }
311  else if (nm.lower() == "802-11-wireless") {
312  ret = TDENetworkConnectionType::WiFi;
313  }
314  else if (nm.lower() == "vpn") {
315  ret = TDENetworkConnectionType::VPN;
316  }
317  else if (nm.lower() == "wimax") {
318  ret = TDENetworkConnectionType::WiMax;
319  }
320  else if (nm.lower() == "vlan") {
321  ret = TDENetworkConnectionType::VLAN;
322  }
323  else if (nm.lower() == "802-11-olpc-mesh") {
324  ret = TDENetworkConnectionType::OLPCMesh;
325  }
326  else if (nm.lower() == "bluetooth") {
327  ret = TDENetworkConnectionType::Bluetooth;
328  }
329  else if (nm.lower() == "cdma") {
330  ret = TDENetworkConnectionType::Modem;
331  }
332  else if (nm.lower() == "gsm") {
333  ret = TDENetworkConnectionType::Modem;
334  }
335 
336  return ret;
337 }
338 
339 TQString tdeConnectionTypeToNMConnectionType(TDENetworkConnectionType::TDENetworkConnectionType type, TDEModemConnectionType::TDEModemConnectionType modemType=TDEModemConnectionType::Other) {
340  TQString ret;
341 
342  if (type == TDENetworkConnectionType::WiredEthernet) {
343  ret = "802-3-ethernet";
344  }
345  else if (type == TDENetworkConnectionType::Infiniband) {
346  ret = "infiniband";
347  }
348  else if (type == TDENetworkConnectionType::WiFi) {
349  ret = "802-11-wireless";
350  }
351  else if (type == TDENetworkConnectionType::VPN) {
352  ret = "vpn";
353  }
354  else if (type == TDENetworkConnectionType::WiMax) {
355  ret = "wimax";
356  }
357  else if (type == TDENetworkConnectionType::VLAN) {
358  ret = "vlan";
359  }
360  else if (type == TDENetworkConnectionType::OLPCMesh) {
361  ret = "802-11-olpc-mesh";
362  }
363  else if (type == TDENetworkConnectionType::Bluetooth) {
364  ret = "bluetooth";
365  }
366  else if (type == TDENetworkConnectionType::Modem) {
367  if (modemType == TDEModemConnectionType::CDMA) {
368  ret = "cdma";
369  }
370  else if (modemType == TDEModemConnectionType::GSM) {
371  ret = "gsm";
372  }
373  }
374 
375  return ret;
376 }
377 
378 TDENetworkIEEE8021xType::TDENetworkIEEE8021xType nmEAPTypeToTDEEAPType(TQString nm) {
379  TDENetworkIEEE8021xType::TDENetworkIEEE8021xType ret = TDENetworkIEEE8021xType::None;
380 
381  if (nm.lower() == "") {
382  ret = TDENetworkIEEE8021xType::None;
383  }
384  else if (nm.lower() == "leap") {
385  ret = TDENetworkIEEE8021xType::LEAP;
386  }
387  else if (nm.lower() == "md5") {
388  ret = TDENetworkIEEE8021xType::MD5;
389  }
390  else if (nm.lower() == "pap") {
391  ret = TDENetworkIEEE8021xType::PAP;
392  }
393  else if (nm.lower() == "chap") {
394  ret = TDENetworkIEEE8021xType::CHAP;
395  }
396  else if (nm.lower() == "mschap") {
397  ret = TDENetworkIEEE8021xType::MSCHAP;
398  }
399  else if (nm.lower() == "mschapv2") {
400  ret = TDENetworkIEEE8021xType::MSCHAPV2;
401  }
402  else if (nm.lower() == "fast") {
403  ret = TDENetworkIEEE8021xType::Fast;
404  }
405  else if (nm.lower() == "psk") {
406  ret = TDENetworkIEEE8021xType::PSK;
407  }
408  else if (nm.lower() == "pax") {
409  ret = TDENetworkIEEE8021xType::PAX;
410  }
411  else if (nm.lower() == "sake") {
412  ret = TDENetworkIEEE8021xType::SAKE;
413  }
414  else if (nm.lower() == "gpsk") {
415  ret = TDENetworkIEEE8021xType::GPSK;
416  }
417  else if (nm.lower() == "tls") {
418  ret = TDENetworkIEEE8021xType::TLS;
419  }
420  else if (nm.lower() == "peap") {
421  ret = TDENetworkIEEE8021xType::PEAP;
422  }
423  else if (nm.lower() == "ttls") {
424  ret = TDENetworkIEEE8021xType::TTLS;
425  }
426  else if (nm.lower() == "sim") {
427  ret = TDENetworkIEEE8021xType::SIM;
428  }
429  else if (nm.lower() == "gtc") {
430  ret = TDENetworkIEEE8021xType::GTC;
431  }
432  else if (nm.lower() == "otp") {
433  ret = TDENetworkIEEE8021xType::OTP;
434  }
435  else {
436  PRINT_ERROR(TQString("unknown EAP type %s requested in existing connection").arg(nm.lower()))
437  }
438 
439  return ret;
440 }
441 
442 TQString tdeEAPTypeToNMEAPType(TDENetworkIEEE8021xType::TDENetworkIEEE8021xType eaptype) {
443  TQString ret = "";
444 
445  if (eaptype == TDENetworkIEEE8021xType::None) {
446  ret = "";
447  }
448  else if (eaptype == TDENetworkIEEE8021xType::LEAP) {
449  ret = "leap";
450  }
451  else if (eaptype == TDENetworkIEEE8021xType::MD5) {
452  ret = "md5";
453  }
454  else if (eaptype == TDENetworkIEEE8021xType::PAP) {
455  ret = "pap";
456  }
457  else if (eaptype == TDENetworkIEEE8021xType::CHAP) {
458  ret = "chap";
459  }
460  else if (eaptype == TDENetworkIEEE8021xType::MSCHAP) {
461  ret = "mschap";
462  }
463  else if (eaptype == TDENetworkIEEE8021xType::MSCHAPV2) {
464  ret = "mschapv2";
465  }
466  else if (eaptype == TDENetworkIEEE8021xType::Fast) {
467  ret = "fast";
468  }
469  else if (eaptype == TDENetworkIEEE8021xType::PSK) {
470  ret = "psk";
471  }
472  else if (eaptype == TDENetworkIEEE8021xType::PAX) {
473  ret = "pax";
474  }
475  else if (eaptype == TDENetworkIEEE8021xType::SAKE) {
476  ret = "sake";
477  }
478  else if (eaptype == TDENetworkIEEE8021xType::GPSK) {
479  ret = "gpsk";
480  }
481  else if (eaptype == TDENetworkIEEE8021xType::TLS) {
482  ret = "tls";
483  }
484  else if (eaptype == TDENetworkIEEE8021xType::PEAP) {
485  ret = "peap";
486  }
487  else if (eaptype == TDENetworkIEEE8021xType::TTLS) {
488  ret = "ttls";
489  }
490  else if (eaptype == TDENetworkIEEE8021xType::SIM) {
491  ret = "sim";
492  }
493  else if (eaptype == TDENetworkIEEE8021xType::GTC) {
494  ret = "gtc";
495  }
496  else if (eaptype == TDENetworkIEEE8021xType::OTP) {
497  ret = "otp";
498  }
499  else {
500  PRINT_ERROR(TQString("unknown TDE EAP type %d requested in new or updated connection").arg(eaptype))
501  }
502 
503  return ret;
504 }
505 
506 TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags nmEAPFastFlagsToTDEEAPFastFlags(TQString nm) {
507  TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags ret = TDENetworkIEEE8021xFastFlags::AllowUnauthenticated | TDENetworkIEEE8021xFastFlags::AllowAuthenticated;
508 
509  unsigned int nm_int = nm.toUInt();
510  if (nm_int == NM_EAP_FAST_PROVISIONING_DISABLED) {
511  ret = TDENetworkIEEE8021xFastFlags::None;
512  }
513  else if (nm_int == NM_EAP_FAST_PROVISIONING_UNAUTHONLY) {
514  ret = TDENetworkIEEE8021xFastFlags::AllowUnauthenticated;
515  }
516  else if (nm_int == NM_EAP_FAST_PROVISIONING_AUTHONLY) {
517  ret = TDENetworkIEEE8021xFastFlags::AllowAuthenticated;
518  }
519  else if (nm_int == NM_EAP_FAST_PROVISIONING_BOTH) {
520  ret = TDENetworkIEEE8021xFastFlags::AllowUnauthenticated | TDENetworkIEEE8021xFastFlags::AllowAuthenticated;
521  }
522  else {
523  PRINT_ERROR(TQString("unknown EAP fast flag %s requested in existing connection").arg(nm.lower()))
524  }
525 
526  return ret;
527 }
528 
529 TQString tdeEAPFastFlagsToNMEAPFastFlags(TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags eaptype) {
530  TQString ret = "";
531 
532  if ((eaptype & TDENetworkIEEE8021xFastFlags::AllowUnauthenticated) && (eaptype & TDENetworkIEEE8021xFastFlags::AllowAuthenticated)) {
533  ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_BOTH);
534  }
535  else if (eaptype & TDENetworkIEEE8021xFastFlags::AllowAuthenticated) {
536  ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_AUTHONLY);
537  }
538  else if (eaptype & TDENetworkIEEE8021xFastFlags::AllowUnauthenticated) {
539  ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_UNAUTHONLY);
540  }
541  else {
542  ret = TQString("%1").arg(NM_EAP_FAST_PROVISIONING_DISABLED);
543  }
544 
545  return ret;
546 }
547 
548 TDEWiFiMode::TDEWiFiMode nmWiFiModeToTDEWiFiMode(TQString nm) {
549  TDEWiFiMode::TDEWiFiMode ret = TDEWiFiMode::Infrastructure;
550 
551  if (nm.lower() == "infrastructure") {
552  ret = TDEWiFiMode::Infrastructure;
553  }
554  else if (nm.lower() == "adhoc") {
555  ret = TDEWiFiMode::AdHoc;
556  }
557 
558  return ret;
559 }
560 
561 TQString tdeWiFiModeToNMWiFiMode(TDEWiFiMode::TDEWiFiMode mode) {
562  TQString ret;
563 
564  if (mode == TDEWiFiMode::Infrastructure) {
565  ret = "infrastructure";
566  }
567  else if (mode == TDEWiFiMode::AdHoc) {
568  ret = "adhoc";
569  }
570 
571  return ret;
572 }
573 
574 TDEWiFiMode::TDEWiFiMode nmWiFiModeToTDEWiFiMode(TQ_UINT32 nm) {
575  TDEWiFiMode::TDEWiFiMode ret = TDEWiFiMode::Infrastructure;
576 
577  if (nm == NM_802_11_MODE_INFRASTRUCTURE) {
578  ret = TDEWiFiMode::Infrastructure;
579  }
580  else if (nm == NM_802_11_MODE_ADHOC) {
581  ret = TDEWiFiMode::AdHoc;
582  }
583 
584  return ret;
585 }
586 
587 TDENetworkWiFiClientFlags::TDENetworkWiFiClientFlags tdeWiFiFlagsToNMWiFiFlags(TQ_UINT32 nm) {
588  TDENetworkWiFiClientFlags::TDENetworkWiFiClientFlags ret = TDENetworkWiFiClientFlags::None;
589 
590  if (nm & NM_802_11_DEVICE_CAP_CIPHER_WEP40) {
591  ret | TDENetworkWiFiClientFlags::CipherWEP40;
592  }
593  if (nm & NM_802_11_DEVICE_CAP_CIPHER_WEP104) {
594  ret | TDENetworkWiFiClientFlags::CipherWEP104;
595  }
596  if (nm & NM_802_11_DEVICE_CAP_CIPHER_TKIP) {
597  ret | TDENetworkWiFiClientFlags::CipherTKIP;
598  }
599  if (nm & NM_802_11_DEVICE_CAP_CIPHER_CCMP) {
600  ret | TDENetworkWiFiClientFlags::CipherCCMP;
601  }
602  if (nm & NM_802_11_DEVICE_CAP_WPA) {
603  ret | TDENetworkWiFiClientFlags::CipherWPA;
604  }
605  if (nm & NM_802_11_DEVICE_CAP_RSN) {
606  ret | TDENetworkWiFiClientFlags::CipherRSN;
607  }
608 
609  return ret;
610 }
611 
612 TDEBluetoothConnectionType::TDEBluetoothConnectionType nmBluetoothModeToTDEBluetoothMode(TQString nm) {
613  TDEBluetoothConnectionType::TDEBluetoothConnectionType ret = TDEBluetoothConnectionType::PAN;
614 
615  if (nm.lower() == "dun") {
616  ret = TDEBluetoothConnectionType::DUN;
617  }
618  else if (nm.lower() == "panu") {
619  ret = TDEBluetoothConnectionType::PAN;
620  }
621 
622  return ret;
623 }
624 
625 TQString tdeBluetoothModeToNMBluetoothMode(TDEBluetoothConnectionType::TDEBluetoothConnectionType type) {
626  TQString ret;
627 
628  if (type == TDEBluetoothConnectionType::DUN) {
629  ret = "dun";
630  }
631  else if (type == TDEBluetoothConnectionType::PAN) {
632  ret = "panu";
633  }
634 
635  return ret;
636 }
637 
638 TDEGSMNetworkType::TDEGSMNetworkType nmGSMModeToTDEGSMMode(TQ_INT32 nm) {
639  TDEGSMNetworkType::TDEGSMNetworkType ret = TDEGSMNetworkType::Any;
640 
641  if (nm == NM_GSM_3G_ONLY) {
642  ret = TDEGSMNetworkType::Only3G;
643  }
644  else if (nm == NM_GSM_GPRS_EDGE_ONLY) {
645  ret = TDEGSMNetworkType::GPRSEdge;
646  }
647  else if (nm == NM_GSM_PREFER_3G) {
648  ret = TDEGSMNetworkType::Prefer3G;
649  }
650  else if (nm == NM_GSM_PREFER_2G) {
651  ret = TDEGSMNetworkType::Prefer2G;
652  }
653 
654  return ret;
655 }
656 
657 TQ_INT32 tdeGSMModeToNMGSMMode(TDEGSMNetworkType::TDEGSMNetworkType type) {
658  TQ_INT32 ret = -1;
659 
660  if (type == TDEGSMNetworkType::Only3G) {
661  ret = NM_GSM_3G_ONLY;
662  }
663  else if (type == TDEGSMNetworkType::GPRSEdge) {
664  ret = NM_GSM_GPRS_EDGE_ONLY;
665  }
666  else if (type == TDEGSMNetworkType::Prefer3G) {
667  ret = NM_GSM_PREFER_3G;
668  }
669  else if (type == TDEGSMNetworkType::Prefer2G) {
670  ret = NM_GSM_PREFER_2G;
671  }
672 
673  return ret;
674 }
675 
676 TDEWiFiFrequencyBand::TDEWiFiFrequencyBand nmWiFiFrequencyBandToTDEWiFiFrequencyBand(TQString nm) {
677  TDEWiFiFrequencyBand::TDEWiFiFrequencyBand ret = TDEWiFiFrequencyBand::Other;
678 
679  if (nm.lower() == "") {
680  ret = TDEWiFiFrequencyBand::None;
681  }
682  else if (nm.lower() == "bg") {
683  ret = TDEWiFiFrequencyBand::Band2_4GHz;
684  }
685  else if (nm.lower() == "a") {
686  ret = TDEWiFiFrequencyBand::Band5GHz;
687  }
688 
689  return ret;
690 }
691 
692 TQString tdeWiFiFrequencyBandToNMWiFiFrequencyBand(TDEWiFiFrequencyBand::TDEWiFiFrequencyBand mode) {
693  TQString ret;
694 
695  if (mode == TDEWiFiFrequencyBand::None) {
696  ret = TQString::null;
697  }
698  else if (mode == TDEWiFiFrequencyBand::Band2_4GHz) {
699  ret = "bg";
700  }
701  else if (mode == TDEWiFiFrequencyBand::Band5GHz) {
702  ret = "a";
703  }
704 
705  return ret;
706 }
707 
708 TDENetworkWiFiKeyType::TDENetworkWiFiKeyType nmWiFiKeyTypeToTDEWiFiKeyType(TQString nm) {
709  TDENetworkWiFiKeyType::TDENetworkWiFiKeyType ret = TDENetworkWiFiKeyType::Other;
710 
711  if (nm.lower() == "none") {
712  ret = TDENetworkWiFiKeyType::WEP;
713  }
714  else if (nm.lower() == "ieee8021x") {
715  ret = TDENetworkWiFiKeyType::DynamicWEP;
716  }
717  else if (nm.lower() == "wpa-none") {
718  ret = TDENetworkWiFiKeyType::WPAAdHoc;
719  }
720  else if (nm.lower() == "wpa-psk") {
721  ret = TDENetworkWiFiKeyType::WPAInfrastructure;
722  }
723  else if (nm.lower() == "wpa-eap") {
724  ret = TDENetworkWiFiKeyType::WPAEnterprise;
725  }
726 
727  return ret;
728 }
729 
730 TQString tdeWiFiKeyTypeToNMWiFiKeyType(TDENetworkWiFiKeyType::TDENetworkWiFiKeyType type) {
731  TQString ret;
732 
733  if (type == TDENetworkWiFiKeyType::WEP) {
734  return "none";
735  }
736  else if (type == TDENetworkWiFiKeyType::DynamicWEP) {
737  return "ieee8021x";
738  }
739  else if (type == TDENetworkWiFiKeyType::WPAAdHoc) {
740  return "wpa-none";
741  }
742  else if (type == TDENetworkWiFiKeyType::WPAInfrastructure) {
743  return "wpa-psk";
744  }
745  else if (type == TDENetworkWiFiKeyType::WPAEnterprise) {
746  return "wpa-eap";
747  }
748 
749  return ret;
750 }
751 
752 TDENetworkWiFiAuthType::TDENetworkWiFiAuthType nmWiFiAuthTypeToTDEWiFiAuthType(TQString nm) {
753  TDENetworkWiFiAuthType::TDENetworkWiFiAuthType ret = TDENetworkWiFiAuthType::Other;
754 
755  if (nm.lower() == "open") {
756  ret = TDENetworkWiFiAuthType::Open;
757  }
758  else if (nm.lower() == "shared") {
759  ret = TDENetworkWiFiAuthType::Shared;
760  }
761  else if (nm.lower() == "leap") {
762  ret = TDENetworkWiFiAuthType::LEAP;
763  }
764 
765  return ret;
766 }
767 
768 TQString tdeWiFiAuthTypeToNMWiFiAuthType(TDENetworkWiFiAuthType::TDENetworkWiFiAuthType type) {
769  TQString ret;
770 
771  if (type == TDENetworkWiFiAuthType::Open) {
772  return "open";
773  }
774  else if (type == TDENetworkWiFiAuthType::Shared) {
775  return "shared";
776  }
777  else if (type == TDENetworkWiFiAuthType::LEAP) {
778  return "leap";
779  }
780 
781  return ret;
782 }
783 
784 TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags nmWiFiWPAVersionToTDEWiFiWPAVersion(TQStringList nm) {
785  TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags ret = TDENetworkWiFiWPAVersionFlags::None;
786 
787  if ((nm.contains("wpa") && nm.contains("rsn")) || (nm.count() < 1)) {
788  ret |= TDENetworkWiFiWPAVersionFlags::Any;
789  }
790  else if (nm.contains("wpa")) {
791  ret |= TDENetworkWiFiWPAVersionFlags::WPA;
792  }
793  else if (nm.contains("rsn")) {
794  ret |= TDENetworkWiFiWPAVersionFlags::RSN;
795  }
796 
797  return ret;
798 }
799 
800 TQStringList tdeWiFiWPAVersionToNMWiFiWPAVersion(TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags type) {
801  TQStringList ret;
802 
803  if (type & TDENetworkWiFiWPAVersionFlags::WPA) {
804  ret.append("wpa");
805  }
806  if (type & TDENetworkWiFiWPAVersionFlags::RSN) {
807  ret.append("rsn");
808  }
809 
810  return ret;
811 }
812 
813 TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher nmWiFiCipherToTDEWiFiCipher(TQString nm) {
814  TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher ret = TDENetworkWiFiConnectionCipher::None;
815 
816  if (nm.lower() == "wep40") {
817  ret = TDENetworkWiFiConnectionCipher::CipherWEP40;
818  }
819  else if (nm.lower() == "wep104") {
820  ret = TDENetworkWiFiConnectionCipher::CipherWEP104;
821  }
822  else if (nm.lower() == "tkip") {
823  ret = TDENetworkWiFiConnectionCipher::CipherTKIP;
824  }
825  else if (nm.lower() == "ccmp") {
826  ret = TDENetworkWiFiConnectionCipher::CipherCCMP;
827  }
828 
829  return ret;
830 }
831 
832 TQString tdeWiFiCipherToNMWiFiCipher(TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher cipher) {
833  TQString ret;
834 
835  if (cipher == TDENetworkWiFiConnectionCipher::CipherWEP40) {
836  ret = "wep40";
837  }
838  else if (cipher == TDENetworkWiFiConnectionCipher::CipherWEP104) {
839  ret = "wep104";
840  }
841  else if (cipher == TDENetworkWiFiConnectionCipher::CipherTKIP) {
842  ret = "tkip";
843  }
844  else if (cipher == TDENetworkWiFiConnectionCipher::CipherCCMP) {
845  ret = "ccmp";
846  }
847 
848  return ret;
849 }
850 
851 TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType nmSlaveTypeToTDESlaveType(TQString nm) {
852  TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType ret = TDENetworkSlaveDeviceType::None;
853 
854  if (nm.lower() == "bond") {
855  ret = TDENetworkSlaveDeviceType::Bond;
856  }
857 
858  return ret;
859 }
860 
861 TQString tdeSlaveTypeToNMSlaveType(TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType slavetype) {
862  TQString ret;
863 
864  if (slavetype == TDENetworkSlaveDeviceType::Bond) {
865  ret = "bond";
866  }
867 
868  return ret;
869 }
870 
871 TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags nmPasswordFlagsToTDEPasswordFlags(unsigned int nm) {
872  TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags ret = TDENetworkPasswordHandlingFlags::None;
873 
874  if (nm & NM_PASSWORD_SECRET_AGENTOWNED) {
875  ret |= TDENetworkPasswordHandlingFlags::ExternalStorage;
876  }
877  if (nm & NM_PASSWORD_SECRET_NOTSAVED) {
878  ret |= TDENetworkPasswordHandlingFlags::NoSave;
879  }
880  if (nm & NM_PASSWORD_SECRET_NOTREQUIRED) {
881  ret |= TDENetworkPasswordHandlingFlags::NoPrompt;
882  }
883 
884  return ret;
885 }
886 
887 unsigned int tdePasswordFlagsToNMPasswordFlags(TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags flags) {
888  unsigned int ret = 0;
889 
890  if (flags & TDENetworkPasswordHandlingFlags::ExternalStorage) {
891  ret |= NM_PASSWORD_SECRET_AGENTOWNED;
892  }
893  if (flags & TDENetworkPasswordHandlingFlags::NoSave) {
894  ret |= NM_PASSWORD_SECRET_NOTSAVED;
895  }
896  if (flags & TDENetworkPasswordHandlingFlags::NoPrompt) {
897  ret |= NM_PASSWORD_SECRET_NOTREQUIRED;
898  }
899 
900  return ret;
901 }
902 
903 TDENetworkVLANFlags::TDENetworkVLANFlags nmVLANFlagsToTDEVLANFlags(unsigned int nm) {
904  TDENetworkVLANFlags::TDENetworkVLANFlags ret = TDENetworkVLANFlags::None;
905 
906  if (nm & NM_VLAN_REORDER_PACKET_HEADERS) {
907  ret |= TDENetworkVLANFlags::ReorderPacketHeaders;
908  }
909  if (nm & NM_VLAN_USE_GVRP) {
910  ret |= TDENetworkVLANFlags::UseGVRP;
911  }
912  if (nm & NM_VLAN_LOOSE_BINDING) {
913  ret |= TDENetworkVLANFlags::LooseBinding;
914  }
915 
916  return ret;
917 }
918 
919 unsigned int tdeVLANFlagsToNMVLANFlags(TDENetworkVLANFlags::TDENetworkVLANFlags flags) {
920  unsigned int ret = 0;
921 
922  if (flags & TDENetworkVLANFlags::ReorderPacketHeaders) {
923  ret |= NM_VLAN_REORDER_PACKET_HEADERS;
924  }
925  if (flags & TDENetworkVLANFlags::UseGVRP) {
926  ret |= NM_VLAN_USE_GVRP;
927  }
928  if (flags & TDENetworkVLANFlags::LooseBinding) {
929  ret |= NM_VLAN_LOOSE_BINDING;
930  }
931 
932  return ret;
933 }
934 
935 TDENetworkParity::TDENetworkParity nmParityToTDEParity(char nm) {
936  TDENetworkParity::TDENetworkParity ret = TDENetworkParity::None;
937 
938  if (nm == 'E') {
939  ret = TDENetworkParity::Even;
940  }
941  else if (nm == 'o') {
942  ret = TDENetworkParity::Odd;
943  }
944 
945  return ret;
946 }
947 
948 char tdeParityToNMParity(TDENetworkParity::TDENetworkParity parity) {
949  char ret = 'n';
950 
951  if (parity == TDENetworkParity::Even) {
952  ret = 'E';
953  }
954  else if (parity == TDENetworkParity::Odd) {
955  ret = 'o';
956  }
957 
958  return ret;
959 }
960 
961 TDENetworkWepKeyType::TDENetworkWepKeyType nmWepKeyTypeToTDEWepKeyType(unsigned int nm, TQString key=TQString::null) {
962  TDENetworkWepKeyType::TDENetworkWepKeyType ret = TDENetworkWepKeyType::Hexadecimal;
963 
964  if (nm == NM_WEP_TYPE_HEXADECIMAL) {
965  if (key.isNull()) {
966  ret = TDENetworkWepKeyType::Hexadecimal;
967  }
968  else {
969  if ((key.length() == 10) || (key.length() == 26)) {
970  ret = TDENetworkWepKeyType::Hexadecimal;
971  }
972  else {
973  ret = TDENetworkWepKeyType::Ascii;
974  }
975  }
976  }
977  else if (nm == NM_WEP_TYPE_PASSPHRASE) {
978  ret = TDENetworkWepKeyType::Passphrase;
979  }
980 
981  return ret;
982 }
983 
984 unsigned int tdeWepKeyTypeToNMWepKeyType(TDENetworkWepKeyType::TDENetworkWepKeyType type) {
985  unsigned int ret = 0;
986 
987  if (type == TDENetworkWepKeyType::Hexadecimal) {
988  ret = NM_WEP_TYPE_HEXADECIMAL;
989  }
990  else if (type == TDENetworkWepKeyType::Ascii) {
991  ret = NM_WEP_TYPE_HEXADECIMAL;
992  }
993  else if (type == TDENetworkWepKeyType::Passphrase) {
994  ret = NM_WEP_TYPE_PASSPHRASE;
995  }
996 
997  return ret;
998 }
999 
1000 TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags nmCapabilityFlagsToTDECapabilityFlags(unsigned int nm) {
1001  TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags ret = TDENetworkDeviceCapabilityFlags::None;
1002 
1003  if (nm & NM_DEVICE_CAP_NM_SUPPORTED) {
1004  ret |= TDENetworkDeviceCapabilityFlags::Supported;
1005  }
1006  if (nm & NM_DEVICE_CAP_CARRIER_DETECT) {
1007  ret |= TDENetworkDeviceCapabilityFlags::CanDetectLink;
1008  }
1009 
1010  return ret;
1011 }
1012 
1013 unsigned int tdeCapabilityFlagsToNMCapabilityFlags(TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags flags) {
1014  unsigned int ret = 0;
1015 
1016  if (flags & TDENetworkDeviceCapabilityFlags::Supported) {
1017  ret |= NM_DEVICE_CAP_NM_SUPPORTED;
1018  }
1019  if (flags & TDENetworkDeviceCapabilityFlags::CanDetectLink) {
1020  ret |= NM_DEVICE_CAP_CARRIER_DETECT;
1021  }
1022 
1023  return ret;
1024 }
1025 
1026 TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags nmAPSecFlagsToTDEAPSecFlags(unsigned int genflags, unsigned int nm) {
1027  TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags ret = TDENetworkWiFiAPFlags::None;
1028 
1029  if (genflags & NM_ACCESS_POINT_CAP_PRIVACY) {
1030  ret |= TDENetworkWiFiAPFlags::PrivacySupport;
1031  }
1032 
1033  if (nm & NM_ACCESS_POINT_SEC_PAIR_WEP40) {
1034  ret |= TDENetworkWiFiAPFlags::PairWEP40;
1035  }
1036  if (nm & NM_ACCESS_POINT_SEC_PAIR_WEP104) {
1037  ret |= TDENetworkWiFiAPFlags::PairWEP104;
1038  }
1039  if (nm & NM_ACCESS_POINT_SEC_PAIR_TKIP) {
1040  ret |= TDENetworkWiFiAPFlags::PairTKIP;
1041  }
1042  if (nm & NM_ACCESS_POINT_SEC_PAIR_CCMP) {
1043  ret |= TDENetworkWiFiAPFlags::PairCCMP;
1044  }
1045  if (nm & NM_ACCESS_POINT_SEC_GROUP_WEP40) {
1046  ret |= TDENetworkWiFiAPFlags::GroupWEP40;
1047  }
1048  if (nm & NM_ACCESS_POINT_SEC_GROUP_WEP104) {
1049  ret |= TDENetworkWiFiAPFlags::GroupWEP104;
1050  }
1051  if (nm & NM_ACCESS_POINT_SEC_GROUP_TKIP) {
1052  ret |= TDENetworkWiFiAPFlags::GroupTKIP;
1053  }
1054  if (nm & NM_ACCESS_POINT_SEC_GROUP_CCMP) {
1055  ret |= TDENetworkWiFiAPFlags::GroupCCMP;
1056  }
1057  if (nm & NM_ACCESS_POINT_SEC_KEY_MGMT_PSK) {
1058  ret |= TDENetworkWiFiAPFlags::KeyManagementPSK;
1059  }
1060  if (nm & NM_ACCESS_POINT_SEC_KEY_MGMT_802_1X) {
1061  ret |= TDENetworkWiFiAPFlags::KeyManagement80211;
1062  }
1063 
1064  return ret;
1065 }
1066 
1067 unsigned int tdeAPSecFlagsToNMAPGenSecFlags(TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags flags) {
1068  unsigned int ret = 0;
1069 
1070  if (flags & TDENetworkWiFiAPFlags::PrivacySupport) {
1071  ret |= NM_ACCESS_POINT_CAP_PRIVACY;
1072  }
1073 
1074  return ret;
1075 }
1076 
1077 unsigned int tdeAPSecFlagsToNMAPSecFlags(TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags flags) {
1078  unsigned int ret = 0;
1079 
1080  if (flags & TDENetworkWiFiAPFlags::PairWEP40) {
1081  ret |= NM_ACCESS_POINT_SEC_PAIR_WEP40;
1082  }
1083  if (flags & TDENetworkWiFiAPFlags::PairWEP104) {
1084  ret |= NM_ACCESS_POINT_SEC_PAIR_WEP104;
1085  }
1086  if (flags & TDENetworkWiFiAPFlags::PairTKIP) {
1087  ret |= NM_ACCESS_POINT_SEC_PAIR_TKIP;
1088  }
1089  if (flags & TDENetworkWiFiAPFlags::PairCCMP) {
1090  ret |= NM_ACCESS_POINT_SEC_PAIR_CCMP;
1091  }
1092  if (flags & TDENetworkWiFiAPFlags::GroupWEP40) {
1093  ret |= NM_ACCESS_POINT_SEC_GROUP_WEP40;
1094  }
1095  if (flags & TDENetworkWiFiAPFlags::GroupWEP104) {
1096  ret |= NM_ACCESS_POINT_SEC_GROUP_WEP104;
1097  }
1098  if (flags & TDENetworkWiFiAPFlags::GroupTKIP) {
1099  ret |= NM_ACCESS_POINT_SEC_GROUP_TKIP;
1100  }
1101  if (flags & TDENetworkWiFiAPFlags::GroupCCMP) {
1102  ret |= NM_ACCESS_POINT_SEC_GROUP_CCMP;
1103  }
1104  if (flags & TDENetworkWiFiAPFlags::KeyManagementPSK) {
1105  ret |= NM_ACCESS_POINT_SEC_KEY_MGMT_PSK;
1106  }
1107  if (flags & TDENetworkWiFiAPFlags::KeyManagement80211) {
1108  ret |= NM_ACCESS_POINT_SEC_KEY_MGMT_802_1X;
1109  }
1110 
1111  return ret;
1112 }
1113 
1114 TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode nmIBTransportToTDEIBTransport(TQString nm) {
1115  TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode ret = TDENetworkInfinibandTransportMode::Other;
1116 
1117  if (nm.lower() == "datagram") {
1118  ret = TDENetworkInfinibandTransportMode::Datagram;
1119  }
1120  else if (nm.lower() == "connected") {
1121  ret = TDENetworkInfinibandTransportMode::Connected;
1122  }
1123 
1124  return ret;
1125 }
1126 
1127 TQString tdeIBTransportToNMIBTransport(TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode mode) {
1128  TQString ret;
1129 
1130  if (mode == TDENetworkInfinibandTransportMode::Datagram) {
1131  ret = "datagram";
1132  }
1133  else if (mode == TDENetworkInfinibandTransportMode::Connected) {
1134  ret = "connected";
1135  }
1136 
1137  return ret;
1138 }
1139 
1140 TQString TDENetworkConnectionManager_BackendNM::deviceInterfaceString(TQString deviceNode) {
1141  if (d->m_networkManagerProxy) {
1142  TQT_DBusObjectPathList devices;
1143  TQT_DBusError error;
1144  bool ret;
1145  ret = d->m_networkManagerProxy->GetDevices(devices, error);
1146  if (ret) {
1147  TQT_DBusObjectPathList::iterator it;
1148  for (it = devices.begin(); it != devices.end(); ++it) {
1149  DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, (*it));
1150  genericDevice.setConnection(TQT_DBusConnection::systemBus());
1151  TQString deviceInterface = genericDevice.getInterface(error);
1152  if (error.isValid()) {
1153  // Error!
1154  PRINT_ERROR((error.name() + ": " + error.message()))
1155  break;
1156  }
1157  else if (deviceInterface == deviceNode) {
1158  return (*it);
1159  }
1160  }
1161  return "";
1162  }
1163  else {
1164  // Error!
1165  PRINT_ERROR((error.name() + ": " + error.message()))
1166  return "";
1167  }
1168  }
1169  else {
1170  return "";
1171  }
1172 }
1173 
1174 TQString tdeDeviceUUIDForGenericDevice(TQT_DBusObjectPath path) {
1175  TQT_DBusError error;
1176  DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, path);
1177  genericDevice.setConnection(TQT_DBusConnection::systemBus());
1178  TQString deviceInterface = genericDevice.getInterface(error);
1179  if (error.isValid()) {
1180  return TQString::null;
1181  }
1182 
1183  TDEHardwareDevices *hwdevices = TDEGlobal::hardwareDevices();
1184  if (!hwdevices) {
1185  return TQString::null;
1186  }
1187 
1188  TDEGenericHardwareList devices = hwdevices->listByDeviceClass(TDEGenericDeviceType::Network);
1189  for (TDEGenericHardwareList::iterator it = devices.begin(); it != devices.end(); ++it) {
1190  TDENetworkDevice* dev = dynamic_cast<TDENetworkDevice*>(*it);
1191  if (dev) {
1192  if (deviceInterface == dev->deviceNode()) {
1193  return dev->uniqueID();
1194  }
1195  }
1196  }
1197 
1198  return TQString::null;
1199 }
1200 
1201 TDENetworkConnectionManager_BackendNM_DBusSignalReceiver::TDENetworkConnectionManager_BackendNM_DBusSignalReceiver(TDENetworkConnectionManager_BackendNMPrivate* parent) : m_parent(parent) {
1202  //
1203 }
1204 
1205 TDENetworkConnectionManager_BackendNM_DBusSignalReceiver::~TDENetworkConnectionManager_BackendNM_DBusSignalReceiver() {
1206  //
1207 }
1208 
1209 void TDENetworkConnectionManager_BackendNM_DBusSignalReceiver::dbusSignal(const TQT_DBusMessage& message) {
1210  if (message.type() == TQT_DBusMessage::SignalMessage) {
1211  TQString interface = message.interface();
1212  TQString sender = message.sender();
1213  TQString member = message.member();
1214  TQString path = message.path();
1215 
1216 // printf("[DEBUG] In dbusSignal: sender: %s, member: %s, interface: %s, path: %s, parent path: %s\n", sender.ascii(), member.ascii(), interface.ascii(), path.ascii(), m_parent->m_dbusDeviceString.ascii()); fflush(stdout);
1217 
1218  if (interface == NM_VPN_DBUS_CONNECTION_SERVICE) {
1219  if (member == "VpnStateChanged") {
1220  // Demarshal data
1221  TQ_UINT32 state = message[0].toUInt32();
1222  TQ_UINT32 reason = message[1].toUInt32();
1223  if (state == NM_VPN_STATE_FAILED) {
1224  m_parent->internalProcessVPNFailure(reason);
1225  }
1226  }
1227  }
1228  else if (interface == NM_DBUS_DEVICE_SERVICE) {
1229  if (path == m_parent->m_dbusDeviceString) {
1230  if (member == "StateChanged") {
1231  // Demarshal data
1232  TQ_UINT32 new_state = message[0].toUInt32();
1233  TQ_UINT32 old_state = message[1].toUInt32();
1234  TQ_UINT32 reason = message[2].toUInt32();
1235  m_parent->internalProcessDeviceStateChanged(new_state, old_state, reason);
1236  }
1237  }
1238  }
1239  }
1240 }
1241 
1242 TDENetworkConnectionManager_BackendNM::TDENetworkConnectionManager_BackendNM(TDENetworkDevice* networkDevice) : TDENetworkConnectionManager(networkDevice) {
1243  d = new TDENetworkConnectionManager_BackendNMPrivate(this);
1244 
1245  // Set up proxy interfaces
1246  d->m_networkManagerProxy = new DBus::NetworkManagerProxy(NM_DBUS_SERVICE, NM_DBUS_PATH);
1247  d->m_networkManagerProxy->setConnection(TQT_DBusConnection::systemBus());
1248  d->m_networkManagerSettings = new DBus::SettingsInterface(NM_DBUS_SERVICE, NM_DBUS_PATH_SETTINGS);
1249  d->m_networkManagerSettings->setConnection(TQT_DBusConnection::systemBus());
1250  d->m_vpnProxy = new DBus::VPNPluginProxy(NM_VPN_DBUS_PLUGIN_SERVICE, NM_VPN_DBUS_PLUGIN_PATH);
1251  d->m_vpnProxy->setConnection(TQT_DBusConnection::systemBus());
1252 
1253  d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
1254  if (d->m_dbusDeviceString != "") {
1255  d->m_networkDeviceProxy = new DBus::DeviceProxy(NM_DBUS_SERVICE, d->m_dbusDeviceString);
1256  d->m_networkDeviceProxy->setConnection(TQT_DBusConnection::systemBus());
1257  if (deviceType() == TDENetworkDeviceType::WiFi) {
1258  d->m_wiFiDeviceProxy = new DBus::WiFiDeviceProxy(NM_DBUS_SERVICE, d->m_dbusDeviceString);
1259  d->m_wiFiDeviceProxy->setConnection(TQT_DBusConnection::systemBus());
1260  }
1261  }
1262 
1263  // Connect global signals
1264  connect(d->m_networkManagerProxy, SIGNAL(StateChanged(TQ_UINT32)), d, SLOT(internalProcessGlobalStateChanged(TQ_UINT32)));
1265 
1266  // Connect VPN signals
1267  if (d->m_vpnProxy) {
1268  connect(d->m_vpnProxy, SIGNAL(StateChanged(TQ_UINT32)), d, SLOT(internalProcessVPNStateChanged(TQ_UINT32)));
1269  connect(d->m_vpnProxy, SIGNAL(LoginBanner(const TQString&)), d, SLOT(internalProcessVPNLoginBanner(const TQString&)));
1270  connect(d->m_vpnProxy, SIGNAL(Failure(TQ_UINT32)), d, SLOT(internalProcessVPNFailure(TQ_UINT32)));
1271  }
1272 
1273  // Connect local signals
1274  if (d->m_networkDeviceProxy) {
1275  connect(d->m_networkDeviceProxy, SIGNAL(StateChanged(TQ_UINT32, TQ_UINT32, TQ_UINT32)), d, SLOT(internalProcessDeviceStateChanged(TQ_UINT32, TQ_UINT32, TQ_UINT32)));
1276  }
1277  if (d->m_wiFiDeviceProxy) {
1278  connect(d->m_wiFiDeviceProxy, SIGNAL(AccessPointAdded(const TQT_DBusObjectPath&)), d, SLOT(internalProcessWiFiAccessPointAdded(const TQT_DBusObjectPath&)));
1279  connect(d->m_wiFiDeviceProxy, SIGNAL(AccessPointRemoved(const TQT_DBusObjectPath&)), d, SLOT(internalProcessWiFiAccessPointRemoved(const TQT_DBusObjectPath&)));
1280  connect(d->m_wiFiDeviceProxy, SIGNAL(PropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)), d, SLOT(internalProcessWiFiPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)));
1281  }
1282 
1283  // Create public lists
1284  m_connectionList = new TDENetworkConnectionList;
1285  m_hwNeighborList = new TDENetworkHWNeighborList;
1286 
1287  // Run site survey to populate neighbor list with initial data
1288  siteSurvey();
1289 }
1290 
1291 TDENetworkConnectionManager_BackendNM::~TDENetworkConnectionManager_BackendNM() {
1292  // Destroy public lists
1293  clearTDENetworkConnectionList();
1294  delete m_connectionList;
1295  clearTDENetworkHWNeighborList();
1296  delete m_hwNeighborList;
1297 
1298  // Tear down proxy interfaces
1299  if (d->m_networkManagerProxy) delete d->m_networkManagerProxy;
1300  if (d->m_networkManagerSettings) delete d->m_networkManagerSettings;
1301  if (d->m_networkDeviceProxy) delete d->m_networkDeviceProxy;
1302 
1303  delete d;
1304 }
1305 
1306 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessGlobalStateChanged(TQ_UINT32 state) {
1307  m_parent->internalNetworkConnectionStateChanged(m_parent->backendStatus());
1308 }
1309 
1310 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessVPNStateChanged(TQ_UINT32 state) {
1311  m_parent->internalNetworkConnectionStateChanged(m_parent->backendStatus());
1312 }
1313 
1314 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessVPNLoginBanner(const TQString& banner) {
1315  m_parent->internalVpnEvent(TDENetworkVPNEventType::LoginBanner, banner);
1316 }
1317 
1318 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessVPNFailure(TQ_UINT32 reason) {
1319  // FIXME
1320  // This should provide a plain-text interpretation of the NetworkManager-specific error code
1321  m_parent->internalVpnEvent(TDENetworkVPNEventType::Failure, TQString("VPN connection attempt failed!<br>NetworkManager returned error %1.").arg(reason));
1322 }
1323 
1324 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessDeviceStateChanged(TQ_UINT32 newState, TQ_UINT32 oldState, TQ_UINT32 reason) {
1325  Q_UNUSED(oldState)
1326 
1327  if (m_prevDeviceState == newState) return;
1328  m_prevDeviceState = newState;
1329 
1330  if (newState == NM_DEVICE_STATE_FAILED) {
1331  TQString errorString;
1332  if (reason == NM_DEVICE_STATE_REASON_NONE) {
1333  errorString = TQString("Connection attempt failed!");
1334  }
1335  else if (reason == NM_DEVICE_STATE_REASON_UNKNOWN) {
1336  errorString = TQString("Connection attempt failed!<br>Unknown error detected.");
1337  }
1338  else if (reason == NM_DEVICE_STATE_REASON_NOW_MANAGED) {
1339  errorString = TQString("Connection attempt failed!<br>Network device is now managed.");
1340  }
1341  else if (reason == NM_DEVICE_STATE_REASON_NOW_UNMANAGED) {
1342  errorString = TQString("Connection attempt failed!<br>Network device is now unmanaged.");
1343  }
1344  else if (reason == NM_DEVICE_STATE_REASON_CONFIG_FAILED) {
1345  errorString = TQString("Connection attempt failed!<br>Configuration failed.");
1346  }
1347  else if (reason == NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE) {
1348  errorString = TQString("Connection attempt failed!<br>IP configuration unavailable.");
1349  }
1350  else if (reason == NM_DEVICE_STATE_REASON_IP_CONFIG_EXPIRED) {
1351  errorString = TQString("Connection attempt failed!<br>IP configuration expired.");
1352  }
1353  else if (reason == NM_DEVICE_STATE_REASON_NO_SECRETS) {
1354  errorString = i18n("Connection attempt failed!<br>Secrets were required to establish a connection, but no secrets were available.");
1355  }
1356  else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT) {
1357  errorString = TQString("Connection attempt failed!<br>The supplicant was disconnected while attempting to establish a wireless connection.");
1358  }
1359  else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_CONFIG_FAILED) {
1360  errorString = TQString("Connection attempt failed!<br>Supplicant configuration failed while attempting to establish a wireless connection.");
1361  }
1362  else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED) {
1363  errorString = i18n("Connection attempt failed!<br>The supplicant failed while attempting to establish a wireless connection.");
1364  }
1365  else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_TIMEOUT) {
1366  errorString = i18n("Connection attempt failed!<br>The supplicant timed out while attempting to establish a wireless connection.");
1367  }
1368  else if (reason == NM_DEVICE_STATE_REASON_PPP_START_FAILED) {
1369  errorString = i18n("Connection attempt failed!<br>The PPP client failed to start.");
1370  }
1371  else if (reason == NM_DEVICE_STATE_REASON_PPP_DISCONNECT) {
1372  errorString = i18n("Connection attempt failed!<br>The PPP client was disconnected.");
1373  }
1374  else if (reason == NM_DEVICE_STATE_REASON_PPP_FAILED) {
1375  errorString = i18n("Connection attempt failed!<br>Unknown PPP failure.");
1376  }
1377  else if (reason == NM_DEVICE_STATE_REASON_DHCP_START_FAILED) {
1378  errorString = i18n("Connection attempt failed!<br>The DHCP client failed to start.");
1379  }
1380  else if (reason == NM_DEVICE_STATE_REASON_DHCP_ERROR) {
1381  errorString = i18n("Connection attempt failed!<br>The DHCP client encountered an error.");
1382  }
1383  else if (reason == NM_DEVICE_STATE_REASON_DHCP_FAILED) {
1384  errorString = i18n("Connection attempt failed!<br>Uknown DHCP failure.");
1385  }
1386  else if (reason == NM_DEVICE_STATE_REASON_SHARED_START_FAILED) {
1387  errorString = i18n("Connection attempt failed!<br>The connection sharing service failed to start.");
1388  }
1389  else if (reason == NM_DEVICE_STATE_REASON_SHARED_FAILED) {
1390  errorString = i18n("Connection attempt failed!<br>The connection sharing service encountered an error.");
1391  }
1392  else if (reason == NM_DEVICE_STATE_REASON_AUTOIP_START_FAILED) {
1393  errorString = i18n("Connection attempt failed!<br>The AutoIP service failed to start.");
1394  }
1395  else if (reason == NM_DEVICE_STATE_REASON_AUTOIP_ERROR) {
1396  errorString = i18n("Connection attempt failed!<br>The AutoIP service encountered an error.");
1397  }
1398  else if (reason == NM_DEVICE_STATE_REASON_AUTOIP_FAILED) {
1399  errorString = i18n("Connection attempt failed!<br>Unknown AutoIP failure.");
1400  }
1401  else if (reason == NM_DEVICE_STATE_REASON_MODEM_BUSY) {
1402  errorString = i18n("Connection attempt failed!<br>Modem was busy.");
1403  }
1404  else if (reason == NM_DEVICE_STATE_REASON_MODEM_NO_DIAL_TONE) {
1405  errorString = i18n("Connection attempt failed!<br>No dial tone.");
1406  }
1407  else if (reason == NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER) {
1408  errorString = i18n("Connection attempt failed!<br>No carrier detected.");
1409  }
1410  else if (reason == NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT) {
1411  errorString = i18n("Connection attempt failed!<br>Modem timed out while dialing.");
1412  }
1413  else if (reason == NM_DEVICE_STATE_REASON_MODEM_DIAL_FAILED) {
1414  errorString = i18n("Connection attempt failed!<br>The modem failed to dial.");
1415  }
1416  else if (reason == NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED) {
1417  errorString = i18n("Connection attempt failed!<br>Modem initialization failed.");
1418  }
1419  else if (reason == NM_DEVICE_STATE_REASON_GSM_APN_FAILED) {
1420  errorString = i18n("Connection attempt failed!<br>GSM APN failure.");
1421  }
1422  else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING) {
1423  errorString = i18n("Connection attempt failed!<br>GSM registration failed to search for networks.");
1424  }
1425  else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED) {
1426  errorString = i18n("Connection attempt failed!<br>GSM registration attempt was rejected.");
1427  }
1428  else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_TIMEOUT) {
1429  errorString = i18n("Connection attempt failed!<br>GSM registration attempt timed out.");
1430  }
1431  else if (reason == NM_DEVICE_STATE_REASON_GSM_REGISTRATION_FAILED) {
1432  errorString = i18n("Connection attempt failed!<br>GSM registration attempt failed.");
1433  }
1434  else if (reason == NM_DEVICE_STATE_REASON_GSM_PIN_CHECK_FAILED) {
1435  errorString = i18n("Connection attempt failed!<br>GSM PIN check failed.");
1436  }
1437  else if (reason == NM_DEVICE_STATE_REASON_FIRMWARE_MISSING) {
1438  errorString = i18n("Connection attempt failed!<br>Network device firmware is missing.");
1439  }
1440  else if (reason == NM_DEVICE_STATE_REASON_REMOVED) {
1441  errorString = i18n("Connection attempt failed!<br>Network device was removed.");
1442  }
1443  else if (reason == NM_DEVICE_STATE_REASON_SLEEPING) {
1444  errorString = i18n("Connection attempt failed!<br>Network device is sleeping.");
1445  }
1446  else if (reason == NM_DEVICE_STATE_REASON_CONNECTION_REMOVED) {
1447  errorString = i18n("Connection attempt failed!<br>Connection was removed.");
1448  }
1449  else if (reason == NM_DEVICE_STATE_REASON_USER_REQUESTED) {
1450  errorString = i18n("Connection attempt failed!<br>User requested device disconnection.");
1451  }
1452  else if (reason == NM_DEVICE_STATE_REASON_CARRIER) {
1453  errorString = i18n("Connection attempt failed!<br>Carrier or link status changed.");
1454  }
1455  else if (reason == NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED) {
1456  errorString = i18n("Connection attempt failed!<br>Device and/or connection already active.");
1457  }
1458  else if (reason == NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE) {
1459  errorString = i18n("Connection attempt failed!<br>The supplicant is now available.");
1460  }
1461  else if (reason == NM_DEVICE_STATE_REASON_MODEM_NOT_FOUND) {
1462  errorString = i18n("Connection attempt failed!<br>Requested modem was not found.");
1463  }
1464  else if (reason == NM_DEVICE_STATE_REASON_BT_FAILED) {
1465  errorString = i18n("Connection attempt failed!<br>Bluetooth connection timeout.");
1466  }
1467  else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED) {
1468  errorString = i18n("Connection attempt failed!<br>GSM SIM not inserted.");
1469  }
1470  else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED) {
1471  errorString = i18n("Connection attempt failed!<br>GSM PIN required.");
1472  }
1473  else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED) {
1474  errorString = i18n("Connection attempt failed!<br>GSM PUK required.");
1475  }
1476  else if (reason == NM_DEVICE_STATE_REASON_GSM_SIM_WRONG) {
1477  errorString = i18n("Connection attempt failed!<br>GSM SIM incorrect.");
1478  }
1479  else if (reason == NM_DEVICE_STATE_REASON_INFINIBAND_MODE) {
1480  errorString = i18n("Connection attempt failed!<br>Incorrect Infiniband mode.");
1481  }
1482  else if (reason == NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED) {
1483  errorString = i18n("Connection attempt failed!<br>Dependency failure.");
1484  }
1485  else if (reason == NM_DEVICE_STATE_REASON_BR2684_FAILED) {
1486  errorString = i18n("Connection attempt failed!<br>Unknown bridge failure.");
1487  }
1488  else if (reason == NM_DEVICE_STATE_REASON_MODEM_MANAGER_UNAVAILABLE) {
1489  errorString = i18n("Connection attempt failed!<br>ModemManager not available.");
1490  }
1491  else if (reason == NM_DEVICE_STATE_REASON_SSID_NOT_FOUND) {
1492  errorString = i18n("Connection attempt failed!<br>SSID not found.");
1493  }
1494  else if (reason == NM_DEVICE_STATE_REASON_SECONDARY_CONNECTION_FAILED) {
1495  errorString = i18n("Connection attempt failed!<br>Secondary connection failure.");
1496  }
1497  else {
1498  // FIXME
1499  // This should provide a plain-text interpretation of the NetworkManager-specific error code
1500  errorString = TQString("Connection attempt failed!<br>NetworkManager returned error %1.").arg(reason);
1501  }
1502  m_parent->internalNetworkDeviceEvent(TDENetworkDeviceEventType::Failure, errorString);
1503  }
1504 
1505  m_parent->internalNetworkDeviceStateChanged(nmDeviceStateToTDEDeviceState(newState), m_parent->deviceNode());
1506 }
1507 
1508 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessWiFiAccessPointAdded(const TQT_DBusObjectPath& dbuspath) {
1509  TDENetworkWiFiAPInfo* apInfo = m_parent->getAccessPointDetails(dbuspath);
1510  if (apInfo) {
1511  if (!m_accessPointProxyList.contains(dbuspath)) {
1512  // Set up monitoring object
1513  DBus::AccessPointProxy* apProxy = new DBus::AccessPointProxy(NM_DBUS_SERVICE, dbuspath);
1514  apProxy->setConnection(TQT_DBusConnection::systemBus());
1515  connect(apProxy, SIGNAL(PropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)), this, SLOT(internalProcessAPPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>&)));
1516  m_accessPointProxyList[dbuspath] = (apProxy);
1517 
1518  // Notify client applications
1519  m_parent->internalAccessPointStatusChanged(apInfo->BSSID, TDENetworkAPEventType::Discovered);
1520  }
1521  delete apInfo;
1522  }
1523 }
1524 
1525 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessWiFiAccessPointRemoved(const TQT_DBusObjectPath& dbuspath) {
1526  TDENetworkWiFiAPInfo* apInfo = m_parent->getAccessPointDetails(dbuspath);
1527  if (apInfo) {
1528  // Notify client applications
1529  m_parent->internalAccessPointStatusChanged(apInfo->BSSID, TDENetworkAPEventType::Lost);
1530  delete apInfo;
1531 
1532  // Destroy related monitoring object
1533  DBus::AccessPointProxy* apProxy = m_accessPointProxyList[dbuspath];
1534  m_accessPointProxyList.remove(dbuspath);
1535  if (apProxy) {
1536  delete apProxy;
1537  }
1538  }
1539 }
1540 
1541 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessWiFiPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>& props) {
1542  if (m_wiFiDeviceProxy) {
1543  if (props.contains("ActiveAccessPoint")) {
1544  TQT_DBusError error;
1545  TDENetworkWiFiAPInfo* apInfo = m_parent->getAccessPointDetails(m_wiFiDeviceProxy->getActiveAccessPoint(error));
1546  if (apInfo) {
1547  m_parent->internalAccessPointStatusChanged(apInfo->BSSID, TDENetworkAPEventType::AccessPointChanged);
1548  }
1549  }
1550  else if (props.contains("Bitrate")) {
1551  m_parent->internalNetworkDeviceEvent(TDENetworkDeviceEventType::BitRateChanged, TQString::null);
1552  }
1553  }
1554 }
1555 
1556 void TDENetworkConnectionManager_BackendNMPrivate::internalProcessAPPropertiesChanged(const TQMap<TQString, TQT_DBusVariant>& props) {
1557  const DBus::AccessPointProxy* apProxy = dynamic_cast<const DBus::AccessPointProxy*>(sender());
1558  if (apProxy) {
1559  TQT_DBusError error;
1560  TDEMACAddress BSSID;
1561  BSSID.fromString(apProxy->getHwAddress(error));
1562  if (props.contains("Strength")) {
1563  m_parent->internalAccessPointStatusChanged(BSSID, TDENetworkAPEventType::SignalStrengthChanged);
1564  }
1565  }
1566 }
1567 
1568 TDENetworkDeviceType::TDENetworkDeviceType TDENetworkConnectionManager_BackendNM::deviceType() {
1569  if (!m_networkDevice) {
1570  return TDENetworkDeviceType::BackendOnly;
1571  }
1572  else {
1573  if (d->m_dbusDeviceString != "") {
1574  // Query NM for the device type
1575  TQT_DBusError error;
1576  d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
1577  DBus::DeviceProxy genericDevice(NM_DBUS_SERVICE, d->m_dbusDeviceString);
1578  genericDevice.setConnection(TQT_DBusConnection::systemBus());
1579  TDENetworkDeviceType::TDENetworkDeviceType ret = nmDeviceTypeToTDEDeviceType(genericDevice.getDeviceType(error));
1580  if (error.isValid()) {
1581  // Error!
1582  PRINT_ERROR((error.name() + ": " + error.message()))
1583  return TDENetworkDeviceType::Other;
1584  }
1585  else {
1586  return ret;
1587  }
1588  }
1589  else {
1590  // Error!
1591  PRINT_ERROR(TQString("Invalid DBUS device string '%1'").arg(d->m_dbusDeviceString))
1592  return TDENetworkDeviceType::Other;
1593  }
1594  }
1595 }
1596 
1597 TDENetworkConnectionType::TDENetworkConnectionType TDENetworkConnectionManager_BackendNM::connectionType(TQString dbusPath) {
1598  TDENetworkConnectionType::TDENetworkConnectionType connType = TDENetworkConnectionType::Other;
1599  TQ_UINT32 ret;
1600  TQT_DBusError error;
1601 
1602 #ifndef USE_ASYNC_DBUS_CALLS
1603  // Obtain connection settings from the path specified
1604  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
1605  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
1606  TQT_DBusTQStringDataMap connectionSettingsMap;
1607  ret = connectionSettings.GetSettings(connectionSettingsMap, error);
1608  if (ret && error.isValid()) {
1609  ret = 0;
1610  PRINT_ERROR((error.name() + ": " + error.message()))
1611  }
1612  if (ret) {
1613 #else // USE_ASYNC_DBUS_CALLS
1614  // Obtain connection settings from the path specified
1615  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
1616  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
1617  connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
1618  int asyncCallID;
1619  ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
1620  if (ret && error.isValid()) {
1621  ret = 0;
1622  PRINT_ERROR((error.name() + ": " + error.message()))
1623  }
1624  if (ret) {
1625  // Wait for the asynchronous call to return...
1626  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
1627  TQTimer nmCallTimeoutTimer;
1628  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
1629  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
1630  tqApp->processEvents();
1631  if (!nmCallTimeoutTimer.isActive()) {
1632  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
1633  break;
1634  }
1635  }
1636  TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
1637  if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
1638  PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
1639  d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
1640  }
1641  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
1642  if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
1643  d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
1644  }
1645 #endif // USE_ASYNC_DBUS_CALLS
1646 
1647  // Parse settings to find connection type
1648  TQT_DBusTQStringDataMap::const_iterator it2;
1649  for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
1650  TQString outerKeyValue = it2.key();
1651  TQT_DBusData dataValue = it2.data();
1652 
1653  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
1654  TQT_DBusTQStringDataMap::const_iterator it3;
1655  for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
1656  TQString keyValue = it3.key();
1657  TQT_DBusData dataValue = it3.data();
1658  if (dataValue.type() == TQT_DBusData::Variant) {
1659  TQT_DBusVariant dataValueVariant = dataValue.toVariant();
1660  TQT_DBusData dataValue2 = dataValueVariant.value;
1661  if (dataValue2.type() != TQT_DBusData::Variant) {
1662  if (outerKeyValue.lower() == "connection") {
1663  if (keyValue.lower() == "type") {
1664  connType = nmConnectionTypeToTDEConnectionType(dataValue2.toString());
1665  }
1666  }
1667  }
1668  }
1669  }
1670  }
1671  }
1672 
1673  return connType;
1674 }
1675 
1676 TQString TDENetworkConnectionManager_BackendNM::backendName() {
1677  return i18n("NetworkManager");
1678 }
1679 
1680 TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags TDENetworkConnectionManager_BackendNM::backendStatus() {
1681  if (d->m_networkManagerProxy) {
1682  TQ_UINT32 ret;
1683  TQT_DBusError error;
1684  ret = d->m_networkManagerProxy->getState(error);
1685  if (error.isValid()) {
1686  // Error!
1687  PRINT_ERROR((error.name() + ": " + error.message()))
1688  return TDENetworkGlobalManagerFlags::BackendUnavailable;
1689  }
1690  else {
1691  TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags globalFlags = nmGlobalStateToTDEGlobalState(ret);
1692  TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags vpnFlags = TDENetworkGlobalManagerFlags::Unknown;
1693  if (d->m_vpnProxy) {
1694  ret = d->m_vpnProxy->getState(error);
1695  if (error.isValid()) {
1696  // Error!
1697  bool print_error = true;
1698  if (error.name() == "org.freedesktop.DBus.Error.ServiceUnknown") {
1699  if (d->vpn_service_error_notified) {
1700  print_error = false;
1701  }
1702  else {
1703  d->vpn_service_error_notified = true;
1704  }
1705  }
1706  if (print_error) {
1707  PRINT_ERROR(TQString("Attempting to access the network-manager VPN service returned: %1").arg(error.name() + ": " + error.message()))
1708  }
1709  vpnFlags = TDENetworkGlobalManagerFlags::VPNUnknown;
1710  }
1711  else {
1712  vpnFlags = nmVPNStateToTDEGlobalState(ret);
1713  }
1714  }
1715  return globalFlags | vpnFlags;
1716  }
1717  }
1718  else {
1719  return TDENetworkGlobalManagerFlags::BackendUnavailable;
1720  }
1721 }
1722 
1723 TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceInformation() {
1724  TQT_DBusError error;
1725  TDENetworkDeviceInformation ret;
1726 
1727  if (d->m_networkDeviceProxy) {
1728  ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
1729  ret.UUID = d->m_networkDeviceProxy->getUdi(error);
1730  ret.backendDriver = d->m_networkDeviceProxy->getDriver(error);
1731  ret.backendDriverVersion = d->m_networkDeviceProxy->getDriverVersion(error);
1732  ret.firmwareVersion = d->m_networkDeviceProxy->getFirmwareVersion(error);
1733  ret.capabilityFlags = nmCapabilityFlagsToTDECapabilityFlags(d->m_networkDeviceProxy->getCapabilities(error));
1734  // ipConfiguration is not filled in, as the TDE HW library provides complementary functionality and is more reliable/easier to use and maintain
1735  ret.managed = d->m_networkDeviceProxy->getManaged(error);
1736  ret.autoConnect = d->m_networkDeviceProxy->getAutoconnect(error);
1737  ret.firmwareMissing = d->m_networkDeviceProxy->getFirmwareMissing(error);
1738  ret.deviceType = nmDeviceTypeToTDEDeviceType(d->m_networkDeviceProxy->getDeviceType(error));
1739  if (error.isValid()) {
1740  // Error!
1741  bool print_error = true;
1742  if (error.name() == "org.freedesktop.DBus.Error.AccessDenied") {
1743  if (error.message().contains("org.freedesktop.NetworkManager.Device")) {
1744  // Unable to determine if device allows autoconnect
1745  // Assume true!
1746  ret.autoConnect = true;
1747  if (d->device_autoconnect_error_notified) {
1748  print_error = false;
1749  }
1750  else {
1751  d->device_autoconnect_error_notified = true;
1752  }
1753  }
1754  }
1755  if (print_error) {
1756  PRINT_ERROR((error.name() + ": " + error.message()))
1757  }
1758 
1759  // Reset error object to avoid spurious error messages on the command line
1760  error = TQT_DBusError();
1761  }
1762 
1763  // Populate wiFiInfo
1764  if ((deviceType() == TDENetworkDeviceType::WiFi) && (d->m_wiFiDeviceProxy)) {
1765  ret.wiFiInfo.valid = true;
1766  ret.wiFiInfo.hwAddress.fromString(d->m_wiFiDeviceProxy->getHwAddress(error));
1767  ret.wiFiInfo.permanentHWAddress.fromString(d->m_wiFiDeviceProxy->getPermHwAddress(error));
1768  ret.wiFiInfo.operatingMode = nmWiFiModeToTDEWiFiMode(d->m_wiFiDeviceProxy->getMode(error));
1769  ret.wiFiInfo.bitrate = d->m_wiFiDeviceProxy->getBitrate(error);
1770  TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(d->m_wiFiDeviceProxy->getActiveAccessPoint(error));
1771  if (error.isValid()) {
1772  PRINT_ERROR((error.name() + ": " + error.message()))
1773 
1774  // Reset error object to avoid spurious error messages on the command line
1775  error = TQT_DBusError();
1776  }
1777  if (apInfo) {
1778  ret.wiFiInfo.activeAccessPointBSSID = apInfo->BSSID;
1779  TDENetworkWiFiAPInfo* neighborListAPInfo = findAccessPointByBSSID(ret.wiFiInfo.activeAccessPointBSSID);
1780  if (neighborListAPInfo) {
1781  *neighborListAPInfo = *apInfo;
1782  }
1783  delete apInfo;
1784  }
1785  else {
1786  ret.wiFiInfo.activeAccessPointBSSID = TDEMACAddress();
1787  }
1788  ret.wiFiInfo.wirelessFlags = tdeWiFiFlagsToNMWiFiFlags(d->m_wiFiDeviceProxy->getWirelessCapabilities(error));
1789  }
1790  else {
1791  ret.wiFiInfo.valid = false;
1792  }
1793 
1794  // Get active connection UUID
1795  TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
1796  if (!error.isValid()) {
1797  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
1798  activeConnection.setConnection(TQT_DBusConnection::systemBus());
1799  ret.activeConnectionUUID = activeConnection.getUuid(error);
1800  if (error.isValid()) {
1801  ret.activeConnectionUUID = TQString::null;
1802  }
1803  }
1804 
1805  ret.valid = true;
1806  }
1807 
1808  return ret;
1809 }
1810 
1811 TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceStatus() {
1812  TQT_DBusError error;
1813  TDENetworkDeviceInformation ret;
1814 
1815  if (d->m_networkDeviceProxy) {
1816  ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
1817  ret.UUID = d->m_networkDeviceProxy->getUdi(error);
1818 
1819  // Get active connection UUID
1820  TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
1821  if (!error.isValid()) {
1822  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
1823  activeConnection.setConnection(TQT_DBusConnection::systemBus());
1824  ret.activeConnectionUUID = activeConnection.getUuid(error);
1825  if (error.isValid()) {
1826  ret.activeConnectionUUID = TQString::null;
1827  }
1828  }
1829 
1830  ret.valid = true;
1831  }
1832 
1833  return ret;
1834 }
1835 
1836 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncReply(int asyncCallId, const TQT_DBusDataMap<TQString>& settings) {
1837  nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
1838  nmConnectionSettingsAsyncSettingsResponse[asyncCallId] = settings;
1839 }
1840 
1841 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncReply(int asyncCallId) {
1842  nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
1843 }
1844 
1845 void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncReply(int asyncCallId, const TQT_DBusObjectPath& path) {
1846  nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
1847  nmAddConnectionAsyncResponse[asyncCallId] = path;
1848 }
1849 
1850 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncError(int asyncCallId, const TQT_DBusError error) {
1851  nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallId] = error;
1852 }
1853 
1854 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncError(int asyncCallId, const TQT_DBusError error) {
1855  nmConnectionSettingsUpdateAsyncSettingsErrorResponse[asyncCallId] = error;
1856 }
1857 
1858 void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncError(int asyncCallId, const TQT_DBusError error) {
1859  nmAddConnectionAsyncErrorResponse[asyncCallId] = error;
1860 }
1861 
1862 void TDENetworkConnectionManager_BackendNM::loadConnectionInformation() {
1863  if (d->nonReentrantCallActive) return;
1864 
1865  d->nonReentrantCallActive = true;
1866 
1867  TDEMACAddress deviceMACAddress;
1868  deviceMACAddress.fromString(this->deviceMACAddress());
1869 
1870  if (d->m_networkManagerSettings) {
1871  clearTDENetworkConnectionList();
1872  TQT_DBusObjectPathList connections;
1873  TQT_DBusError error;
1874  bool ret;
1875  int state;
1876  ret = d->m_networkManagerSettings->ListConnections(connections, error);
1877  if (ret) {
1878  TQT_DBusObjectPathList::iterator it;
1879  for (it = connections.begin(); it != connections.end(); ++it) {
1880  TDENetworkConnection* connection;
1881  TDEWiredEthernetConnection* ethernetConnection = NULL;
1882  TDEWiredInfinibandConnection* infinibandConnection = NULL;
1883  TDEWiFiConnection* wiFiConnection = NULL;
1884  TDEVPNConnection* vpnConnection = NULL;
1885  TDEWiMaxConnection* wiMaxConnection = NULL;
1886  TDEVLANConnection* vlanConnection = NULL;
1887  TDEOLPCMeshConnection* olpcMeshConnection = NULL;
1888  TDEBluetoothConnection* bluetoothConnection = NULL;
1889  TDEModemConnection* modemConnection = NULL;
1890  TDENetworkConnectionType::TDENetworkConnectionType connType = connectionType((*it));
1891  if (connType == TDENetworkConnectionType::WiredEthernet) {
1892  connection = ethernetConnection = new TDEWiredEthernetConnection;
1893  }
1894  else if (connType == TDENetworkConnectionType::Infiniband) {
1895  connection = infinibandConnection = new TDEWiredInfinibandConnection;
1896  }
1897  else if (connType == TDENetworkConnectionType::WiFi) {
1898  connection = wiFiConnection = new TDEWiFiConnection;
1899  }
1900  else if (connType == TDENetworkConnectionType::VPN) {
1901  connection = vpnConnection = new TDEVPNConnection;
1902  }
1903  else if (connType == TDENetworkConnectionType::WiMax) {
1904  connection = wiMaxConnection = new TDEWiMaxConnection;
1905  }
1906  else if (connType == TDENetworkConnectionType::VLAN) {
1907  connection = vlanConnection = new TDEVLANConnection;
1908  }
1909  else if (connType == TDENetworkConnectionType::OLPCMesh) {
1910  connection = olpcMeshConnection = new TDEOLPCMeshConnection;
1911  }
1912  else if (connType == TDENetworkConnectionType::Bluetooth) {
1913  connection = bluetoothConnection = new TDEBluetoothConnection;
1914  }
1915  else if (connType == TDENetworkConnectionType::Modem) {
1916  connection = modemConnection = new TDEModemConnection;
1917  }
1918  else {
1919  connection = new TDENetworkConnection;
1920  }
1921  // Set up defaults
1922  connection->ipConfig.connectionFlags = TDENetworkIPConfigurationFlags::IPV4DHCPIP | \
1923  TDENetworkIPConfigurationFlags::IPV4DHCPDNS | \
1924  TDENetworkIPConfigurationFlags::IPV4DHCPRoutes | \
1925  TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute | \
1926  TDENetworkIPConfigurationFlags::IPV6DHCPIP | \
1927  TDENetworkIPConfigurationFlags::IPV6DHCPDNS | \
1928  TDENetworkIPConfigurationFlags::IPV6DHCPRoutes | \
1929  TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
1930  // Set up NM-specific defaults
1931  // Keep in sync with latest NM default settings!
1932  // NM 0.9 setting descriptions and default values are available at:
1933  // http://projects.gnome.org/NetworkManager/developers/api/09/ref-settings.html
1934  connection->autoConnect = true;
1935 
1936  if (wiFiConnection) {
1937  wiFiConnection->securitySettings.authType = TDENetworkWiFiAuthType::Open;
1938  }
1939 
1940 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
1941  printf("[network-manager comm debug] %s\n", (*it).data()); fflush(stdout);
1942 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
1943 
1944 #ifndef USE_ASYNC_DBUS_CALLS
1945  // Obtain connection settings from the path specified
1946  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
1947  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
1948  TQT_DBusTQStringDataMap connectionSettingsMap;
1949  ret = connectionSettings.GetSettings(connectionSettingsMap, error);
1950  if (ret && error.isValid()) {
1951  ret = 0;
1952  PRINT_ERROR((error.name() + ": " + error.message()))
1953  }
1954  if (ret) {
1955 #else // USE_ASYNC_DBUS_CALLS
1956  // Obtain connection settings from the path specified
1957  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
1958  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
1959  connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
1960  connect(&connectionSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processConnectionSettingsAsyncError(int, const TQT_DBusError)));
1961  int asyncCallID;
1962  ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
1963  if (ret && error.isValid()) {
1964  ret = 0;
1965  PRINT_ERROR((error.name() + ": " + error.message()))
1966  }
1967  if (ret) {
1968  // Wait for the asynchronous call to return...
1969  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
1970  TQTimer nmCallTimeoutTimer;
1971  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
1972  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
1973  tqApp->processEvents();
1974  if (!nmCallTimeoutTimer.isActive()) {
1975  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
1976  break;
1977  }
1978  }
1979  TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
1980  if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
1981  PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
1982  d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
1983  }
1984  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
1985  if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
1986  d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
1987  }
1988 #endif // USE_ASYNC_DBUS_CALLS
1989 
1990 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
1991  printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
1992  printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
1993 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
1994 
1995  // Parse settings
1996  TQT_DBusTQStringDataMap::const_iterator it2;
1997  for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
1998  TQString outerKeyValue = it2.key();
1999  TQT_DBusData dataValue = it2.data();
2000 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2001  printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
2002 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2003  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
2004  TQT_DBusTQStringDataMap::const_iterator it3;
2005  for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
2006  TQString keyValue = it3.key();
2007  TQT_DBusData dataValue = it3.data();
2008  if (dataValue.type() != TQT_DBusData::Variant) {
2009 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2010  printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
2011 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2012  // No NM settings are known which use this style
2013  }
2014  else {
2015  TQT_DBusVariant dataValueVariant = dataValue.toVariant();
2016  TQT_DBusData dataValue2 = dataValueVariant.value;
2017  if (dataValue2.type() != TQT_DBusData::Variant) {
2018 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2019  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);
2020 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2021  // Most NM settings use this style
2022  if (outerKeyValue.lower() == "connection") {
2023  if (keyValue.lower() == "id") {
2024  connection->friendlyName = dataValue2.toString();
2025  }
2026  else if (keyValue.lower() == "uuid") {
2027  connection->UUID = dataValue2.toString().lower();
2028  }
2029  else if (keyValue.lower() == "permissions") {
2030  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2031  TQT_DBusDataValueList::const_iterator it4;
2032  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2033  TQT_DBusData innerDataValue = *it4;
2034  TQString authString = innerDataValue.toString();
2035  TQStringList pieces = TQStringList::split(":", authString);
2036  if (pieces[0].lower() == "user") {
2037  connection->authorizedUsers.append(pieces[1]);
2038  }
2039  }
2040  }
2041  else if (keyValue.lower() == "autoconnect") {
2042  connection->autoConnect = dataValue2.toBool();
2043  }
2044  else if (keyValue.lower() == "read-only") {
2045  connection->readOnly = dataValue2.toBool();
2046  }
2047  else if (keyValue.lower() == "master") {
2048  connection->masterConnectionUUID = dataValue2.toString().lower();
2049  }
2050  else if (keyValue.lower() == "slave-type") {
2051  connection->slaveType = nmSlaveTypeToTDESlaveType(dataValue2.toString());
2052  }
2053  else if (keyValue.lower() == "timestamp") {
2054  connection->lastKnownConnection.setTime_t(dataValue2.toUInt64());
2055  }
2056  }
2057  else if (outerKeyValue.lower() == "802-1x") {
2058  if (keyValue.lower() == "eap") {
2059  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2060  TQT_DBusDataValueList::const_iterator it4;
2061  state = 0;
2062  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2063  TQT_DBusData innerDataValue = *it4;
2064  if (state == 0) {
2065  // EAP type
2066  connection->eapConfig.type = nmEAPTypeToTDEEAPType(innerDataValue.toString());
2067  }
2068  state++;
2069  }
2070  }
2071  else if (keyValue.lower() == "identity") {
2072  connection->eapConfig.userName = dataValue2.toString();
2073  }
2074  else if (keyValue.lower() == "anonymous-identity") {
2075  connection->eapConfig.anonymousUserName = dataValue2.toString();
2076  }
2077  else if (keyValue.lower() == "pac-file") {
2078  connection->eapConfig.pacFileName = dataValue2.toString();
2079  }
2080  else if (keyValue.lower() == "ca-cert") {
2081  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2082  TQT_DBusDataValueList::const_iterator it4;
2083  int count=0;
2084  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2085  TQT_DBusData innerDataValue = *it4;
2086  count++;
2087  connection->eapConfig.caCertificate.resize(count+1);
2088  connection->eapConfig.caCertificate[count] = innerDataValue.toByte();
2089  }
2090  }
2091  else if (keyValue.lower() == "ca-path") {
2092  connection->eapConfig.additionalCAFilesPath = dataValue2.toString();
2093  }
2094  else if (keyValue.lower() == "subject-match") {
2095  connection->eapConfig.authServerCertSubjectMatch = dataValue2.toString();
2096  }
2097  else if (keyValue.lower() == "altsubject-matches") {
2098  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2099  TQT_DBusDataValueList::const_iterator it4;
2100  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2101  TQT_DBusData innerDataValue = *it4;
2102  connection->eapConfig.alternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
2103  }
2104  }
2105  else if (keyValue.lower() == "client-cert") {
2106  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2107  TQT_DBusDataValueList::const_iterator it4;
2108  int count=0;
2109  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2110  TQT_DBusData innerDataValue = *it4;
2111  count++;
2112  connection->eapConfig.clientCertificate.resize(count+1);
2113  connection->eapConfig.clientCertificate[count] = innerDataValue.toByte();
2114  }
2115  }
2116  else if (keyValue.lower() == "phase1-peapver") {
2117  connection->eapConfig.forcePEAPVersion = dataValue2.toString();
2118  }
2119  else if (keyValue.lower() == "phase1-peaplabel") {
2120  connection->eapConfig.forcePEAPLabel = dataValue2.toString();
2121  }
2122  else if (keyValue.lower() == "phase1-fast-provisioning") {
2123  connection->eapConfig.fastProvisioningFlags = nmEAPFastFlagsToTDEEAPFastFlags(dataValue2.toString());
2124  }
2125  else if (keyValue.lower() == "phase2-auth") {
2126  connection->eapConfig.phase2NonEAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
2127  }
2128  else if (keyValue.lower() == "phase2-autheap") {
2129  connection->eapConfig.phase2EAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
2130  }
2131  else if (keyValue.lower() == "phase2-ca-cert") {
2132  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2133  TQT_DBusDataValueList::const_iterator it4;
2134  int count=0;
2135  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2136  TQT_DBusData innerDataValue = *it4;
2137  count++;
2138  connection->eapConfig.phase2CaCertificate.resize(count+1);
2139  connection->eapConfig.phase2CaCertificate[count] = innerDataValue.toByte();
2140  }
2141  }
2142  else if (keyValue.lower() == "phase2-ca-path") {
2143  connection->eapConfig.phase2CaFilesPath = dataValue2.toString();
2144  }
2145  else if (keyValue.lower() == "phase2-subject-match") {
2146  connection->eapConfig.phase2AuthServerCertSubjectMatch = dataValue2.toString();
2147  }
2148  else if (keyValue.lower() == "phase2-altsubject-matches") {
2149  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2150  TQT_DBusDataValueList::const_iterator it4;
2151  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2152  TQT_DBusData innerDataValue = *it4;
2153  connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
2154  }
2155  }
2156  else if (keyValue.lower() == "phase2-client-cert") {
2157  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2158  TQT_DBusDataValueList::const_iterator it4;
2159  int count=0;
2160  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2161  TQT_DBusData innerDataValue = *it4;
2162  count++;
2163  connection->eapConfig.phase2ClientCertificate.resize(count+1);
2164  connection->eapConfig.phase2ClientCertificate[count] = innerDataValue.toByte();
2165  }
2166  }
2167  else if (keyValue.lower() == "password-flags") {
2168  connection->eapConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2169  }
2170  else if (keyValue.lower() == "password-raw-flags") {
2171  connection->eapConfig.binaryPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2172  }
2173  else if (keyValue.lower() == "private-key") {
2174  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2175  TQT_DBusDataValueList::const_iterator it4;
2176  int count=0;
2177  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2178  TQT_DBusData innerDataValue = *it4;
2179  count++;
2180  connection->eapConfig.privateKey.resize(count+1);
2181  connection->eapConfig.privateKey[count] = innerDataValue.toByte();
2182  }
2183  }
2184  else if (keyValue.lower() == "private-key-password-flags") {
2185  connection->eapConfig.privateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2186  }
2187  else if (keyValue.lower() == "phase2-private-key") {
2188  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2189  TQT_DBusDataValueList::const_iterator it4;
2190  int count=0;
2191  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2192  TQT_DBusData innerDataValue = *it4;
2193  count++;
2194  connection->eapConfig.phase2PrivateKey.resize(count+1);
2195  connection->eapConfig.phase2PrivateKey[count] = innerDataValue.toByte();
2196  }
2197  }
2198  else if (keyValue.lower() == "phase2-private-key-password-flags") {
2199  connection->eapConfig.phase2PrivateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2200  }
2201  else if (keyValue.lower() == "system-ca-certs") {
2202  connection->eapConfig.forceSystemCaCertificates = dataValue2.toBool();
2203  }
2204  connection->eapConfig.valid = true;
2205  }
2206  else if (outerKeyValue.lower() == "802-3-ethernet") {
2207  if (keyValue.lower() == "duplex") {
2208  connection->fullDuplex = (dataValue2.toString().lower() == "full")?true:false;
2209  }
2210  else if (keyValue.lower() == "mac-address") {
2211  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2212  TQT_DBusDataValueList::const_iterator it4;
2213  TDENetworkByteList macAddress;
2214  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2215  TQT_DBusData innerDataValue = *it4;
2216  macAddress.append(innerDataValue.toByte());
2217  }
2218  connection->lockedHWAddress.setAddress(macAddress);
2219  }
2220  else if (keyValue.lower() == "cloned-mac-address") {
2221  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2222  TQT_DBusDataValueList::const_iterator it4;
2223  TDENetworkByteList macAddress;
2224  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2225  TQT_DBusData innerDataValue = *it4;
2226  macAddress.append(innerDataValue.toByte());
2227  }
2228  connection->manualHWAddress.setAddress(macAddress);
2229  }
2230  else if (keyValue.lower() == "mtu") {
2231  connection->mtu = dataValue2.toUInt32();
2232  }
2233  }
2234  else if (outerKeyValue.lower() == "infiniband") {
2235  if (keyValue.lower() == "mac-address") {
2236  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2237  TQT_DBusDataValueList::const_iterator it4;
2238  TDENetworkByteList macAddress;
2239  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2240  TQT_DBusData innerDataValue = *it4;
2241  macAddress.append(innerDataValue.toByte());
2242  }
2243  connection->lockedHWAddress.setAddress(macAddress);
2244  }
2245  else if (keyValue.lower() == "mtu") {
2246  connection->mtu = dataValue2.toUInt32();
2247  }
2248  else if (keyValue.lower() == "transport-mode") {
2249  infinibandConnection->transportMode = nmIBTransportToTDEIBTransport(dataValue2.toString());
2250  }
2251  }
2252  else if (outerKeyValue.lower() == "802-11-wireless") {
2253  if (keyValue.lower() == "ssid") {
2254  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2255  TQT_DBusDataValueList::const_iterator it4;
2256  int count = 0;
2257  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2258  TQT_DBusData innerDataValue = *it4;
2259  wiFiConnection->SSID.resize(count+1);
2260  wiFiConnection->SSID[count] = innerDataValue.toByte();
2261  count++;
2262  }
2263  }
2264  else if (keyValue.lower() == "mac-address") {
2265  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2266  TQT_DBusDataValueList::const_iterator it4;
2267  TDENetworkByteList macAddress;
2268  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2269  TQT_DBusData innerDataValue = *it4;
2270  macAddress.append(innerDataValue.toByte());
2271  }
2272  connection->lockedHWAddress.setAddress(macAddress);
2273  }
2274  else if (keyValue.lower() == "cloned-mac-address") {
2275  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2276  TQT_DBusDataValueList::const_iterator it4;
2277  TDENetworkByteList macAddress;
2278  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2279  TQT_DBusData innerDataValue = *it4;
2280  macAddress.append(innerDataValue.toByte());
2281  }
2282  connection->manualHWAddress.setAddress(macAddress);
2283  }
2284  else if (keyValue.lower() == "mtu") {
2285  connection->mtu = dataValue2.toUInt32();
2286  }
2287  else if (keyValue.lower() == "mode") {
2288  wiFiConnection->operatingMode = nmWiFiModeToTDEWiFiMode(dataValue2.toString());
2289  }
2290  else if (keyValue.lower() == "band") {
2291  wiFiConnection->bandRestriction = nmWiFiFrequencyBandToTDEWiFiFrequencyBand(dataValue2.toString());
2292  }
2293  else if (keyValue.lower() == "channel") {
2294  wiFiConnection->channelRestriction = dataValue2.toUInt32();
2295  if (wiFiConnection->channelRestriction == 0) wiFiConnection->channelRestriction = -1;
2296  }
2297  else if (keyValue.lower() == "rate") {
2298  wiFiConnection->bitRateRestriction = dataValue2.toUInt32()*1000;
2299  if (wiFiConnection->bitRateRestriction == 0) wiFiConnection->bitRateRestriction = -1;
2300  }
2301  else if (keyValue.lower() == "tx-power") {
2302  wiFiConnection->powerRestriction = dataValue2.toUInt32();
2303  if (wiFiConnection->powerRestriction == 0) wiFiConnection->powerRestriction = -1;
2304  }
2305  else if (keyValue.lower() == "bssid") {
2306  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2307  TQT_DBusDataValueList::const_iterator it4;
2308  TDENetworkByteList macAddress;
2309  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2310  TQT_DBusData innerDataValue = *it4;
2311  macAddress.append(innerDataValue.toByte());
2312  }
2313  wiFiConnection->accessPointRestriction.setAddress(macAddress);
2314  }
2315  else if (keyValue.lower() == "mac-address-blacklist") {
2316  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2317  TQT_DBusDataValueList::const_iterator it4;
2318  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2319  TQT_DBusData innerDataValue = *it4;
2320  TDEMACAddress hwAddress;
2321  hwAddress.fromString(innerDataValue.toString());
2322  wiFiConnection->blacklistedBSSIDs.append(hwAddress);
2323  }
2324  }
2325  else if (keyValue.lower() == "seen-bssids") {
2326  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2327  TQT_DBusDataValueList::const_iterator it4;
2328  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2329  TQT_DBusData innerDataValue = *it4;
2330  TDEMACAddress hwAddress;
2331  hwAddress.fromString(innerDataValue.toString());
2332  wiFiConnection->heardBSSIDs.append(hwAddress);
2333  }
2334  }
2335  else if (keyValue.lower() == "security") {
2336  TQString setting;
2337  if (setting.lower() == "802-11-wireless-security") {
2338  wiFiConnection->securityRequired = true;
2339  }
2340  else {
2341  wiFiConnection->securityRequired = false;
2342  }
2343  }
2344  else if (keyValue.lower() == "hidden") {
2345  wiFiConnection->isHiddenNetwork = dataValue2.toBool();
2346  }
2347  }
2348  else if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
2349  if (keyValue.lower() == "key-mgmt") {
2350  wiFiConnection->securitySettings.keyType = nmWiFiKeyTypeToTDEWiFiKeyType(dataValue2.toString());
2351  }
2352  else if (keyValue.lower() == "wep-tx-keyidx") {
2353  wiFiConnection->securitySettings.wepKeyIndex = dataValue2.toUInt32();
2354  }
2355  else if (keyValue.lower() == "auth-alg") {
2356  wiFiConnection->securitySettings.authType = nmWiFiAuthTypeToTDEWiFiAuthType(dataValue2.toString());
2357  }
2358  else if (keyValue.lower() == "proto") {
2359  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2360  TQT_DBusDataValueList::const_iterator it4;
2361  TQStringList strings;
2362  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2363  TQT_DBusData innerDataValue = *it4;
2364  strings.append(innerDataValue.toString());
2365  }
2366  wiFiConnection->securitySettings.wpaVersion = nmWiFiWPAVersionToTDEWiFiWPAVersion(strings);
2367  }
2368  else if (keyValue.lower() == "pairwise") {
2369  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2370  TQT_DBusDataValueList::const_iterator it4;
2371  TQStringList strings;
2372  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2373  TQT_DBusData innerDataValue = *it4;
2374  wiFiConnection->securitySettings.allowedPairWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
2375  }
2376  if ((wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
2377  || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
2378  || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
2379  || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
2380  wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
2381  }
2382  }
2383  else if (keyValue.lower() == "group") {
2384  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2385  TQT_DBusDataValueList::const_iterator it4;
2386  TQStringList strings;
2387  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2388  TQT_DBusData innerDataValue = *it4;
2389  wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
2390  }
2391  if ((wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
2392  || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
2393  || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
2394  || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
2395  wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
2396  }
2397  }
2398  else if (keyValue.lower() == "leap-username") {
2399  wiFiConnection->securitySettings.leapUsername = dataValue2.toString();
2400  }
2401  else if (keyValue.lower() == "wep-key-flags") {
2402  wiFiConnection->securitySettings.wepKeyFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2403  }
2404  else if (keyValue.lower() == "wep-key-type") {
2405  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(dataValue2.toUInt32());
2406  }
2407  else if (keyValue.lower() == "psk-flags") {
2408  wiFiConnection->securitySettings.pskFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2409  }
2410  else if (keyValue.lower() == "leap-password-flags") {
2411  wiFiConnection->securitySettings.leapPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2412  }
2413  wiFiConnection->securitySettings.valid = true;
2414  }
2415  else if (outerKeyValue.lower() == "vpn") {
2416  if (keyValue.lower() == "service-type") {
2417  TQString plugin = dataValue2.toString();
2418  plugin.replace("org.freedesktop.NetworkManager.", "");
2419  vpnConnection->vpnPluginID = plugin;
2420  }
2421  else if (keyValue.lower() == "user-name") {
2422  vpnConnection->lockedUserName = dataValue2.toString();
2423  }
2424  else if (keyValue.lower() == "data") {
2425  vpnConnection->pluginData.clear();
2426  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
2427  TQT_DBusTQStringDataMap::const_iterator it4;
2428  for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
2429  TQString keyValue4 = it4.key();
2430  TQT_DBusData dataValue4 = it4.data();
2431  if (dataValue4.type() == TQT_DBusData::String) {
2432  vpnConnection->pluginData[keyValue4] = dataValue4.toString();
2433  }
2434  }
2435  }
2436  }
2437  else if (outerKeyValue.lower() == "wimax") {
2438  if (keyValue.lower() == "mac-address") {
2439  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2440  TQT_DBusDataValueList::const_iterator it4;
2441  TDENetworkByteList macAddress;
2442  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2443  TQT_DBusData innerDataValue = *it4;
2444  macAddress.append(innerDataValue.toByte());
2445  }
2446  connection->lockedHWAddress.setAddress(macAddress);
2447  }
2448  else if (keyValue.lower() == "network-name") {
2449  wiMaxConnection->networkServiceProvider = dataValue2.toString();
2450  }
2451  }
2452  else if (outerKeyValue.lower() == "vlan") {
2453  if (keyValue.lower() == "interface-name") {
2454  vlanConnection->kernelName = dataValue2.toString();
2455  }
2456  else if (keyValue.lower() == "parent") {
2457  vlanConnection->parentConnectionUUID = dataValue2.toString();
2458  }
2459  else if (keyValue.lower() == "id") {
2460  vlanConnection->vlanID = dataValue2.toUInt32();
2461  }
2462  else if (keyValue.lower() == "flags") {
2463  vlanConnection->vlanFlags = nmVLANFlagsToTDEVLANFlags(dataValue2.toUInt32());
2464  }
2465  else if (keyValue.lower() == "ingress-priority-map") {
2466  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2467  TQT_DBusDataValueList::const_iterator it4;
2468  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2469  TQT_DBusData innerDataValue = *it4;
2470  TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
2471  vlanConnection->ingressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
2472  }
2473  }
2474  else if (keyValue.lower() == "egress-priority-map") {
2475  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2476  TQT_DBusDataValueList::const_iterator it4;
2477  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2478  TQT_DBusData innerDataValue = *it4;
2479  TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
2480  vlanConnection->egressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
2481  }
2482  }
2483  }
2484  else if (outerKeyValue.lower() == "serial") {
2485  if (keyValue.lower() == "baud") {
2486  connection->serialConfig.baudRate = dataValue2.toUInt32();
2487  }
2488  else if (keyValue.lower() == "bits") {
2489  connection->serialConfig.byteWidth = dataValue2.toUInt32();
2490  }
2491  else if (keyValue.lower() == "parity") {
2492  connection->serialConfig.parity = nmParityToTDEParity(dataValue2.toByte());
2493  }
2494  else if (keyValue.lower() == "stopbits") {
2495  connection->serialConfig.stopBits = dataValue2.toUInt32();
2496  }
2497  else if (keyValue.lower() == "send-delay") {
2498  connection->serialConfig.txDelay = dataValue2.toUInt64();
2499  }
2500  connection->serialConfig.valid = true;
2501  }
2502  else if (outerKeyValue.lower() == "ppp") {
2503  if (keyValue.lower() == "noauth") {
2504  connection->pppConfig.requireServerAuthentication = !(dataValue2.toBool());
2505  }
2506  else if (keyValue.lower() == "refuse-eap") {
2507  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisableEAP;
2508  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableEAP;
2509  }
2510  else if (keyValue.lower() == "refuse-pap") {
2511  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisablePAP;
2512  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisablePAP;
2513  }
2514  else if (keyValue.lower() == "refuse-chap") {
2515  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisableCHAP;
2516  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableCHAP;
2517  }
2518  else if (keyValue.lower() == "refuse-mschap") {
2519  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisableMSCHAP;
2520  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAP;
2521  }
2522  else if (keyValue.lower() == "refuse-mschapv2") {
2523  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisableMSCHAPv2;
2524  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAPv2;
2525  }
2526  else if (keyValue.lower() == "nobsdcomp") {
2527  if (dataValue2.toBool()) connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowBSDCompression;
2528  else connection->pppConfig.flags |= TDENetworkPPPFlags::AllowBSDCompression;
2529  }
2530  else if (keyValue.lower() == "nodeflate") {
2531  if (dataValue2.toBool()) connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowDeflateCompression;
2532  else connection->pppConfig.flags |= TDENetworkPPPFlags::AllowDeflateCompression;
2533  }
2534  else if (keyValue.lower() == "no-vj-comp") {
2535  if (dataValue2.toBool()) connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowVJCompression;
2536  else connection->pppConfig.flags |= TDENetworkPPPFlags::AllowVJCompression;
2537  }
2538  else if (keyValue.lower() == "require-mppe") {
2539  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::RequireMPPE;
2540  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE;
2541  }
2542  else if (keyValue.lower() == "require-mppe-128") {
2543  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::RequireMPPE128;
2544  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE128;
2545  }
2546  else if (keyValue.lower() == "mppe-stateful") {
2547  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::StatefulMPPE;
2548  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::StatefulMPPE;
2549  }
2550  else if (keyValue.lower() == "crtscts") {
2551  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::UseHardwareFlowControl;
2552  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::UseHardwareFlowControl;
2553  }
2554  else if (keyValue.lower() == "baud") {
2555  connection->pppConfig.baudRate = dataValue2.toUInt32();
2556  }
2557  else if (keyValue.lower() == "mru") {
2558  connection->pppConfig.mru = dataValue2.toUInt32();
2559  }
2560  else if (keyValue.lower() == "mtu") {
2561  connection->pppConfig.mtu = dataValue2.toUInt32();
2562  }
2563  else if (keyValue.lower() == "lcp-echo-interval") {
2564  connection->pppConfig.lcpEchoPingInterval = dataValue2.toUInt32();
2565  }
2566  else if (keyValue.lower() == "lcp-echo-failure") {
2567  connection->pppConfig.lcpEchoFailureThreshold = dataValue2.toUInt32();
2568  }
2569  connection->pppConfig.valid = true;
2570  }
2571  else if (outerKeyValue.lower() == "pppoe") {
2572  if (keyValue.lower() == "service") {
2573  connection->pppoeConfig.networkServiceProvider = dataValue2.toString();
2574  }
2575  else if (keyValue.lower() == "username") {
2576  connection->pppoeConfig.username = dataValue2.toString();
2577  }
2578  else if (keyValue.lower() == "password-flags") {
2579  connection->pppoeConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2580  }
2581  connection->pppoeConfig.secretsValid = true;
2582  }
2583  else if ((outerKeyValue.lower() == "802-11-olpc-mesh") && (olpcMeshConnection)) {
2584  if (keyValue.lower() == "ssid") {
2585  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2586  TQT_DBusDataValueList::const_iterator it4;
2587  int count = 0;
2588  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2589  TQT_DBusData innerDataValue = *it4;
2590  olpcMeshConnection->SSID.resize(count+1);
2591  olpcMeshConnection->SSID[count] = innerDataValue.toByte();
2592  count++;
2593  }
2594  }
2595  else if (keyValue.lower() == "channel") {
2596  olpcMeshConnection->channel = dataValue2.toUInt32();
2597  }
2598  else if (keyValue.lower() == "dhcp-anycast-address") {
2599  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2600  TQT_DBusDataValueList::const_iterator it4;
2601  int count = 0;
2602  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2603  TQT_DBusData innerDataValue = *it4;
2604  olpcMeshConnection->anycastDHCPHWAddress.resize(count+1);
2605  olpcMeshConnection->anycastDHCPHWAddress[count] = innerDataValue.toByte();
2606  count++;
2607  }
2608  }
2609  }
2610  else if ((outerKeyValue.lower() == "bluetooth") && (bluetoothConnection)) {
2611  if (keyValue.lower() == "bdaddr") {
2612  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2613  TQT_DBusDataValueList::const_iterator it4;
2614  TDENetworkByteList macAddress;
2615  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2616  TQT_DBusData innerDataValue = *it4;
2617  macAddress.append(innerDataValue.toByte());
2618  }
2619  connection->lockedHWAddress.setAddress(macAddress);
2620  }
2621  else if (keyValue.lower() == "type") {
2622  bluetoothConnection->type = nmBluetoothModeToTDEBluetoothMode(dataValue2.toString());
2623  }
2624  }
2625  else if ((outerKeyValue.lower() == "cdma") && (modemConnection)) {
2626  if (keyValue.lower() == "number") {
2627  modemConnection->cdmaConfig.providerDataNumber = dataValue2.toString();
2628  }
2629  else if (keyValue.lower() == "username") {
2630  modemConnection->cdmaConfig.username = dataValue2.toString();
2631  }
2632  else if (keyValue.lower() == "password-flags") {
2633  modemConnection->cdmaConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2634  }
2635  modemConnection->type = TDEModemConnectionType::CDMA;
2636  modemConnection->cdmaConfig.valid = true;
2637  }
2638  else if ((outerKeyValue.lower() == "gsm") && (modemConnection)) {
2639  if (keyValue.lower() == "number") {
2640  modemConnection->gsmConfig.providerDataNumber = dataValue2.toString();
2641  }
2642  else if (keyValue.lower() == "username") {
2643  modemConnection->gsmConfig.username = dataValue2.toString();
2644  }
2645  else if (keyValue.lower() == "password-flags") {
2646  modemConnection->gsmConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2647  }
2648  else if (keyValue.lower() == "apn") {
2649  modemConnection->gsmConfig.accessPointName = dataValue2.toString();
2650  }
2651  else if (keyValue.lower() == "network-id") {
2652  modemConnection->gsmConfig.networkID = dataValue2.toString();
2653  }
2654  else if (keyValue.lower() == "network-type") {
2655  modemConnection->gsmConfig.networkType = nmGSMModeToTDEGSMMode(dataValue2.toInt32());
2656  }
2657  else if (keyValue.lower() == "pin-flags") {
2658  modemConnection->gsmConfig.pinFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2659  }
2660  else if (keyValue.lower() == "allowed-bands") {
2661  modemConnection->gsmConfig.allowedFrequencyBands = dataValue2.toUInt32();
2662  }
2663  else if (keyValue.lower() == "home-only") {
2664  modemConnection->gsmConfig.allowRoaming = !dataValue2.toBool();
2665  }
2666  modemConnection->type = TDEModemConnectionType::GSM;
2667  modemConnection->gsmConfig.valid = true;
2668  }
2669  else if (outerKeyValue.lower() == "ipv4") {
2670  if (keyValue.lower() == "addresses") {
2671  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2672  TQT_DBusDataValueList::const_iterator it4;
2673  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2674  TQT_DBusData innerDataValue = *it4;
2675  TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
2676  TQT_DBusDataValueList::const_iterator it5;
2677  state = 0;
2678  TDENetworkSingleIPConfiguration ipConfig;
2679  for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
2680  TQT_DBusData innerMostDataValue = *it5;
2681  if (state == 0) {
2682  // Address
2683  ipConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
2684  }
2685  else if (state == 1) {
2686  // Network mask
2687  ipConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
2688  }
2689  else if (state == 2) {
2690  // Gateway
2691  ipConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
2692  }
2693  state++;
2694  }
2695  ipConfig.valid = true;
2696  connection->ipConfig.ipConfigurations.append(ipConfig);
2697  }
2698  }
2699  else if (keyValue.lower() == "dhcp-client-id") {
2700  connection->ipConfig.dhcpClientIdentifier = dataValue2.toString();
2701  }
2702  else if (keyValue.lower() == "dns") {
2703  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2704  TQT_DBusDataValueList::const_iterator it4;
2705  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2706  TQT_DBusData innerDataValue = *it4;
2707  connection->ipConfig.resolvers.append(TQHostAddress(reverseIPV4ByteOrder(innerDataValue.toUInt32())));
2708  }
2709  }
2710  else if (keyValue.lower() == "dns-search") {
2711  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2712  TQT_DBusDataValueList::const_iterator it4;
2713  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2714  TQT_DBusData innerDataValue = *it4;
2715  connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), false));
2716  }
2717  }
2718  else if (keyValue.lower() == "ignore-auto-dns") {
2719  bool nm_static_dns = dataValue2.toBool();
2720  if (nm_static_dns) {
2721  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
2722  }
2723  else {
2724  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
2725  }
2726  }
2727  else if (keyValue.lower() == "may-fail") {
2728  bool nm_may_fail = dataValue2.toBool();
2729  connection->requireIPV4 = !nm_may_fail;
2730  }
2731  else if (keyValue.lower() == "method") {
2732  TQString nm_method = dataValue2.toString().lower();
2733  if (nm_method == "auto") {
2734  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPIP;
2735  }
2736  else if (nm_method == "manual") {
2737  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPIP;
2738  }
2739  else if (nm_method == "link-local") {
2740  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4LocalOnly;
2741  }
2742  else if (nm_method == "shared") {
2743  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer;
2744  }
2745  else if (nm_method == "disabled") {
2746  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4Disabled;
2747  }
2748  }
2749  else if (keyValue.lower() == "ignore-auto-routes") {
2750  bool nm_static_routes = dataValue2.toBool();
2751  if (nm_static_routes) {
2752  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
2753  }
2754  else {
2755  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
2756  }
2757  }
2758  else if (keyValue.lower() == "never-default") {
2759  bool nm_can_default_route = !dataValue2.toBool();
2760  if (nm_can_default_route) {
2761  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
2762  }
2763  else {
2764  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
2765  }
2766  }
2767  else if (keyValue.lower() == "routes") {
2768  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2769  TQT_DBusDataValueList::const_iterator it4;
2770  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2771  TQT_DBusData innerDataValue = *it4;
2772  TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
2773  TQT_DBusDataValueList::const_iterator it5;
2774  state = 0;
2775  TDENetworkSingleRouteConfiguration routeConfig;
2776  for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
2777  TQT_DBusData innerMostDataValue = *it5;
2778  if (state == 0) {
2779  // Address
2780  routeConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
2781  }
2782  else if (state == 1) {
2783  // Network mask
2784  routeConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
2785  }
2786  else if (state == 2) {
2787  // Gateway
2788  routeConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
2789  }
2790  else if (state == 3) {
2791  // Metric
2792  routeConfig.metric = innerMostDataValue.toUInt32();
2793  }
2794  state++;
2795  }
2796  routeConfig.valid = true;
2797  connection->ipConfig.routeConfigurations.append(routeConfig);
2798  }
2799  }
2800  connection->ipConfig.valid = true;
2801  }
2802  else if (outerKeyValue.lower() == "ipv6") {
2803  if (keyValue.lower() == "addresses") {
2804  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2805  TQT_DBusDataValueList::const_iterator it4;
2806  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2807  TQT_DBusData innerDataValue = *it4;
2808  TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
2809  TQT_DBusDataValueList::const_iterator it5;
2810  TDENetworkSingleIPConfiguration ipConfig;
2811  // Address
2812  TQT_DBusDataValueList innerMostValueList;
2813  innerMostValueList = innerValueList[0].toTQValueList();
2814  TQ_UINT8 nm_v6address[16];
2815  unsigned char nm_addr_ptr = 0;
2816  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2817  for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
2818  TQT_DBusData innerMostDataValue = *it5;
2819  if (nm_addr_ptr < 16) {
2820  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2821  nm_addr_ptr++;
2822  }
2823  }
2824  ipConfig.ipAddress = TQHostAddress(nm_v6address);
2825 
2826  // Netmask
2827  ipConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);
2828 
2829  // Gateway
2830  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2831  for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
2832  TQT_DBusData innerMostDataValue = *it5;
2833  if (nm_addr_ptr < 16) {
2834  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2835  nm_addr_ptr++;
2836  }
2837  }
2838  ipConfig.gateway = TQHostAddress(nm_v6address);
2839 
2840  ipConfig.valid = true;
2841  connection->ipConfig.ipConfigurations.append(ipConfig);
2842  }
2843  }
2844  else if (keyValue.lower() == "dns") {
2845  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2846  TQT_DBusDataValueList::const_iterator it4;
2847  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2848  TQT_DBusData innerDataValue = *it4;
2849  TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
2850  TQT_DBusDataValueList::const_iterator it5;
2851  TQ_UINT8 nm_v6address[16];
2852  unsigned char nm_addr_ptr = 0;
2853  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2854  for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
2855  TQT_DBusData innerMostDataValue = *it5;
2856  if (nm_addr_ptr < 16) {
2857  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2858  nm_addr_ptr++;
2859  }
2860  }
2861  connection->ipConfig.resolvers.append(TQHostAddress(nm_v6address));
2862  }
2863  }
2864  else if (keyValue.lower() == "dns-search") {
2865  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2866  TQT_DBusDataValueList::const_iterator it4;
2867  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2868  TQT_DBusData innerDataValue = *it4;
2869  TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
2870  TQT_DBusDataValueList::const_iterator it5;
2871  connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), true));
2872  }
2873  }
2874  else if (keyValue.lower() == "ignore-auto-dns") {
2875  bool nm_static_dns = dataValue2.toBool();
2876  if (nm_static_dns) {
2877  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
2878  }
2879  else {
2880  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
2881  }
2882  }
2883  else if (keyValue.lower() == "may-fail") {
2884  bool nm_may_fail = dataValue2.toBool();
2885  connection->requireIPV6 = !nm_may_fail;
2886  }
2887  else if (keyValue.lower() == "method") {
2888  TQString nm_method = dataValue2.toString().lower();
2889  if (nm_method == "auto") {
2890  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPIP;
2891  }
2892  else if (nm_method == "manual") {
2893  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPIP;
2894  }
2895  else if (nm_method == "link-local") {
2896  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6LocalOnly;
2897  }
2898  else if (nm_method == "shared") {
2899  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer;
2900  }
2901  else if (nm_method == "ignore") {
2902  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6Disabled;
2903  }
2904  }
2905  else if (keyValue.lower() == "ignore-auto-routes") {
2906  bool nm_static_routes = dataValue2.toBool();
2907  if (nm_static_routes) {
2908  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
2909  }
2910  else {
2911  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
2912  }
2913  }
2914  else if (keyValue.lower() == "never-default") {
2915  bool nm_can_default_route = !dataValue2.toBool();
2916  if (nm_can_default_route) {
2917  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
2918  }
2919  else {
2920  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
2921  }
2922  }
2923  else if (keyValue.lower() == "routes") {
2924  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2925  TQT_DBusDataValueList::const_iterator it4;
2926  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2927  TQT_DBusData innerDataValue = *it4;
2928  TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
2929  TQT_DBusDataValueList::const_iterator it5;
2930  TDENetworkSingleRouteConfiguration routeConfig;
2931  // Address
2932  TQT_DBusDataValueList innerMostValueList;
2933  innerMostValueList = innerValueList[0].toTQValueList();
2934  TQ_UINT8 nm_v6address[16];
2935  unsigned char nm_addr_ptr = 0;
2936  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2937  for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
2938  TQT_DBusData innerMostDataValue = *it5;
2939  if (nm_addr_ptr < 16) {
2940  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2941  nm_addr_ptr++;
2942  }
2943  }
2944  routeConfig.ipAddress = TQHostAddress(nm_v6address);
2945 
2946  // Netmask
2947  routeConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);
2948 
2949  // Gateway
2950  innerMostValueList = innerValueList[2].toTQValueList();
2951  nm_addr_ptr = 0;
2952  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2953  for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
2954  TQT_DBusData innerMostDataValue = *it5;
2955  if (nm_addr_ptr < 16) {
2956  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2957  nm_addr_ptr++;
2958  }
2959  }
2960  routeConfig.gateway = TQHostAddress(nm_v6address);
2961 
2962  // Metric
2963  routeConfig.metric = innerValueList[3].toUInt32();
2964 
2965  routeConfig.valid = true;
2966  connection->ipConfig.routeConfigurations.append(routeConfig);
2967  }
2968  }
2969  connection->ipConfig.valid = true;
2970  }
2971  }
2972  else {
2973  // FIXME
2974  // There are several advanced properties which appear to use string maps
2975  // For example, s390-options
2976  // Support should eventually be added for these, e.g. in a backend-specific Advanced tab somewhere
2977  }
2978  }
2979  }
2980  }
2981 
2982  // If the connection's MAC matches my MAC, or if the connection is not locked to any MAC address,
2983  // or if this manager object is not locked to a device, then add this connection to the list
2984  if ((deviceMACAddress == connection->lockedHWAddress) || (!connection->lockedHWAddress.isValid()) || (!deviceMACAddress.isValid())) {
2985  loadConnectionAllowedValues(connection);
2986  m_connectionList->append(connection);
2987  }
2988  }
2989  else {
2990  // Error!
2991  PRINT_ERROR((error.name() + ": " + error.message()))
2992  }
2993  }
2994  }
2995  else {
2996  // Error!
2997  PRINT_ERROR((error.name() + ": " + error.message()))
2998  }
2999  internalNetworkManagementEvent(TDENetworkGlobalEventType::ConnectionListChanged);
3000  }
3001 
3002  d->nonReentrantCallActive = false;
3003 }
3004 
3005 void TDENetworkConnectionManager_BackendNM::loadConnectionAllowedValues(TDENetworkConnection* connection) {
3006  if (connection) {
3007  // Insert all allowed EAP phase 2 methods
3008  connection->eapConfig.allowedPhase2NonEAPMethods.clear();
3009  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MD5);
3010  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
3011  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::OTP);
3012  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::GTC);
3013  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::TLS);
3014 
3015  connection->eapConfig.allowedPhase2EAPMethods.clear();
3016  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::PAP);
3017  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::CHAP);
3018  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAP);
3019  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
3020  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::OTP);
3021  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::GTC);
3022  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::TLS);
3023 
3024  connection->eapConfig.allowedValid = true;
3025  }
3026 }
3027 
3028 // NOTE
3029 // While this separate separate routine is needed to get the secrets, note that secrets must
3030 // be saved using the same connection map save routine that all other settings use above.
3031 bool TDENetworkConnectionManager_BackendNM::loadConnectionSecrets(TQString uuid) {
3032  TDENetworkConnection* connection = findConnectionByUUID(uuid);
3033  if (!connection) {
3034  PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database. Did you run loadConnectionInformation() first?"));
3035  return FALSE;
3036  }
3037  //TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
3038  //TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
3039  TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
3040  TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
3041  //TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
3042  //TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
3043  //TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
3044  //TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
3045  TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
3046 
3047  bool ret = TRUE;
3048  ret = ret && loadConnectionSecretsForGroup(uuid, "802-1x");
3049  if (wiFiConnection) {
3050  ret = ret && loadConnectionSecretsForGroup(uuid, "802-11-wireless-security");
3051  }
3052  if (vpnConnection) {
3053  ret = ret && loadConnectionSecretsForGroup(uuid, "vpn");
3054  }
3055  ret = ret && loadConnectionSecretsForGroup(uuid, "pppoe");
3056  if (modemConnection) {
3057  ret = ret && loadConnectionSecretsForGroup(uuid, "cdma");
3058  ret = ret && loadConnectionSecretsForGroup(uuid, "gsm");
3059  }
3060  return ret;
3061 }
3062 
3063 bool TDENetworkConnectionManager_BackendNM::loadConnectionSecretsForGroup(TQString uuid, TQString group) {
3064  TDENetworkConnection* connection = findConnectionByUUID(uuid);
3065  if (!connection) {
3066  PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database. Did you run loadConnectionInformation() first?"));
3067  return FALSE;
3068  }
3069  //TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
3070  //TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
3071  TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
3072  TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
3073  //TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
3074  //TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
3075  //TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
3076  //TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
3077  TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
3078  TQT_DBusObjectPath existingConnection;
3079  TQT_DBusError error;
3080  bool ret;
3081  TQT_DBusTQStringDataMap connectionSecretsMap(TQT_DBusData::String);
3082  ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
3083  if (ret) {
3084 #ifndef USE_ASYNC_DBUS_CALLS
3085  // Obtain connection settings from the path specified
3086  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
3087  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
3088  ret = connectionSettings.GetSecrets(group, connectionSecretsMap, error);
3089  if (ret && error.isValid()) {
3090  ret = 0;
3091  PRINT_ERROR((error.name() + ": " + error.message()))
3092  }
3093  if (ret) {
3094 #else // USE_ASYNC_DBUS_CALLS
3095  // Obtain connection secrets from the path specified
3096  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
3097  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
3098  connect(&connectionSettings, SIGNAL(GetSecretsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
3099  int asyncCallID;
3100  ret = connectionSettings.GetSecretsAsync(asyncCallID, group, error);
3101  if (ret && error.isValid()) {
3102  ret = 0;
3103  PRINT_ERROR((error.name() + ": " + error.message()))
3104  }
3105  if (ret) {
3106  // Wait for the asynchronous call to return...
3107  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
3108  TQTimer nmCallTimeoutTimer;
3109  nmCallTimeoutTimer.start(NM_ASYNC_SECRETS_INTERACTION_TIMEOUT_MS, TRUE);
3110  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
3111  tqApp->processEvents();
3112  if (!nmCallTimeoutTimer.isActive()) {
3113  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
3114  break;
3115  }
3116  }
3117  connectionSecretsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
3118  if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
3119  PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
3120  d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
3121  }
3122  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
3123  if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
3124  d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
3125  }
3126 #endif // USE_ASYNC_DBUS_CALLS
3127 
3128 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3129  printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
3130  printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSecretsMap));
3131 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3132 
3133  // Parse settings
3134  TQT_DBusTQStringDataMap::const_iterator it2;
3135  for (it2 = connectionSecretsMap.begin(); it2 != connectionSecretsMap.end(); ++it2) {
3136  TQString outerKeyValue = it2.key();
3137  TQT_DBusData dataValue = it2.data();
3138 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3139  printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
3140 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3141  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
3142  TQT_DBusTQStringDataMap::const_iterator it3;
3143  for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
3144  TQString keyValue = it3.key();
3145  TQT_DBusData dataValue = it3.data();
3146  if (dataValue.type() != TQT_DBusData::Variant) {
3147 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3148  printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
3149 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3150  // No NM settings are known which use this style
3151  }
3152  else {
3153  TQT_DBusVariant dataValueVariant = dataValue.toVariant();
3154  TQT_DBusData dataValue2 = dataValueVariant.value;
3155  if (dataValue2.type() != TQT_DBusData::Variant) {
3156 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3157  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);
3158 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3159  // Most NM settings use this style
3160  if (outerKeyValue.lower() == "802-1x") {
3161  if (keyValue.lower() == "password") {
3162  connection->eapConfig.password = dataValue2.toString();
3163  }
3164  else if (keyValue.lower() == "password-raw") {
3165  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
3166  TQT_DBusDataValueList::const_iterator it4;
3167  int count=0;
3168  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
3169  TQT_DBusData innerDataValue = *it4;
3170  count++;
3171  connection->eapConfig.binaryPassword.resize(count+1);
3172  connection->eapConfig.binaryPassword[count] = innerDataValue.toByte();
3173  }
3174  }
3175  else if (keyValue.lower() == "private-key-password") {
3176  connection->eapConfig.privateKeyPassword = dataValue2.toString();
3177  }
3178  else if (keyValue.lower() == "phase2-private-key-password") {
3179  connection->eapConfig.phase2PrivateKeyPassword = dataValue2.toString();
3180  }
3181  connection->eapConfig.secretsValid = true;
3182  }
3183  if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
3184  if (keyValue.lower() == "wep-key0") {
3185  wiFiConnection->securitySettings.wepKey0 = dataValue2.toString();
3186  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey0);
3187  }
3188  else if (keyValue.lower() == "wep-key1") {
3189  wiFiConnection->securitySettings.wepKey1 = dataValue2.toString();
3190  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey1);
3191  }
3192  else if (keyValue.lower() == "wep-key2") {
3193  wiFiConnection->securitySettings.wepKey2 = dataValue2.toString();
3194  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey2);
3195  }
3196  else if (keyValue.lower() == "wep-key3") {
3197  wiFiConnection->securitySettings.wepKey3 = dataValue2.toString();
3198  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey3);
3199  }
3200  else if (keyValue.lower() == "psk") {
3201  wiFiConnection->securitySettings.psk = dataValue2.toString();
3202  }
3203  else if (keyValue.lower() == "eap-password") {
3204  wiFiConnection->securitySettings.leapPassword = dataValue2.toString();
3205  }
3206  }
3207  if ((outerKeyValue.lower() == "vpn") && (vpnConnection)) {
3208  if (keyValue.lower() == "secrets") {
3209  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
3210  TQT_DBusTQStringDataMap::const_iterator it4;
3211  for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
3212  vpnConnection->pluginSecrets.clear();
3213  TQString keyValue4 = it4.key();
3214  TQT_DBusData dataValue4 = it4.data();
3215  if (dataValue4.type() == TQT_DBusData::String) {
3216  vpnConnection->pluginSecrets[keyValue4] = dataValue4.toString();
3217  }
3218  }
3219  vpnConnection->secretsValid = true;
3220  }
3221  }
3222  if (outerKeyValue.lower() == "pppoe") {
3223  if (keyValue.lower() == "password") {
3224  connection->pppoeConfig.password = dataValue2.toString();
3225  }
3226  connection->pppoeConfig.secretsValid = true;
3227  }
3228  if (outerKeyValue.lower() == "cdma") {
3229  if (keyValue.lower() == "password") {
3230  modemConnection->cdmaConfig.password = dataValue2.toString();
3231  }
3232  modemConnection->cdmaConfig.secretsValid = true;
3233  }
3234  if (outerKeyValue.lower() == "gsm") {
3235  if (keyValue.lower() == "password") {
3236  modemConnection->gsmConfig.password = dataValue2.toString();
3237  }
3238  else if (keyValue.lower() == "pin") {
3239  modemConnection->gsmConfig.pin = dataValue2.toString();
3240  }
3241  modemConnection->gsmConfig.secretsValid = true;
3242  }
3243  }
3244  }
3245  }
3246  }
3247  return TRUE;
3248  }
3249  else {
3250  PRINT_ERROR(TQString("Unable to load secrets for connection with uuid '%1'").arg(uuid))
3251  return FALSE;
3252  }
3253  }
3254  else {
3255  PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
3256  return FALSE;
3257  }
3258 }
3259 
3260 bool TDENetworkConnectionManager_BackendNM::saveConnection(TDENetworkConnection* connection) {
3261  bool timed_out = FALSE;
3262  bool command_failed = FALSE;
3263 
3264  if (!connection) {
3265  PRINT_ERROR(TQString("connection cannot be NULL!"));
3266  return FALSE;
3267  }
3268 
3269  // If the UUID is blank, generate a new UUID for this connection and also guarantee that it it truly unique
3270  if (connection->UUID == "") {
3271  bool unique = false;
3272  while (!unique) {
3273  connection->UUID = TQUuid::createUuid().toString();
3274  connection->UUID.replace("{", "");
3275  connection->UUID.replace("}", "");
3276  if (!findConnectionByUUID(connection->UUID)) {
3277  unique = true;
3278  }
3279  }
3280  }
3281 
3282  // Find path for connection with specified UUID, if it exists
3283  // This is so that any settings that we are not aware of can be loaded now and preserved through the update operation
3284  TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
3285  TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
3286  TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
3287  TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
3288  TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
3289  TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
3290  TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEOLPCMeshConnection*>(connection);
3291  TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
3292  TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
3293  TQT_DBusObjectPath existingConnection;
3294  TQT_DBusError error;
3295  bool ret;
3296  bool existing;
3297  TQT_DBusTQStringDataMap connectionSettingsMap(TQT_DBusData::String);
3298  existing = false;
3299  ret = d->m_networkManagerSettings->GetConnectionByUuid(connection->UUID, existingConnection, error);
3300  if (ret) {
3301 #ifndef USE_ASYNC_DBUS_CALLS
3302  // Obtain connection settings from the path specified
3303  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
3304  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
3305  ret = connectionSettings.GetSettings(connectionSettingsMap, error);
3306  if (ret && error.isValid()) {
3307  ret = 0;
3308  PRINT_ERROR((error.name() + ": " + error.message()))
3309  }
3310  if (ret) {
3311 #else // USE_ASYNC_DBUS_CALLS
3312  // Obtain connection settings from the path specified
3313  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
3314  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
3315  connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
3316  int asyncCallID;
3317  ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
3318  if (ret && error.isValid()) {
3319  ret = 0;
3320  PRINT_ERROR((error.name() + ": " + error.message()))
3321  }
3322  if (ret) {
3323  // Wait for the asynchronous call to return...
3324  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
3325  TQTimer nmCallTimeoutTimer;
3326  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
3327  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
3328  tqApp->processEvents();
3329  if (!nmCallTimeoutTimer.isActive()) {
3330  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
3331  timed_out = true;
3332  break;
3333  }
3334  }
3335  connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
3336  if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
3337  PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
3338  d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
3339  }
3340  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
3341  if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
3342  d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
3343  }
3344 #endif // USE_ASYNC_DBUS_CALLS
3345  existing = true;
3346  }
3347  }
3348 
3349  // Create and/or update settings map from provided connection information
3350  // We start at the outermost layer and work our way inwards, in a structure which should match the parser in loadConnectionInformation() very closely
3351  bool groupValid;
3352  TQT_DBusData dbusData;
3353  TQT_DBusData innerDbusData;
3354  TQMap<TQString, TQT_DBusData> outerMap = connectionSettingsMap.toTQMap();
3355  {
3356  groupValid = false;
3357  dbusData = outerMap["connection"];
3358  {
3359  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3360  {
3361  settingsMap["id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->friendlyName));
3362  {
3363  TQString type;
3364  if (ethernetConnection) type = "802-3-ethernet";
3365  else if (infinibandConnection) type = "infiniband";
3366  else if (wiFiConnection) type = "802-11-wireless";
3367  else if (vpnConnection) type = "vpn";
3368  else if (wiMaxConnection) type = "wimax";
3369  else if (vlanConnection) type = "vlan";
3370  else if (olpcMeshConnection) type = "802-11-olpc-mesh";
3371  else if (bluetoothConnection) type = "bluetooth";
3372  else if (modemConnection) {
3373  if (modemConnection->type == TDEModemConnectionType::CDMA) {
3374  type = "cdma";
3375  }
3376  else if (modemConnection->type == TDEModemConnectionType::GSM) {
3377  type = "gsm";
3378  }
3379  }
3380  if (!type.isNull()) settingsMap["type"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(type));
3381  }
3382  settingsMap["uuid"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->UUID));
3383  {
3384  TQT_DBusDataValueList valueList;
3385  {
3386  for (TQStringList::Iterator it = connection->authorizedUsers.begin(); it != connection->authorizedUsers.end(); ++it) {
3387  TQString assembledString = TQString("user:%1:").arg(*it);
3388  valueList.append(TQT_DBusData::fromString(assembledString));
3389  }
3390  }
3391  if (valueList.count() > 0) settingsMap["permissions"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3392  else settingsMap.remove("permissions");
3393  }
3394  settingsMap["autoconnect"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->autoConnect));
3395  settingsMap["read-only"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->readOnly));
3396  UPDATE_STRING_SETTING_IF_VALID(connection->masterConnectionUUID, "master", settingsMap)
3397  {
3398  TQString slaveType = tdeSlaveTypeToNMSlaveType(connection->slaveType);
3399  if (slaveType != "") settingsMap["slave-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(slaveType));
3400  else settingsMap.remove("slave-type");
3401  }
3402  // settingsMap["timestamp"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt64(connection->lastKnownConnection.toTime_t())); // Probably read-only to us
3403  }
3404  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3405  groupValid = (settingsMap.count() > 0);
3406  }
3407  if (groupValid) outerMap.insert("connection", dbusData, TRUE); else outerMap.remove("connection");
3408 
3409  groupValid = false;
3410  dbusData = outerMap["802-1x"];
3411  {
3412  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3413  {
3414  if (connection->eapConfig.valid) {
3415  TQT_DBusDataValueList valueList;
3416  {
3417  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
3418  // EAP type
3419  valueList.append(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.type)));
3420  }
3421  settingsMap["eap"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3422  }
3423  else {
3424  settingsMap.remove("eap");
3425  }
3426  if (connection->eapConfig.valid) {
3427  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.userName, "identity", settingsMap)
3428  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.anonymousUserName, "anonymous-identity", settingsMap)
3429  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.pacFileName, "pac-file", settingsMap)
3430  }
3431  else {
3432  settingsMap.remove("identity");
3433  settingsMap.remove("anonymous-identity");
3434  settingsMap.remove("pac-file");
3435  }
3436  if (connection->eapConfig.valid) {
3437  TQT_DBusDataValueList valueList;
3438  {
3439  unsigned int count;
3440  for (count=0; count<connection->eapConfig.caCertificate.count(); count++) {
3441  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.caCertificate[count]));
3442  }
3443  }
3444  if (valueList.count() > 0) settingsMap["ca-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3445  else settingsMap.remove("ca-cert");
3446  }
3447  else {
3448  settingsMap.remove("ca-cert");
3449  }
3450  if (connection->eapConfig.valid) {
3451  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.additionalCAFilesPath, "ca-path", settingsMap)
3452  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.authServerCertSubjectMatch, "subject-match", settingsMap)
3453  }
3454  else {
3455  settingsMap.remove("ca-path");
3456  settingsMap.remove("subject-match");
3457  }
3458  if (connection->eapConfig.valid) {
3459  TQT_DBusDataValueList valueList;
3460  {
3461  for (TQStringList::Iterator it = connection->eapConfig.alternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.alternateAuthServerCertSubjectMatch.end(); ++it) {
3462  valueList.append(TQT_DBusData::fromString(*it));
3463  }
3464  }
3465  if (valueList.count() > 0) settingsMap["altsubject-matches"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3466  else settingsMap.remove("altsubject-matches");
3467  }
3468  else {
3469  settingsMap.remove("altsubject-matches");
3470  }
3471  if (connection->eapConfig.valid) {
3472  TQT_DBusDataValueList valueList;
3473  {
3474  unsigned int count;
3475  for (count=0; count<connection->eapConfig.clientCertificate.count(); count++) {
3476  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.clientCertificate[count]));
3477  }
3478  }
3479  if (valueList.count() > 0) settingsMap["client-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3480  else settingsMap.remove("client-cert");
3481  }
3482  else {
3483  settingsMap.remove("client-cert");
3484  }
3485  if (connection->eapConfig.valid) {
3486  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPVersion, "phase1-peapver", settingsMap)
3487  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPLabel, "phase1-peaplabel", settingsMap)
3488  UPDATE_STRING_SETTING_IF_VALID(tdeEAPFastFlagsToNMEAPFastFlags(connection->eapConfig.fastProvisioningFlags), "phase1-fast-provisioning", settingsMap)
3489  }
3490  else {
3491  settingsMap.remove("phase1-peapver");
3492  settingsMap.remove("phase1-peaplabel");
3493  settingsMap.remove("phase1-fast-provisioning");
3494  }
3495  if (connection->eapConfig.valid) {
3496  settingsMap["phase2-auth"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2NonEAPAuthMethod)));
3497  settingsMap["phase2-autheap"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2EAPAuthMethod)));
3498  }
3499  else {
3500  settingsMap.remove("phase2-auth");
3501  settingsMap.remove("phase2-autheap");
3502  }
3503  if (connection->eapConfig.valid) {
3504  TQT_DBusDataValueList valueList;
3505  {
3506  unsigned int count;
3507  for (count=0; count<connection->eapConfig.phase2CaCertificate.count(); count++) {
3508  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2CaCertificate[count]));
3509  }
3510  }
3511  if (valueList.count() > 0) settingsMap["phase2-ca-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3512  else settingsMap.remove("phase2-ca-cert");
3513  }
3514  else {
3515  settingsMap.remove("phase2-ca-cert");
3516  }
3517  if (connection->eapConfig.valid) {
3518  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2CaFilesPath, "phase2-ca-path", settingsMap)
3519  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2AuthServerCertSubjectMatch, "phase2-subject-match", settingsMap)
3520  }
3521  else {
3522  settingsMap.remove("phase2-ca-path");
3523  settingsMap.remove("phase2-subject-match");
3524  }
3525  if (connection->eapConfig.valid) {
3526  TQT_DBusDataValueList valueList;
3527  {
3528  for (TQStringList::Iterator it = connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.end(); ++it) {
3529  valueList.append(TQT_DBusData::fromString(*it));
3530  }
3531  }
3532  if (valueList.count() > 0) settingsMap["phase2-altsubject-matches"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3533  else settingsMap.remove("phase2-altsubject-matches");
3534  }
3535  else {
3536  settingsMap.remove("phase2-altsubject-matches");
3537  }
3538  if (connection->eapConfig.valid) {
3539  TQT_DBusDataValueList valueList;
3540  {
3541  unsigned int count;
3542  for (count=0; count<connection->eapConfig.phase2ClientCertificate.count(); count++) {
3543  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2ClientCertificate[count]));
3544  }
3545  }
3546  if (valueList.count() > 0) settingsMap["phase2-client-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3547  else settingsMap.remove("phase2-client-cert");
3548  }
3549  else {
3550  settingsMap.remove("phase2-client-cert");
3551  }
3552  if (connection->eapConfig.valid) {
3553  settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.passwordFlags)));
3554  settingsMap["password-raw-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.binaryPasswordFlags)));
3555  }
3556  else {
3557  settingsMap.remove("password-flags");
3558  settingsMap.remove("password-raw-flags");
3559  }
3560  if (connection->eapConfig.valid) {
3561  TQT_DBusDataValueList valueList;
3562  {
3563  unsigned int count;
3564  for (count=0; count<connection->eapConfig.privateKey.count(); count++) {
3565  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.privateKey[count]));
3566  }
3567  }
3568  if (valueList.count() > 0) settingsMap["private-key"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3569  else settingsMap.remove("private-key");
3570  }
3571  else {
3572  settingsMap.remove("private-key");
3573  }
3574  if (connection->eapConfig.valid) {
3575  settingsMap["private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.privateKeyPasswordFlags)));
3576  }
3577  else {
3578  settingsMap.remove("private-key-password-flags");
3579  }
3580  if (connection->eapConfig.valid) {
3581  TQT_DBusDataValueList valueList;
3582  {
3583  unsigned int count;
3584  for (count=0; count<connection->eapConfig.phase2PrivateKey.count(); count++) {
3585  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2PrivateKey[count]));
3586  }
3587  }
3588  if (valueList.count() > 0) settingsMap["phase2-private-key"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3589  else settingsMap.remove("phase2-private-key");
3590  }
3591  else {
3592  settingsMap.remove("phase2-private-key");
3593  }
3594  if (connection->eapConfig.valid) {
3595  settingsMap["phase2-private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.phase2PrivateKeyPasswordFlags)));
3596  }
3597  else {
3598  settingsMap.remove("phase2-private-key-password-flags");
3599  }
3600  if (connection->eapConfig.valid) {
3601  settingsMap["system-ca-certs"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->eapConfig.forceSystemCaCertificates));
3602  }
3603  else {
3604  settingsMap.remove("system-ca-certs");
3605  }
3606  if (connection->eapConfig.secretsValid) {
3607  settingsMap["password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.password));
3608  }
3609  else {
3610  settingsMap.remove("password");
3611  }
3612  if (connection->eapConfig.valid) {
3613  TQT_DBusDataValueList valueList;
3614  {
3615  unsigned int count;
3616  for (count=0; count<connection->eapConfig.binaryPassword.count(); count++) {
3617  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.binaryPassword[count]));
3618  }
3619  }
3620  if (valueList.count() > 0) settingsMap["password-raw"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3621  else settingsMap.remove("password-raw");
3622  }
3623  else {
3624  settingsMap.remove("password-raw");
3625  }
3626  if (connection->eapConfig.secretsValid) {
3627  settingsMap["private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.privateKeyPassword));
3628  settingsMap["phase2-private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.phase2PrivateKeyPassword));
3629  }
3630  else {
3631  settingsMap.remove("private-key-password");
3632  settingsMap.remove("phase2-private-key-password");
3633  }
3634  }
3635  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3636  groupValid = (settingsMap.count() > 0);
3637  }
3638  if (groupValid) outerMap.insert("802-1x", dbusData, TRUE); else outerMap.remove("802-1x");
3639 
3640  groupValid = false;
3641  dbusData = outerMap["802-3-ethernet"];
3642  if (ethernetConnection) {
3643  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3644  {
3645  settingsMap["duplex"] = convertDBUSDataToVariantData(TQT_DBusData::fromString((connection->fullDuplex)?"full":"half"));
3646  if (connection->lockedHWAddress.isValid()) {
3647  TDENetworkByteList address = connection->lockedHWAddress.address();
3648  TQT_DBusDataValueList valueList;
3649  TDENetworkByteList::iterator it;
3650  for (it = address.begin(); it != address.end(); ++it) {
3651  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3652  valueList.append(innerDataValue);
3653  }
3654  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3655  settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3656  }
3657  else {
3658  settingsMap.remove("mac-address");
3659  }
3660  if (connection->manualHWAddress.isValid()) {
3661  TDENetworkByteList address = connection->manualHWAddress.address();
3662  TQT_DBusDataValueList valueList;
3663  TDENetworkByteList::iterator it;
3664  for (it = address.begin(); it != address.end(); ++it) {
3665  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3666  valueList.append(innerDataValue);
3667  }
3668  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3669  settingsMap["cloned-mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3670  }
3671  else {
3672  settingsMap.remove("cloned-mac-address");
3673  }
3674  if (connection->mtu > 0) {
3675  settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
3676  }
3677  else {
3678  settingsMap.remove("mtu");
3679  }
3680  }
3681  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3682  groupValid = (settingsMap.count() > 0);
3683  }
3684  if (groupValid) outerMap.insert("802-3-ethernet", dbusData, TRUE); else outerMap.remove("802-3-ethernet");
3685 
3686  groupValid = false;
3687  dbusData = outerMap["infiniband"];
3688  if (infinibandConnection) {
3689  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3690  {
3691  if (connection->lockedHWAddress.isValid()) {
3692  TDENetworkByteList address = connection->lockedHWAddress.address();
3693  TQT_DBusDataValueList valueList;
3694  TDENetworkByteList::iterator it;
3695  for (it = address.begin(); it != address.end(); ++it) {
3696  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3697  valueList.append(innerDataValue);
3698  }
3699  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3700  settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3701  }
3702  else {
3703  settingsMap.remove("mac-address");
3704  }
3705  if (connection->mtu > 0) {
3706  settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
3707  }
3708  else {
3709  settingsMap.remove("mtu");
3710  }
3711  UPDATE_STRING_SETTING_IF_VALID(tdeIBTransportToNMIBTransport(infinibandConnection->transportMode), "transport-mode", settingsMap)
3712  }
3713  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3714  groupValid = (settingsMap.count() > 0);
3715  }
3716  if (groupValid) outerMap.insert("infiniband", dbusData, TRUE); else outerMap.remove("infiniband");
3717 
3718  groupValid = false;
3719  dbusData = outerMap["802-11-wireless"];
3720  if (wiFiConnection) {
3721  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3722  {
3723  {
3724  unsigned int i;
3725  TQT_DBusDataValueList valueList;
3726  for (i=0; i<wiFiConnection->SSID.count(); i++) {
3727  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(wiFiConnection->SSID[i]);
3728  valueList.append(innerDataValue);
3729  }
3730  settingsMap["ssid"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3731  }
3732  if (connection->lockedHWAddress.isValid()) {
3733  TDENetworkByteList address = connection->lockedHWAddress.address();
3734  TQT_DBusDataValueList valueList;
3735  TDENetworkByteList::iterator it;
3736  for (it = address.begin(); it != address.end(); ++it) {
3737  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3738  valueList.append(innerDataValue);
3739  }
3740  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3741  settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3742  }
3743  else {
3744  settingsMap.remove("mac-address");
3745  }
3746  if (connection->manualHWAddress.isValid()) {
3747  TDENetworkByteList address = connection->manualHWAddress.address();
3748  TQT_DBusDataValueList valueList;
3749  TDENetworkByteList::iterator it;
3750  for (it = address.begin(); it != address.end(); ++it) {
3751  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3752  valueList.append(innerDataValue);
3753  }
3754  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3755  settingsMap["cloned-mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3756  }
3757  else {
3758  settingsMap.remove("cloned-mac-address");
3759  }
3760  if (connection->mtu > 0) {
3761  settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
3762  }
3763  else {
3764  settingsMap.remove("mtu");
3765  }
3766  UPDATE_STRING_SETTING_IF_VALID(tdeWiFiModeToNMWiFiMode(wiFiConnection->operatingMode), "mode", settingsMap)
3767  UPDATE_STRING_SETTING_IF_VALID(tdeWiFiFrequencyBandToNMWiFiFrequencyBand(wiFiConnection->bandRestriction), "band", settingsMap)
3768  if (wiFiConnection->channelRestriction > 0) {
3769  settingsMap["channel"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->channelRestriction));
3770  }
3771  else {
3772  settingsMap.remove("channel");
3773  }
3774  if (wiFiConnection->bitRateRestriction > 0) {
3775  settingsMap["rate"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->bitRateRestriction/1000));
3776  }
3777  else {
3778  settingsMap.remove("rate");
3779  }
3780  if (wiFiConnection->powerRestriction > 0) {
3781  settingsMap["tx-power"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->powerRestriction));
3782  }
3783  else {
3784  settingsMap.remove("tx-power");
3785  }
3786  if (wiFiConnection->accessPointRestriction.isValid()) {
3787  TDENetworkByteList address = wiFiConnection->accessPointRestriction.address();
3788  TQT_DBusDataValueList valueList;
3789  TDENetworkByteList::iterator it;
3790  for (it = address.begin(); it != address.end(); ++it) {
3791  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3792  valueList.append(innerDataValue);
3793  }
3794  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3795  settingsMap["bssid"] = convertDBUSDataToVariantData(nmHWAddress);
3796  }
3797  else {
3798  settingsMap.remove("bssid");
3799  }
3800  {
3801  TQT_DBusDataValueList valueList;
3802  TDEMACAddressList::iterator it;
3803  for (it = wiFiConnection->blacklistedBSSIDs.begin(); it != wiFiConnection->blacklistedBSSIDs.end(); ++it) {
3804  valueList.append(TQT_DBusData::fromString((*it).toString()));
3805  }
3806  if (valueList.count() > 0) settingsMap["mac-address-blacklist"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3807  }
3808  {
3809  TQT_DBusDataValueList valueList;
3810  TDEMACAddressList::iterator it;
3811  for (it = wiFiConnection->heardBSSIDs.begin(); it != wiFiConnection->heardBSSIDs.end(); ++it) {
3812  valueList.append(TQT_DBusData::fromString((*it).toString()));
3813  }
3814  if (valueList.count() > 0) settingsMap["seen-bssids"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3815  }
3816  {
3817  if (wiFiConnection->securityRequired) {
3818  settingsMap["security"] = convertDBUSDataToVariantData(TQT_DBusData::fromString("802-11-wireless-security"));
3819  }
3820  else {
3821  settingsMap.remove("security");
3822  }
3823  }
3824  {
3825  if (wiFiConnection->isHiddenNetwork) {
3826  settingsMap["hidden"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(true));
3827  }
3828  else {
3829  settingsMap.remove("hidden");
3830  }
3831  }
3832  }
3833  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3834  groupValid = (settingsMap.count() > 0);
3835  }
3836  if (groupValid) outerMap.insert("802-11-wireless", dbusData, TRUE); else outerMap.remove("802-11-wireless");
3837 
3838  groupValid = false;
3839  dbusData = outerMap["802-11-wireless-security"];
3840  if (wiFiConnection) {
3841  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3842  {
3843  if (wiFiConnection->securityRequired) {
3844  if (wiFiConnection->securityRequired) {
3845  settingsMap["key-mgmt"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeWiFiKeyTypeToNMWiFiKeyType(wiFiConnection->securitySettings.keyType)));
3846  }
3847  if (wiFiConnection->securitySettings.wepKeyIndex > 0) {
3848  settingsMap["wep-tx-keyidx"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->securitySettings.wepKeyIndex));
3849  }
3850  else {
3851  settingsMap.remove("wep-tx-keyidx");
3852  }
3853  UPDATE_STRING_SETTING_IF_VALID(tdeWiFiAuthTypeToNMWiFiAuthType(wiFiConnection->securitySettings.authType), "auth-alg", settingsMap)
3854  {
3855  TQT_DBusDataValueList valueList;
3856  {
3857  TQStringList strings = tdeWiFiWPAVersionToNMWiFiWPAVersion(wiFiConnection->securitySettings.wpaVersion);
3858  for (TQStringList::Iterator it = strings.begin(); it != strings.end(); ++it) {
3859  valueList.append(TQT_DBusData::fromString(*it));
3860  }
3861  }
3862  if (valueList.count() > 0) settingsMap["proto"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3863  else settingsMap.remove("proto");
3864  }
3865  {
3866  TQT_DBusDataValueList valueList;
3867  {
3868  if (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
3869  if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
3870  if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
3871  if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
3872  if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
3873  }
3874  for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedPairWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedPairWiseCiphers.end(); ++it) {
3875  valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
3876  }
3877  }
3878  if (valueList.count() > 0) settingsMap["pairwise"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3879  else settingsMap.remove("pairwise");
3880  }
3881  {
3882  TQT_DBusDataValueList valueList;
3883  {
3884  if (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
3885  if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
3886  if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
3887  if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
3888  if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
3889  }
3890  for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedGroupWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedGroupWiseCiphers.end(); ++it) {
3891  valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
3892  }
3893  }
3894  if (valueList.count() > 0) settingsMap["group"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3895  else settingsMap.remove("group");
3896  }
3897  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapUsername, "leap-username", settingsMap)
3898  settingsMap["wep-key-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.wepKeyFlags)));
3899  settingsMap["wep-key-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType)));
3900  settingsMap["psk-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.pskFlags)));
3901  settingsMap["leap-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.leapPasswordFlags)));
3902  if (wiFiConnection->securitySettings.secretsValid) {
3903  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey0, "wep-key0", settingsMap)
3904  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey1, "wep-key1", settingsMap)
3905  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey2, "wep-key2", settingsMap)
3906  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey3, "wep-key3", settingsMap)
3907  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.psk, "psk", settingsMap)
3908  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapPassword, "leap-password", settingsMap)
3909  }
3910  else {
3911  settingsMap.remove("wep-key0");
3912  settingsMap.remove("wep-key1");
3913  settingsMap.remove("wep-key2");
3914  settingsMap.remove("wep-key3");
3915  settingsMap.remove("psk");
3916  settingsMap.remove("leap-password");
3917  }
3918  }
3919  else {
3920  settingsMap.remove("key-mgmt");
3921  settingsMap.remove("wep-tx-keyidx");
3922  settingsMap.remove("auth-alg");
3923  settingsMap.remove("proto");
3924  settingsMap.remove("pairwise");
3925  settingsMap.remove("group");
3926  settingsMap.remove("leap-username");
3927  settingsMap.remove("wep-key-flags");
3928  settingsMap.remove("wep-key-type");
3929  settingsMap.remove("psk-flags");
3930  settingsMap.remove("leap-password-flags");
3931  settingsMap.remove("wep-key0");
3932  settingsMap.remove("wep-key1");
3933  settingsMap.remove("wep-key2");
3934  settingsMap.remove("wep-key3");
3935  settingsMap.remove("psk");
3936  settingsMap.remove("leap-password");
3937  }
3938  }
3939  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3940  groupValid = (settingsMap.count() > 0);
3941  }
3942  if (groupValid) outerMap.insert("802-11-wireless-security", dbusData, TRUE); else outerMap.remove("802-11-wireless-security");
3943 
3944  groupValid = false;
3945  dbusData = outerMap["vpn"];
3946  if (vpnConnection) {
3947  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3948  {
3949  {
3950  TQString pluginService = vpnConnection->vpnPluginID;
3951  if (pluginService != "") {
3952  pluginService = "org.freedesktop.NetworkManager." + pluginService;
3953  }
3954  UPDATE_STRING_SETTING_IF_VALID(pluginService, "service-type", settingsMap)
3955  }
3956  UPDATE_STRING_SETTING_IF_VALID(vpnConnection->lockedUserName, "user-name", settingsMap)
3957  {
3958  TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
3959  TDENetworkSettingsMap::const_iterator it;
3960  for (it = vpnConnection->pluginData.begin(); it != vpnConnection->pluginData.end(); ++it) {
3961  nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
3962  }
3963  if (nestedConnectionSettingsMap.count() > 0) settingsMap["data"] = convertDBUSDataToVariantData(TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap)));
3964  else settingsMap.remove("data");
3965  }
3966  if (vpnConnection->secretsValid) {
3967  TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
3968  TDENetworkSettingsMap::const_iterator it;
3969  for (it = vpnConnection->pluginSecrets.begin(); it != vpnConnection->pluginSecrets.end(); ++it) {
3970  nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
3971  }
3972  if (nestedConnectionSettingsMap.count() > 0) settingsMap["secrets"] = convertDBUSDataToVariantData(TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap)));
3973  else settingsMap.remove("secrets");
3974  }
3975  }
3976  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3977  groupValid = (settingsMap.count() > 0);
3978  }
3979  if (groupValid) outerMap.insert("vpn", dbusData, TRUE); else outerMap.remove("vpn");
3980 
3981  groupValid = false;
3982  dbusData = outerMap["wimax"];
3983  if (wiMaxConnection) {
3984  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3985  {
3986  if (connection->lockedHWAddress.isValid()) {
3987  TDENetworkByteList address = connection->lockedHWAddress.address();
3988  TQT_DBusDataValueList valueList;
3989  TDENetworkByteList::iterator it;
3990  for (it = address.begin(); it != address.end(); ++it) {
3991  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3992  valueList.append(innerDataValue);
3993  }
3994  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3995  settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3996  }
3997  else {
3998  settingsMap.remove("mac-address");
3999  }
4000  UPDATE_STRING_SETTING_IF_VALID(wiMaxConnection->networkServiceProvider, "network-name", settingsMap)
4001  }
4002  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4003  groupValid = (settingsMap.count() > 0);
4004  }
4005  if (groupValid) outerMap.insert("wimax", dbusData, TRUE); else outerMap.remove("wimax");
4006 
4007  groupValid = false;
4008  dbusData = outerMap["vlan"];
4009  if (vlanConnection) {
4010  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4011  {
4012  UPDATE_STRING_SETTING_IF_VALID(vlanConnection->kernelName, "interface-name", settingsMap)
4013  UPDATE_STRING_SETTING_IF_VALID(vlanConnection->parentConnectionUUID, "parent", settingsMap)
4014  settingsMap["id"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(vlanConnection->vlanID));
4015  settingsMap["flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdeVLANFlagsToNMVLANFlags(vlanConnection->vlanFlags)));
4016  {
4017  TQT_DBusDataValueList valueList;
4018  TDENetworkPriorityMap::const_iterator it;
4019  for (it = vlanConnection->ingressPriorityMap.begin(); it != vlanConnection->ingressPriorityMap.end(); ++it) {
4020  valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
4021  }
4022  if (valueList.count() > 0) settingsMap["ingress-priority-map"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4023  }
4024  {
4025  TQT_DBusDataValueList valueList;
4026  TDENetworkPriorityMap::const_iterator it;
4027  for (it = vlanConnection->egressPriorityMap.begin(); it != vlanConnection->egressPriorityMap.end(); ++it) {
4028  valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
4029  }
4030  if (valueList.count() > 0) settingsMap["egress-priority-map"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4031  }
4032  }
4033  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4034  groupValid = (settingsMap.count() > 0);
4035  }
4036  if (groupValid) outerMap.insert("vlan", dbusData, TRUE); else outerMap.remove("vlan");
4037 
4038  groupValid = false;
4039  dbusData = outerMap["serial"];
4040  if (connection->serialConfig.valid) {
4041  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4042  {
4043  settingsMap["baud"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.baudRate));
4044  settingsMap["bits"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.byteWidth));
4045  settingsMap["parity"] = convertDBUSDataToVariantData(TQT_DBusData::fromByte(tdeParityToNMParity(connection->serialConfig.parity)));
4046  settingsMap["stopbits"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.stopBits));
4047  settingsMap["send-delay"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt64(connection->serialConfig.txDelay));
4048  }
4049  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4050  groupValid = (settingsMap.count() > 0);
4051  }
4052  if (groupValid) outerMap.insert("serial", dbusData, TRUE); else outerMap.remove("serial");
4053 
4054  groupValid = false;
4055  dbusData = outerMap["ppp"];
4056  if (connection->pppConfig.valid) {
4057  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4058  {
4059  settingsMap["noauth"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.requireServerAuthentication)));
4060  settingsMap["refuse-eap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableEAP));
4061  settingsMap["refuse-pap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisablePAP));
4062  settingsMap["refuse-chap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableCHAP));
4063  settingsMap["refuse-mschap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAP));
4064  settingsMap["refuse-mschapv2"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAPv2));
4065  settingsMap["nobsdcomp"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowBSDCompression)));
4066  settingsMap["nodeflate"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowDeflateCompression)));
4067  settingsMap["no-vj-comp"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowVJCompression)));
4068  settingsMap["require-mppe"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE));
4069  settingsMap["require-mppe-128"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE128));
4070  settingsMap["mppe-stateful"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::StatefulMPPE));
4071  settingsMap["crtscts"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::UseHardwareFlowControl));
4072  settingsMap["baud"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.baudRate));
4073  if (connection->pppConfig.mru > 0) {
4074  settingsMap["mru"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.mru));
4075  }
4076  else {
4077  settingsMap.remove("mru");
4078  }
4079  if (connection->pppConfig.mtu > 0) {
4080  settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.mtu));
4081  }
4082  else {
4083  settingsMap.remove("mtu");
4084  }
4085  if (connection->pppConfig.mtu > 0) {
4086  settingsMap["lcp-echo-interval"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoPingInterval));
4087  }
4088  else {
4089  settingsMap.remove("lcp-echo-interval");
4090  }
4091  if (connection->pppConfig.mtu > 0) {
4092  settingsMap["lcp-echo-failure"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoFailureThreshold));
4093  }
4094  else {
4095  settingsMap.remove("lcp-echo-failure");
4096  }
4097  }
4098  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4099  groupValid = (settingsMap.count() > 0);
4100  }
4101  if (groupValid) outerMap.insert("ppp", dbusData, TRUE); else outerMap.remove("ppp");
4102 
4103  groupValid = false;
4104  dbusData = outerMap["pppoe"];
4105  if (connection->pppoeConfig.valid) {
4106  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4107  {
4108  UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.networkServiceProvider, "service", settingsMap)
4109  UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.username, "username", settingsMap)
4110  if (connection->pppoeConfig.secretsValid) {
4111  UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.password, "password", settingsMap)
4112  }
4113  settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->pppoeConfig.passwordFlags)));
4114  }
4115  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4116  groupValid = (settingsMap.count() > 0);
4117  }
4118  if (groupValid) outerMap.insert("pppoe", dbusData, TRUE); else outerMap.remove("pppoe");
4119 
4120  groupValid = false;
4121  dbusData = outerMap["802-11-olpc-mesh"];
4122  if (olpcMeshConnection) {
4123  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4124  {
4125  {
4126  unsigned int i;
4127  TQT_DBusDataValueList valueList;
4128  for (i=0; i<olpcMeshConnection->SSID.count(); i++) {
4129  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->SSID[i]);
4130  valueList.append(innerDataValue);
4131  }
4132  settingsMap["ssid"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4133  }
4134  settingsMap["channel"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(olpcMeshConnection->channel));
4135  {
4136  unsigned int i;
4137  TQT_DBusDataValueList valueList;
4138  for (i=0; i<olpcMeshConnection->anycastDHCPHWAddress.count(); i++) {
4139  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->anycastDHCPHWAddress[i]);
4140  valueList.append(innerDataValue);
4141  }
4142  settingsMap["dhcp-anycast-address"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4143  }
4144  }
4145  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4146  groupValid = (settingsMap.count() > 0);
4147  }
4148  if (groupValid) outerMap.insert("802-11-olpc-mesh", dbusData, TRUE); else outerMap.remove("802-11-olpc-mesh");
4149 
4150  groupValid = false;
4151  dbusData = outerMap["bluetooth"];
4152  if (bluetoothConnection) {
4153  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4154  {
4155  if (connection->lockedHWAddress.isValid()) {
4156  TDENetworkByteList address = connection->lockedHWAddress.address();
4157  TQT_DBusDataValueList valueList;
4158  TDENetworkByteList::iterator it;
4159  for (it = address.begin(); it != address.end(); ++it) {
4160  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
4161  valueList.append(innerDataValue);
4162  }
4163  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
4164  settingsMap["bdaddr"] = convertDBUSDataToVariantData(nmHWAddress);
4165  }
4166  else {
4167  settingsMap.remove("bdaddr");
4168  }
4169  UPDATE_STRING_SETTING_IF_VALID(tdeBluetoothModeToNMBluetoothMode(bluetoothConnection->type), "type", settingsMap)
4170  }
4171  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4172  groupValid = (settingsMap.count() > 0);
4173  }
4174  if (groupValid) outerMap.insert("bluetooth", dbusData, TRUE); else outerMap.remove("bluetooth");
4175 
4176  groupValid = false;
4177  dbusData = outerMap["cdma"];
4178  if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::CDMA)) {
4179  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4180  {
4181  UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.providerDataNumber, "number", settingsMap)
4182  UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.username, "username", settingsMap)
4183  if (connection->pppoeConfig.secretsValid) {
4184  UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.password, "password", settingsMap)
4185  }
4186  settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->cdmaConfig.passwordFlags)));
4187  }
4188  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4189  groupValid = (settingsMap.count() > 0);
4190  }
4191  if (groupValid) outerMap.insert("cdma", dbusData, TRUE); else outerMap.remove("cdma");
4192 
4193  groupValid = false;
4194  dbusData = outerMap["gsm"];
4195  if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::GSM)) {
4196  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4197  {
4198  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.providerDataNumber, "number", settingsMap)
4199  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.username, "username", settingsMap)
4200  if (connection->pppoeConfig.secretsValid) {
4201  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.password, "password", settingsMap)
4202  }
4203  settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.passwordFlags)));
4204  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.accessPointName, "apn", settingsMap)
4205  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.networkID, "network-id", settingsMap)
4206  settingsMap["network-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromInt32(tdeGSMModeToNMGSMMode(modemConnection->gsmConfig.networkType)));
4207  if (connection->pppoeConfig.secretsValid) {
4208  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.pin, "pin", settingsMap)
4209  }
4210  settingsMap["pin-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.pinFlags)));
4211  settingsMap["allowed-bands"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(modemConnection->gsmConfig.allowedFrequencyBands));
4212  settingsMap["home-only"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(modemConnection->gsmConfig.allowRoaming)));
4213  }
4214  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4215  groupValid = (settingsMap.count() > 0);
4216  }
4217  if (groupValid) outerMap.insert("gsm", dbusData, TRUE); else outerMap.remove("gsm");
4218 
4219  groupValid = false;
4220  dbusData = outerMap["ipv4"];
4221  {
4222  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4223  {
4224  {
4225  TQT_DBusDataValueList valueList;
4226  TDENetworkSingleIPConfigurationList::iterator it;
4227  for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
4228  if ((*it).isIPv4()) {
4229  TQT_DBusDataValueList innerValueList;
4230  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4231  // Address
4232  innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
4233  // Netmask
4234  innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
4235  // Gateway
4236  innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
4237  valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
4238  }
4239  }
4240  if (valueList.count() <= 0) {
4241  // Create an empty list with the correct DBUS type structure
4242  TQT_DBusData valueList;
4243  valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
4244  settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
4245  }
4246  else {
4247  settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4248  }
4249  }
4250  {
4251  if (!connection->ipConfig.dhcpClientIdentifier.isNull()) {
4252  settingsMap["dhcp-client-id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->ipConfig.dhcpClientIdentifier));
4253  }
4254  }
4255  {
4256  TQT_DBusDataValueList valueList;
4257  TDENetworkAddressList::iterator it;
4258  for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
4259  if ((*it).isIPv4Address()) {
4260  valueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).toIPv4Address())));
4261  }
4262  }
4263  if (valueList.count() <= 0) {
4264  // Create an empty list with the correct DBUS type structure
4265  settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32)));
4266  }
4267  else {
4268  settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4269  }
4270  }
4271  {
4272  TQT_DBusDataValueList valueList;
4273  TDENetworkSearchDomainList::iterator it;
4274  for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
4275  if ((*it).isIPv4()) {
4276  valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
4277  }
4278  }
4279  if (valueList.count() > 0) settingsMap["dns-search"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4280  }
4281  {
4282  settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS)));
4283  }
4284  {
4285  settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV4));
4286  }
4287  {
4288  TQString method;
4289  if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP) {
4290  method = "auto";
4291  }
4292  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4LocalOnly) {
4293  method = "link-local";
4294  }
4295  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer) {
4296  method = "shared";
4297  }
4298  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4Disabled) {
4299  method = "disabled";
4300  }
4301  else {
4302  method = "manual";
4303  }
4304  if (!method.isNull())
4305  settingsMap["method"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method));
4306  }
4307  {
4308  settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPRoutes)));
4309  }
4310  {
4311  settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute)));
4312  }
4313  {
4314  TQT_DBusDataValueList valueList;
4315  TDENetworkSingleRouteConfigurationList::iterator it;
4316  for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
4317  if ((*it).isIPv4()) {
4318  TQT_DBusDataValueList innerValueList;
4319  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4320  // Address
4321  innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
4322  // Netmask
4323  innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
4324  // Gateway
4325  innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
4326  // Metric
4327  innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
4328  valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
4329  }
4330  }
4331  if (valueList.count() <= 0) {
4332  // Create an empty list with the correct DBUS type structure
4333  TQT_DBusData valueList;
4334  valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
4335  settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
4336  }
4337  else {
4338  settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4339  }
4340  }
4341  }
4342  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4343  groupValid = (settingsMap.count() > 0);
4344  }
4345  if (groupValid) outerMap.insert("ipv4", dbusData, TRUE); else outerMap.remove("ipv4");
4346 
4347  groupValid = false;
4348  dbusData = outerMap["ipv6"];
4349  {
4350  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4351  {
4352  {
4353  TQT_DBusDataValueList valueList;
4354  TDENetworkSingleIPConfigurationList::iterator it;
4355  for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
4356  if ((*it).isIPv6()) {
4357  int i;
4358  Q_IPV6ADDR v6address;
4359  TQT_DBusDataValueList innerValueList;
4360  TQT_DBusDataValueList innerMostValueList;
4361  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4362  // Address
4363  innerMostValueList.clear();
4364  v6address = (*it).ipAddress.toIPv6Address();
4365  for (i=0; i<16; i++) {
4366  innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4367  }
4368  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4369  // Netmask
4370  innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
4371  // Gateway
4372  innerMostValueList.clear();
4373  v6address = (*it).gateway.toIPv6Address();
4374  for (i=0; i<16; i++) {
4375  innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4376  }
4377  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4378  valueList.append(TQT_DBusData::fromStruct(innerValueList));
4379  }
4380  }
4381  if (valueList.count() <= 0) {
4382  // Create an empty list with the correct DBUS type structure
4383  TQT_DBusDataValueList innerValueList;
4384  TQT_DBusDataValueList innerMostValueList;
4385  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4386  // Address
4387  innerMostValueList.clear();
4388  innerMostValueList.append(TQT_DBusData::fromByte(0));
4389  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4390  // Netmask
4391  innerValueList.append(TQT_DBusData::fromUInt32(0));
4392  // Gateway
4393  innerMostValueList.clear();
4394  innerMostValueList.append(TQT_DBusData::fromByte(0));
4395  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4396  settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList))));
4397  }
4398  else {
4399  settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4400  }
4401  }
4402  {
4403  TQT_DBusDataValueList valueList;
4404  TDENetworkAddressList::iterator it;
4405  for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
4406  if ((*it).isIPv6Address()) {
4407  int i;
4408  Q_IPV6ADDR v6address;
4409  TQT_DBusDataValueList innerValueList;
4410  v6address = (*it).toIPv6Address();
4411  for (i=0; i<16; i++) {
4412  innerValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4413  }
4414  valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
4415  }
4416  }
4417  if (valueList.count() <= 0) {
4418  // Create an empty list with the correct DBUS type structure
4419  TQT_DBusData valueList;
4420  valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::Byte));
4421  settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
4422  }
4423  else {
4424  settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4425  }
4426  }
4427  {
4428  TQT_DBusDataValueList valueList;
4429  TDENetworkSearchDomainList::iterator it;
4430  for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
4431  if ((*it).isIPv6()) {
4432  valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
4433  }
4434  }
4435  if (valueList.count() > 0) settingsMap["dns-search"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4436  }
4437  {
4438  settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS)));
4439  }
4440  {
4441  settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV6));
4442  }
4443  {
4444  TQString method;
4445  if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP) {
4446  method = "auto";
4447  }
4448  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6LocalOnly) {
4449  method = "link-local";
4450  }
4451  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer) {
4452  method = "shared";
4453  }
4454  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6Disabled) {
4455  method = "ignore";
4456  }
4457  else {
4458  method = "manual";
4459  }
4460  if (!method.isNull())
4461  settingsMap["method"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method));
4462  }
4463  {
4464  settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPRoutes)));
4465  }
4466  {
4467  settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute)));
4468  }
4469  {
4470  TQT_DBusDataValueList valueList;
4471  TDENetworkSingleRouteConfigurationList::iterator it;
4472  for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
4473  if ((*it).isIPv6()) {
4474  int i;
4475  Q_IPV6ADDR v6address;
4476  TQT_DBusDataValueList innerValueList;
4477  TQT_DBusDataValueList innerMostValueList;
4478  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4479  // Address
4480  innerMostValueList.clear();
4481  v6address = (*it).ipAddress.toIPv6Address();
4482  for (i=0; i<16; i++) {
4483  innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4484  }
4485  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4486  // Netmask
4487  innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
4488  // Gateway
4489  innerMostValueList.clear();
4490  v6address = (*it).gateway.toIPv6Address();
4491  for (i=0; i<16; i++) {
4492  innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4493  }
4494  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4495  // Metric
4496  innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
4497  valueList.append(TQT_DBusData::fromStruct(innerValueList));
4498  }
4499  }
4500  if (valueList.count() <= 0) {
4501  // Create an empty list with the correct DBUS type structure
4502  TQT_DBusDataValueList innerValueList;
4503  TQT_DBusDataValueList innerMostValueList;
4504  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4505  // Address
4506  innerMostValueList.clear();
4507  innerMostValueList.append(TQT_DBusData::fromByte(0));
4508  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4509  // Netmask
4510  innerValueList.append(TQT_DBusData::fromUInt32(0));
4511  // Gateway
4512  innerMostValueList.clear();
4513  innerMostValueList.append(TQT_DBusData::fromByte(0));
4514  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4515  // Metric
4516  innerValueList.append(TQT_DBusData::fromUInt32(0));
4517  settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList))));
4518  }
4519  else {
4520  settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4521  }
4522  }
4523  }
4524  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4525  groupValid = (settingsMap.count() > 0);
4526  }
4527  if (groupValid) outerMap.insert("ipv6", dbusData, TRUE); else outerMap.remove("ipv6");
4528  }
4529  connectionSettingsMap = TQT_DBusDataMap<TQString>(outerMap);
4530 
4531  // If existing==true, a connection already existed and simply needs to be updated
4532  // If existing==false, a new connection must be created
4533  // To update: Use 'DBus::ConnectionSettingsInterface' with the connection path 'existingConnection' and call 'virtual bool UpdateAsync(int& asyncCallId, const TQT_DBusDataMap<TQString>& properties, TQT_DBusError& error);'
4534  // To create new: Use 'd->m_networkManagerSettings' and call 'virtual bool AddConnectionAsync(int& asyncCallId, const TQT_DBusDataMap<TQString>& connection, TQT_DBusError& error);'
4535 
4536 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4537  printf("[network-manager comm debug] uploaded DBUS object structure map follows:\n"); fflush(stdout);
4538  printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
4539 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4540 
4541  if (existing) {
4542 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4543  printf("[network-manager comm debug] Updating existing connection\n"); fflush(stdout);
4544 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4545  // Save connection settings to the path specified
4546  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
4547  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
4548  connect(&connectionSettings, SIGNAL(UpdateAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
4549  int asyncCallID;
4550  ret = connectionSettings.UpdateAsync(asyncCallID, connectionSettingsMap, error);
4551  if (ret && error.isValid()) {
4552  ret = 0;
4553  PRINT_ERROR((error.name() + ": " + error.message()))
4554  }
4555  if (ret) {
4556  // Wait for the asynchronous call to return...
4557  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
4558  TQTimer nmCallTimeoutTimer;
4559  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
4560  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
4561  tqApp->processEvents();
4562  if (!nmCallTimeoutTimer.isActive()) {
4563  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
4564  timed_out = true;
4565  break;
4566  }
4567  }
4568  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
4569  return !timed_out;
4570  }
4571  else {
4572  // Error!
4573  PRINT_ERROR((error.name() + ": " + error.message()))
4574  return FALSE;
4575  }
4576  }
4577  else {
4578 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4579  printf("[network-manager comm debug] Creating new connection\n"); fflush(stdout);
4580 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4581  // Create new connection
4582  connect(d->m_networkManagerSettings, SIGNAL(AddConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
4583  connect(d->m_networkManagerSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
4584  int asyncCallID;
4585  ret = d->m_networkManagerSettings->AddConnectionAsync(asyncCallID, connectionSettingsMap, error);
4586  if (ret && error.isValid()) {
4587  ret = 0;
4588  PRINT_ERROR((error.name() + ": " + error.message()))
4589  }
4590  if (ret) {
4591  // Wait for the asynchronous call to return...
4592  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
4593  TQTimer nmCallTimeoutTimer;
4594  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
4595  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
4596  if (!nmCallTimeoutTimer.isActive()) {
4597  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
4598  timed_out = true;
4599  break;
4600  }
4601  tqApp->processEvents();
4602  }
4603  if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
4604  PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
4605  d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
4606  }
4607  if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
4608  PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
4609  command_failed = true;
4610  }
4611  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
4612  if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
4613  d->nmAddConnectionAsyncResponse.remove(asyncCallID);
4614  }
4615  return ((!timed_out) && (!command_failed));
4616  }
4617  else {
4618  // Error!
4619  PRINT_ERROR((error.name() + ": " + error.message()))
4620  return FALSE;
4621  }
4622  }
4623 }
4624 
4625 bool TDENetworkConnectionManager_BackendNM::deleteConnection(TQString uuid) {
4626  TQT_DBusObjectPath existingConnection;
4627  TQT_DBusError error;
4628  bool timed_out = false;
4629  bool ret;
4630  if (d->m_networkManagerSettings) {
4631  ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
4632  if (ret) {
4633  // Obtain connection secrets from the path specified
4634  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
4635  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
4636  connect(&connectionSettings, SIGNAL(DeleteAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
4637  int asyncCallID;
4638  ret = connectionSettings.DeleteAsync(asyncCallID, error);
4639  if (ret && error.isValid()) {
4640  ret = 0;
4641  PRINT_ERROR((error.name() + ": " + error.message()))
4642  }
4643  if (ret) {
4644  // Wait for the asynchronous call to return...
4645  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
4646  TQTimer nmCallTimeoutTimer;
4647  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
4648  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
4649  tqApp->processEvents();
4650  if (!nmCallTimeoutTimer.isActive()) {
4651  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
4652  timed_out = true;
4653  break;
4654  }
4655  }
4656  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
4657  return !timed_out;
4658  }
4659  else {
4660  PRINT_ERROR(TQString("Unable to remove connection with uuid '%1'").arg(uuid))
4661  return FALSE;
4662  }
4663  }
4664  else {
4665  PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
4666  return FALSE;
4667  }
4668  }
4669  else {
4670  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4671  return FALSE;
4672  }
4673 }
4674 
4675 bool TDENetworkConnectionManager_BackendNM::verifyConnectionSettings(TDENetworkConnection* connection, TDENetworkConnectionErrorFlags::TDENetworkConnectionErrorFlags* type, TDENetworkErrorStringMap* reason) {
4676  // FIXME
4677  // This should actually attempt to validate all the settings!
4678 
4679  if (!connection) {
4680  return false;
4681  }
4682 
4683  if (connection->friendlyName == "") {
4684  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidConnectionSetting] = i18n("Connection name is invalid");
4685  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidConnectionSetting;
4686  return false;
4687  }
4688 
4689  if (connection->ipConfig.valid) {
4690  // Iterate over all addresses
4691  TDENetworkSingleIPConfigurationList::iterator it;
4692  for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
4693  if ((*it).isIPv4()) {
4694  if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP)) {
4695  if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
4696  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv4Setting] = i18n("IPv4 address is invalid");
4697  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv4Setting;
4698  return false;
4699  }
4700  }
4701  }
4702  else if ((*it).isIPv6()) {
4703  if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP)) {
4704  if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
4705  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv6Setting] = i18n("IPv6 address is invalid");
4706  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv6Setting;
4707  return false;
4708  }
4709  }
4710  }
4711  }
4712  }
4713 
4714  TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
4715  if (wiFiConnection) {
4716  if (wiFiConnection->SSID.count() < 1) {
4717  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessSetting] = i18n("No SSID provided");
4718  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessSetting;
4719  return false;
4720  }
4721  if (wiFiConnection->securityRequired) {
4722  if (wiFiConnection->securitySettings.secretsValid) {
4723  if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WEP) || ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && ((wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Open) || (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Shared)))) {
4724  if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Hexadecimal) {
4725  if (wiFiConnection->securitySettings.wepKey0 != "") {
4726  if ((wiFiConnection->securitySettings.wepKey0.length() != 10) && (wiFiConnection->securitySettings.wepKey0.length() != 26)) {
4727  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
4728  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4729  return false;
4730  }
4731  }
4732  if (wiFiConnection->securitySettings.wepKey1 != "") {
4733  if ((wiFiConnection->securitySettings.wepKey1.length() != 10) && (wiFiConnection->securitySettings.wepKey1.length() != 26)) {
4734  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
4735  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4736  return false;
4737  }
4738  }
4739  if (wiFiConnection->securitySettings.wepKey2 != "") {
4740  if ((wiFiConnection->securitySettings.wepKey2.length() != 10) && (wiFiConnection->securitySettings.wepKey2.length() != 26)) {
4741  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
4742  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4743  return false;
4744  }
4745  }
4746  if (wiFiConnection->securitySettings.wepKey3 != "") {
4747  if ((wiFiConnection->securitySettings.wepKey3.length() != 10) && (wiFiConnection->securitySettings.wepKey3.length() != 26)) {
4748  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
4749  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4750  return false;
4751  }
4752  }
4753  if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
4754  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
4755  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4756  return false;
4757  }
4758  }
4759  else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
4760  if (wiFiConnection->securitySettings.wepKey0 != "") {
4761  if ((wiFiConnection->securitySettings.wepKey0.length() != 5) && (wiFiConnection->securitySettings.wepKey0.length() != 13)) {
4762  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
4763  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4764  return false;
4765  }
4766  }
4767  if (wiFiConnection->securitySettings.wepKey1 != "") {
4768  if ((wiFiConnection->securitySettings.wepKey1.length() != 5) && (wiFiConnection->securitySettings.wepKey1.length() != 13)) {
4769  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
4770  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4771  return false;
4772  }
4773  }
4774  if (wiFiConnection->securitySettings.wepKey2 != "") {
4775  if ((wiFiConnection->securitySettings.wepKey2.length() != 5) && (wiFiConnection->securitySettings.wepKey2.length() != 13)) {
4776  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
4777  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4778  return false;
4779  }
4780  }
4781  if (wiFiConnection->securitySettings.wepKey3 != "") {
4782  if ((wiFiConnection->securitySettings.wepKey3.length() != 5) && (wiFiConnection->securitySettings.wepKey3.length() != 13)) {
4783  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
4784  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4785  return false;
4786  }
4787  }
4788  if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
4789  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
4790  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4791  return false;
4792  }
4793  }
4794  else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
4795  if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
4796  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
4797  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4798  return false;
4799  }
4800  }
4801  }
4802  else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::LEAP)) {
4803  if ((wiFiConnection->securitySettings.leapUsername.length() < 1) || (wiFiConnection->securitySettings.leapPassword.length() < 1)) {
4804  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("LEAP username and/or password not provided");
4805  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4806  return false;
4807  }
4808  }
4809  else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAAdHoc) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAInfrastructure) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAEnterprise)) {
4810  if (wiFiConnection->securitySettings.psk.length() == 64) {
4811  // Verify that only hex characters are present in the string
4812  bool ok;
4813  wiFiConnection->securitySettings.psk.toULongLong(&ok, 16);
4814  if (!ok) {
4815  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("Hexadecimal length PSK contains non-hexadecimal characters");
4816  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4817  return false;
4818  }
4819  }
4820  else if ((wiFiConnection->securitySettings.psk.length() < 8) || (wiFiConnection->securitySettings.psk.length() > 63)) {
4821  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No PSK provided");
4822  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4823  return false;
4824  }
4825  }
4826  }
4827  }
4828  }
4829 
4830  return TRUE;
4831 }
4832 
4833 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::initiateConnection(TQString uuid) {
4834  TQT_DBusObjectPath existingConnection;
4835  TQT_DBusError error;
4836  bool ret;
4837  if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
4838  ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
4839  if (ret) {
4840  if (!m_networkDevice) {
4841  d->m_dbusDeviceString = "/";
4842  }
4843  else {
4844  d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
4845  }
4846 #ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
4847  TQT_DBusObjectPath active_connection;
4848  ret = d->m_networkManagerProxy->ActivateConnection(existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), active_connection, error);
4849  if (ret && error.isValid()) {
4850  ret = 0;
4851  PRINT_ERROR((error.name() + ": " + error.message()))
4852  }
4853  return checkConnectionStatus(uuid);
4854 #else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
4855 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
4856  connect(d->m_networkManagerProxy, SIGNAL(ActivateConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
4857  connect(d->m_networkManagerProxy, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
4858 #endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
4859  int asyncCallID;
4860  ret = d->m_networkManagerProxy->ActivateConnectionAsync(asyncCallID, existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), error);
4861  if (ret && error.isValid()) {
4862  ret = 0;
4863  PRINT_ERROR((error.name() + ": " + error.message()))
4864  }
4865 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
4866  if (ret) {
4867  // Wait for the asynchronous call to return...
4868  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
4869  TQTimer nmCallTimeoutTimer;
4870  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
4871  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
4872  if (!nmCallTimeoutTimer.isActive()) {
4873  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
4874  break;
4875  }
4876  tqApp->processEvents();
4877  }
4878  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
4879  if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
4880  PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
4881  d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
4882  }
4883  if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
4884  PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
4885  }
4886  if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
4887  d->nmAddConnectionAsyncResponse.remove(asyncCallID);
4888  }
4889  return checkConnectionStatus(uuid);
4890  }
4891  else {
4892  // Error!
4893  PRINT_ERROR((error.name() + ": " + error.message()))
4894  return checkConnectionStatus(uuid);
4895  }
4896 #else
4897  return checkConnectionStatus(uuid);
4898 #endif
4899 #endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
4900  }
4901  else {
4902  PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
4903  return TDENetworkConnectionStatus::Invalid;
4904  }
4905  }
4906  else {
4907  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4908  return TDENetworkConnectionStatus::Invalid;
4909  }
4910 }
4911 
4912 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::checkConnectionStatus(TQString uuid) {
4913  TQT_DBusObjectPath existingConnection;
4914  TQT_DBusError error;
4915  if (d->m_networkManagerProxy) {
4916  TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
4917  TQT_DBusObjectPathList::iterator it;
4918  for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
4919  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
4920  activeConnection.setConnection(TQT_DBusConnection::systemBus());
4921  if (activeConnection.getUuid(error) == uuid) {
4922  return nmDeviceStateToTDEDeviceState(activeConnection.getState(error));
4923  }
4924  }
4925  PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
4926  return TDENetworkConnectionStatus::Invalid;
4927  }
4928  else {
4929  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4930  return TDENetworkConnectionStatus::Invalid;
4931  }
4932 }
4933 
4934 TQCString TDENetworkConnectionManager_BackendNM::getActiveConnectionPath(TQString uuid) {
4935  TQT_DBusObjectPath existingConnection;
4936  TQT_DBusError error;
4937  if (d->m_networkManagerProxy) {
4938  TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
4939  TQT_DBusObjectPathList::iterator it;
4940  for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
4941  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
4942  activeConnection.setConnection(TQT_DBusConnection::systemBus());
4943  if (activeConnection.getUuid(error) == uuid) {
4944  return (*it);
4945  }
4946  }
4947  PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
4948  return TQT_DBusObjectPath();
4949  }
4950  else {
4951  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4952  return TQT_DBusObjectPath();
4953  }
4954 }
4955 
4956 TQStringList TDENetworkConnectionManager_BackendNM::connectionPhysicalDeviceUUIDs(TQString uuid) {
4957  if (deviceType() == TDENetworkDeviceType::BackendOnly) {
4958  return TQStringList();
4959  }
4960 
4961  TQT_DBusObjectPath existingConnection;
4962  TQT_DBusError error;
4963  if (d->m_networkManagerProxy) {
4964  TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
4965  TQT_DBusObjectPathList::iterator it;
4966  TQStringList ret;
4967  for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
4968  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
4969  activeConnection.setConnection(TQT_DBusConnection::systemBus());
4970  if (activeConnection.getUuid(error) == uuid) {
4971  TQValueList<TQT_DBusObjectPath> deviceList = activeConnection.getDevices(error);
4972  TQT_DBusObjectPathList::iterator it2;
4973  for (it2 = deviceList.begin(); it2 != deviceList.end(); ++it2) {
4974  TQString devUUID = tdeDeviceUUIDForGenericDevice(*it2);
4975  if (devUUID != "") {
4976  ret.append(devUUID);
4977  }
4978  }
4979  }
4980  }
4981  return ret;
4982  }
4983  else {
4984  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4985  return TQStringList();
4986  }
4987 }
4988 
4989 TDENetworkVPNTypeList TDENetworkConnectionManager_BackendNM::availableVPNTypes() {
4990  TDENetworkVPNTypeList ret;
4991 
4992  // Query NetworkManager to verify plugin availability before claiming support for a VPN type
4993  TQDir serviceDir(NM_PLUGIN_SERVICE_DIR, TQString(), TQDir::Name|TQDir::IgnoreCase, TQDir::Files);
4994  TQStringList services = serviceDir.entryList ().grep (".name", true);
4995 
4996  if (services.count () > 0) {
4997  // read in all available Services
4998  for (TQStringList::Iterator i = services.begin (); i != services.end (); ++i) {
4999  TQString service = NM_PLUGIN_SERVICE_DIR + TQString ("/") + *i;
5000  TDEConfig* tdeconfig = new TDEConfig (service, true, true, "config");
5001  tdeconfig->setGroup ("VPN Connection");
5002 
5003  TQString serviceName = tdeconfig->readEntry("name", TQString());
5004  serviceName = serviceName.lower();
5005 
5006  if (serviceName == "openvpn") {
5007  ret.append(TDENetworkVPNType::OpenVPN);
5008  }
5009  if (serviceName == "pptp") {
5010  ret.append(TDENetworkVPNType::PPTP);
5011  }
5012  if (serviceName == "strongswan") {
5013  ret.append(TDENetworkVPNType::StrongSwan);
5014  }
5015  if (serviceName == "vpnc") {
5016  ret.append(TDENetworkVPNType::VPNC);
5017  }
5018 
5019  delete tdeconfig;
5020  }
5021  }
5022 
5023  return ret;
5024 }
5025 
5026 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::deactivateConnection(TQString uuid) {
5027  TQT_DBusObjectPath existingConnection;
5028  TQT_DBusError error;
5029  bool ret;
5030  if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
5031  existingConnection = getActiveConnectionPath(uuid);
5032  if (existingConnection.isValid()) {
5033  if (!m_networkDevice) {
5034  d->m_dbusDeviceString = "/";
5035  }
5036  else {
5037  d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
5038  }
5039 #ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
5040  ret = d->m_networkManagerProxy->DeactivateConnection(existingConnection, error);
5041  if (ret && error.isValid()) {
5042  ret = 0;
5043  PRINT_ERROR((error.name() + ": " + error.message()))
5044  }
5045  return checkConnectionStatus(uuid);
5046 #else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
5047 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
5048  connect(d->m_networkManagerProxy, SIGNAL(DeactivateConnectionAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
5049 #endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
5050  int asyncCallID;
5051  ret = d->m_networkManagerProxy->DeactivateConnectionAsync(asyncCallID, existingConnection, error);
5052  if (ret && error.isValid()) {
5053  ret = 0;
5054  PRINT_ERROR((error.name() + ": " + error.message()))
5055  }
5056 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
5057  if (ret) {
5058  // Wait for the asynchronous call to return...
5059  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
5060  TQTimer nmCallTimeoutTimer;
5061  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
5062  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
5063  if (!nmCallTimeoutTimer.isActive()) {
5064  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
5065  break;
5066  }
5067  tqApp->processEvents();
5068  }
5069  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
5070  return checkConnectionStatus(uuid);
5071  }
5072  else {
5073  // Error!
5074  PRINT_ERROR((error.name() + ": " + error.message()))
5075  return checkConnectionStatus(uuid);
5076  }
5077 #else
5078  return checkConnectionStatus(uuid);
5079 #endif
5080 #endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
5081  }
5082  else {
5083  PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
5084  return TDENetworkConnectionStatus::Invalid;
5085  }
5086  }
5087  else {
5088  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
5089  return TDENetworkConnectionStatus::Invalid;
5090  }
5091 }
5092 
5093 TQStringList TDENetworkConnectionManager_BackendNM::validSettings() {
5094  TQStringList ret;
5095 
5096  ret.append("TDENetworkSingleIPConfiguration::ipAddress");
5097  ret.append("TDENetworkSingleIPConfiguration::networkMask");
5098  ret.append("TDENetworkSingleIPConfiguration::gateway");
5099 
5100  ret.append("TDENetworkSingleRouteConfiguration::ipAddress");
5101  ret.append("TDENetworkSingleRouteConfiguration::networkMask");
5102  ret.append("TDENetworkSingleRouteConfiguration::gateway");
5103 
5104  ret.append("TDENetworkIEEE8021xConfiguration::valid");
5105  ret.append("TDENetworkIEEE8021xConfiguration::allowedValid");
5106  ret.append("TDENetworkIEEE8021xConfiguration::secretsValid");
5107  ret.append("TDENetworkIEEE8021xConfiguration::type");
5108  ret.append("TDENetworkIEEE8021xConfiguration::userName");
5109  ret.append("TDENetworkIEEE8021xConfiguration::anonymousUserName");
5110  ret.append("TDENetworkIEEE8021xConfiguration::pacFileName");
5111  ret.append("TDENetworkIEEE8021xConfiguration::caCertificate");
5112  ret.append("TDENetworkIEEE8021xConfiguration::additionalCAFilesPath");
5113  ret.append("TDENetworkIEEE8021xConfiguration::authServerCertSubjectMatch");
5114  ret.append("TDENetworkIEEE8021xConfiguration::alternateAuthServerCertSubjectMatch");
5115  ret.append("TDENetworkIEEE8021xConfiguration::clientCertificate");
5116  ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPVersion");
5117  ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPLabel");
5118  ret.append("TDENetworkIEEE8021xConfiguration::fastProvisioningFlags");
5119  ret.append("TDENetworkIEEE8021xConfiguration::phase2NonEAPAuthMethod");
5120  ret.append("TDENetworkIEEE8021xConfiguration::phase2EAPAuthMethod");
5121  ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2NonEAPMethods");
5122  ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2EAPMethods");
5123  ret.append("TDENetworkIEEE8021xConfiguration::phase2CaCertificate");
5124  ret.append("TDENetworkIEEE8021xConfiguration::phase2CaFilesPath");
5125  ret.append("TDENetworkIEEE8021xConfiguration::phase2AuthServerCertSubjectMatch");
5126  ret.append("TDENetworkIEEE8021xConfiguration::phase2AlternateAuthServerCertSubjectMatch");
5127  ret.append("TDENetworkIEEE8021xConfiguration::phase2ClientCertificate");
5128  ret.append("TDENetworkIEEE8021xConfiguration::password");
5129  ret.append("TDENetworkIEEE8021xConfiguration::passwordFlags");
5130  ret.append("TDENetworkIEEE8021xConfiguration::binaryPassword");
5131  ret.append("TDENetworkIEEE8021xConfiguration::binaryPasswordFlags");
5132  ret.append("TDENetworkIEEE8021xConfiguration::privateKey");
5133  ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPassword");
5134  ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPasswordFlags");
5135  ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKey");
5136  ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPassword");
5137  ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPasswordFlags");
5138  ret.append("TDENetworkIEEE8021xConfiguration::forceSystemCaCertificates");
5139 
5140  ret.append("TDENetworkPPPConfiguration::valid");
5141  ret.append("TDENetworkPPPConfiguration::requireServerAuthentication");
5142  ret.append("TDENetworkPPPConfiguration::flags");
5143  ret.append("TDENetworkPPPConfiguration::baudRate");
5144  ret.append("TDENetworkPPPConfiguration::mru");
5145  ret.append("TDENetworkPPPConfiguration::mtu");
5146  ret.append("TDENetworkPPPConfiguration::lcpEchoPingInterval");
5147  ret.append("TDENetworkPPPConfiguration::lcpEchoFailureThreshold");
5148 
5149  ret.append("TDENetworkPPPOEConfiguration::valid");
5150  ret.append("TDENetworkPPPOEConfiguration::secretsValid");
5151  ret.append("TDENetworkPPPOEConfiguration::networkServiceProvider");
5152  ret.append("TDENetworkPPPOEConfiguration::username");
5153  ret.append("TDENetworkPPPOEConfiguration::password");
5154  ret.append("TDENetworkPPPOEConfiguration::passwordFlags");
5155 
5156  ret.append("TDENetworkSerialConfiguration::valid");
5157  ret.append("TDENetworkSerialConfiguration::baudRate");
5158  ret.append("TDENetworkSerialConfiguration::byteWidth");
5159  ret.append("TDENetworkSerialConfiguration::parity");
5160  ret.append("TDENetworkSerialConfiguration::stopBits");
5161  ret.append("TDENetworkSerialConfiguration::txDelay");
5162 
5163  ret.append("TDENetworkCDMAConfiguration::valid");
5164  ret.append("TDENetworkCDMAConfiguration::secretsValid");
5165  ret.append("TDENetworkCDMAConfiguration::providerDataNumber");
5166  ret.append("TDENetworkCDMAConfiguration::username");
5167  ret.append("TDENetworkCDMAConfiguration::password");
5168  ret.append("TDENetworkCDMAConfiguration::passwordFlags");
5169 
5170  ret.append("TDENetworkGSMConfiguration::valid");
5171  ret.append("TDENetworkGSMConfiguration::secretsValid");
5172  ret.append("TDENetworkGSMConfiguration::providerDataNumber");
5173  ret.append("TDENetworkGSMConfiguration::username");
5174  ret.append("TDENetworkGSMConfiguration::password");
5175  ret.append("TDENetworkGSMConfiguration::passwordFlags");
5176  ret.append("TDENetworkGSMConfiguration::accessPointName");
5177  ret.append("TDENetworkGSMConfiguration::networkID");
5178  ret.append("TDENetworkGSMConfiguration::networkType");
5179  ret.append("TDENetworkGSMConfiguration::pin");
5180  ret.append("TDENetworkGSMConfiguration::pinFlags");
5181  ret.append("TDENetworkGSMConfiguration::allowedFrequencyBands");
5182  ret.append("TDENetworkGSMConfiguration::allowRoaming");
5183 
5184  ret.append("TDENetworkWiFiSecurityConfiguration::valid");
5185  ret.append("TDENetworkWiFiSecurityConfiguration::secretsValid");
5186  ret.append("TDENetworkWiFiSecurityConfiguration::keyType");
5187  ret.append("TDENetworkWiFiSecurityConfiguration::authType");
5188  ret.append("TDENetworkWiFiSecurityConfiguration::wpaVersion");
5189  ret.append("TDENetworkWiFiSecurityConfiguration::cipher");
5190  ret.append("TDENetworkWiFiSecurityConfiguration::wepKey0");
5191  ret.append("TDENetworkWiFiSecurityConfiguration::wepKey1");
5192  ret.append("TDENetworkWiFiSecurityConfiguration::wepKey2");
5193  ret.append("TDENetworkWiFiSecurityConfiguration::wepKey3");
5194  ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyFlags");
5195  ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyIndex");
5196  ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyType");
5197  ret.append("TDENetworkWiFiSecurityConfiguration::allowedPairWiseCiphers");
5198  ret.append("TDENetworkWiFiSecurityConfiguration::allowedGroupWiseCiphers");
5199  ret.append("TDENetworkWiFiSecurityConfiguration::psk");
5200  ret.append("TDENetworkWiFiSecurityConfiguration::pskFlags");
5201  ret.append("TDENetworkWiFiSecurityConfiguration::leapUsername");
5202  ret.append("TDENetworkWiFiSecurityConfiguration::leapPassword");
5203  ret.append("TDENetworkWiFiSecurityConfiguration::leapPasswordFlags");
5204 
5205  ret.append("TDENetworkIPConfiguration::valid");
5206  ret.append("TDENetworkIPConfiguration::connectionFlags");
5207  ret.append("TDENetworkIPConfiguration::ipConfigurations");
5208  ret.append("TDENetworkIPConfiguration::routeConfigurations");
5209  ret.append("TDENetworkIPConfiguration::broadcast");
5210  ret.append("TDENetworkIPConfiguration::destination");
5211  ret.append("TDENetworkIPConfiguration::resolvers");
5212  ret.append("TDENetworkIPConfiguration::searchDomains");
5213  ret.append("TDENetworkIPConfiguration::dhcpClientIdentifier");
5214 
5215  ret.append("TDENetworkConnection::UUID");
5216  ret.append("TDENetworkConnection::friendlyName");
5217  ret.append("TDENetworkConnection::ipConfig");
5218  ret.append("TDENetworkConnection::lockedHWAddress");
5219  ret.append("TDENetworkConnection::manualHWAddress");
5220  ret.append("TDENetworkConnection::readOnly");
5221  ret.append("TDENetworkConnection::autoConnect");
5222  ret.append("TDENetworkConnection::fullDuplex");
5223  ret.append("TDENetworkConnection::requireIPV4");
5224  ret.append("TDENetworkConnection::requireIPV6");
5225  ret.append("TDENetworkConnection::mtu");
5226  ret.append("TDENetworkConnection::eapConfig");
5227  ret.append("TDENetworkConnection::pppConfig");
5228  ret.append("TDENetworkConnection::pppoeConfig");
5229  ret.append("TDENetworkConnection::serialConfig");
5230  ret.append("TDENetworkConnection::authorizedUsers");
5231  ret.append("TDENetworkConnection::masterConnectionUUID");
5232  ret.append("TDENetworkConnection::slaveType");
5233  ret.append("TDENetworkConnection::lastKnownConnection");
5234 
5235  ret.append("TDEWiFiConnection::SSID");
5236  ret.append("TDEWiFiConnection::operatingMode");
5237  ret.append("TDEWiFiConnection::bandRestriction");
5238  ret.append("TDEWiFiConnection::channelRestriction");
5239  ret.append("TDEWiFiConnection::bitRateRestriction");
5240  ret.append("TDEWiFiConnection::powerRestriction");
5241  ret.append("TDEWiFiConnection::accessPointRestriction");
5242  ret.append("TDEWiFiConnection::blacklistedBSSIDs");
5243  ret.append("TDEWiFiConnection::heardBSSIDs");
5244  ret.append("TDEWiFiConnection::isHiddenNetwork");
5245  ret.append("TDEWiFiConnection::securityRequired");
5246  ret.append("TDEWiFiConnection::securitySettings");
5247 
5248  ret.append("TDEWiredInfinibandConnection::transportMode");
5249 
5250  ret.append("TDEVPNConnection::vpnPluginID");
5251  ret.append("TDEVPNConnection::lockedUserName");
5252  ret.append("TDEVPNConnection::pluginData");
5253  ret.append("TDEVPNConnection::secretsValid");
5254  ret.append("TDEVPNConnection::pluginSecrets");
5255 
5256  ret.append("TDEWiMaxConnection::networkServiceProvider");
5257 
5258  ret.append("TDEVLANConnection::kernelName");
5259  ret.append("TDEVLANConnection::parentConnectionUUID");
5260  ret.append("TDEVLANConnection::vlanID");
5261  ret.append("TDEVLANConnection::vlanFlags");
5262  ret.append("TDEVLANConnection::ingressPriorityMap");
5263  ret.append("TDEVLANConnection::egressPriorityMap");
5264 
5265  ret.append("TDEOLPCMeshConnection::SSID");
5266  ret.append("TDEOLPCMeshConnection::channel");
5267  ret.append("TDEOLPCMeshConnection::anycastDHCPHWAddress");
5268 
5269  ret.append("TDEBluetoothConnection::type");
5270 
5271  ret.append("TDEModemConnection::type");
5272  ret.append("TDEModemConnection::cdmaConfig");
5273  ret.append("TDEModemConnection::gsmConfig");
5274 
5275  ret.append("TDEWiredInfinibandConnection::transportMode");
5276 
5277  return ret;
5278 }
5279 
5280 TDENetworkWiFiAPInfo* TDENetworkConnectionManager_BackendNM::getAccessPointDetails(TQString dbusPath) {
5281  if (dbusPath == "") {
5282  return NULL;
5283  }
5284 
5285  TDENetworkWiFiAPInfo* apInfo = new TDENetworkWiFiAPInfo;
5286  TQT_DBusError error;
5287  unsigned int index;
5288  DBus::AccessPointProxy accessPoint(NM_DBUS_SERVICE, dbusPath);
5289  accessPoint.setConnection(TQT_DBusConnection::systemBus());
5290 
5291  TQValueList<TQ_UINT8> nmSSID = accessPoint.getSsid(error);
5292  if (error.isValid()) {
5293  delete apInfo;
5294  return NULL;
5295  }
5296  TQValueList<TQ_UINT8>::iterator it;
5297  index = 0;
5298  for (it = nmSSID.begin(); it != nmSSID.end(); ++it) {
5299  apInfo->SSID.resize(index+1);
5300  apInfo->SSID[index] = (*it);
5301  index++;
5302  }
5303 
5304  apInfo->wpaFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getWpaFlags(error));
5305  apInfo->rsnFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getRsnFlags(error));
5306  apInfo->frequency = accessPoint.getFrequency(error);
5307  apInfo->BSSID.fromString(accessPoint.getHwAddress(error));
5308  apInfo->maxBitrate = accessPoint.getMaxBitrate(error);
5309  apInfo->signalQuality = (accessPoint.getStrength(error)/100.0);
5310 
5311  apInfo->valid = true;
5312 
5313  return apInfo;
5314 }
5315 
5316 TDENetworkHWNeighborList* TDENetworkConnectionManager_BackendNM::siteSurvey() {
5317  TQT_DBusError error;
5318  bool ret;
5319 
5320  TDENetworkDeviceType::TDENetworkDeviceType myDeviceType = deviceType();
5321  d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
5322  clearTDENetworkHWNeighborList();
5323 
5324  if (myDeviceType == TDENetworkDeviceType::WiFi) {
5325  DBus::WiFiDeviceProxy wiFiDevice(NM_DBUS_SERVICE, d->m_dbusDeviceString);
5326  wiFiDevice.setConnection(TQT_DBusConnection::systemBus());
5327  // FIXME
5328  // Should call wiFiDevice.RequestScanAsync first to rescan all access points
5329  TQT_DBusObjectPathList accessPoints;
5330  ret = wiFiDevice.GetAccessPoints(accessPoints, error);
5331  if (ret) {
5332  TQT_DBusObjectPathList::iterator it;
5333  for (it = accessPoints.begin(); it != accessPoints.end(); ++it) {
5334  TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(TQString(*it));
5335  if (apInfo) {
5336  m_hwNeighborList->append(apInfo);
5337  // Ensure that this AP is monitored for changes
5338  d->internalProcessWiFiAccessPointAdded(*it);
5339  }
5340  }
5341  }
5342  }
5343 
5344  return m_hwNeighborList;
5345 }
5346 
5347 bool TDENetworkConnectionManager_BackendNM::networkingEnabled() {
5348  if (d->m_networkManagerProxy) {
5349  bool ret;
5350  TQT_DBusError error;
5351  ret = d->m_networkManagerProxy->getNetworkingEnabled(error);
5352  if (error.isValid()) {
5353  // Error!
5354  PRINT_ERROR((error.name() + ": " + error.message()))
5355  return FALSE;
5356  }
5357  else {
5358  return ret;
5359  }
5360  }
5361  else {
5362  return FALSE;
5363  }
5364 }
5365 
5366 bool TDENetworkConnectionManager_BackendNM::wiFiHardwareEnabled() {
5367  if (d->m_networkManagerProxy) {
5368  bool ret;
5369  TQT_DBusError error;
5370  ret = d->m_networkManagerProxy->getWirelessHardwareEnabled(error);
5371  if (error.isValid()) {
5372  // Error!
5373  PRINT_ERROR((error.name() + ": " + error.message()))
5374  return FALSE;
5375  }
5376  else {
5377  return ret;
5378  }
5379  }
5380  else {
5381  return FALSE;
5382  }
5383 }
5384 
5385 bool TDENetworkConnectionManager_BackendNM::enableNetworking(bool enable) {
5386  // FIXME
5387  // Yes, this abuses the Sleep command
5388  // Is there a better way to do it?
5389  if (d->m_networkManagerProxy) {
5390  int asynccallid;
5391  TQT_DBusError error;
5392  d->m_networkManagerProxy->SleepAsync(asynccallid, !enable, error);
5393  if (error.isValid()) {
5394  // Error!
5395  PRINT_ERROR((error.name() + ": " + error.message()))
5396  return FALSE;
5397  }
5398  else {
5399  // FIXME
5400  // Wait for async reply before returning...
5401  return TRUE;
5402  }
5403  }
5404  else {
5405  return FALSE;
5406  }
5407 }
5408 
5409 bool TDENetworkConnectionManager_BackendNM::enableWiFi(bool enable) {
5410  if (d->m_networkManagerProxy) {
5411  TQT_DBusError error;
5412  d->m_networkManagerProxy->setWirelessEnabled(enable, error);
5413  if (error.isValid()) {
5414  // Error!
5415  PRINT_ERROR((error.name() + ": " + error.message()))
5416  return FALSE;
5417  }
5418  else {
5419  return TRUE;
5420  }
5421  }
5422  else {
5423  return FALSE;
5424  }
5425 }
5426 
5427 bool TDENetworkConnectionManager_BackendNM::wiFiEnabled() {
5428  if (d->m_networkManagerProxy) {
5429  bool ret;
5430  TQT_DBusError error;
5431  ret = d->m_networkManagerProxy->getWirelessEnabled(error);
5432  if (error.isValid()) {
5433  // Error!
5434  PRINT_ERROR((error.name() + ": " + error.message()))
5435  return FALSE;
5436  }
5437  else {
5438  return ret;
5439  }
5440  }
5441  else {
5442  return FALSE;
5443  }
5444 }
5445 
5446 TQStringList TDENetworkConnectionManager_BackendNM::defaultNetworkDevices() {
5447  // Cycle through all available connections and see which one is default, then find all devices for that connection...
5448  TQStringList ret;
5449 
5450  TQT_DBusObjectPath existingConnection;
5451  TQT_DBusError error;
5452  if (d->m_networkManagerProxy) {
5453  TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
5454  TQT_DBusObjectPathList::iterator it;
5455  for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
5456  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
5457  activeConnection.setConnection(TQT_DBusConnection::systemBus());
5458  if (activeConnection.getDefault(error)) {
5459  // This is the default ipv4 connection
5460  TQString uuid = activeConnection.getUuid(error);
5461  TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
5462  for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
5463  ret.append(*it);
5464  }
5465  }
5466  else if (activeConnection.getDefault6(error)) {
5467  // This is the default ipv6 connection
5468  TQString uuid = activeConnection.getUuid(error);
5469  TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
5470  for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
5471  ret.append(*it);
5472  }
5473  }
5474  }
5475  return ret;
5476  }
5477  else {
5478  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
5479  return TQStringList();
5480  }
5481 }
5482 
5483 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) {
5484  // Set up global signal handler
5485  m_dbusSignalConnection = new TQT_DBusConnection(TQT_DBusConnection::systemBus());
5486  m_dbusSignalReceiver = new TDENetworkConnectionManager_BackendNM_DBusSignalReceiver(this);
5487  m_dbusSignalConnection->connect(m_dbusSignalReceiver, TQT_SLOT(dbusSignal(const TQT_DBusMessage&)));
5488 }
5489 
5490 TDENetworkConnectionManager_BackendNMPrivate::~TDENetworkConnectionManager_BackendNMPrivate() {
5491  // Destroy global signal handler
5492  if (m_dbusSignalConnection) delete m_dbusSignalConnection;
5493  if (m_dbusSignalReceiver) delete m_dbusSignalReceiver;
5494 
5495  // Destroy proxy objects
5496  TQMap<TQString, DBus::AccessPointProxy*>::iterator it;
5497  for (it = m_accessPointProxyList.begin(); it != m_accessPointProxyList.end(); ++it) {
5498  DBus::AccessPointProxy *apProxy = it.data();
5499  if (apProxy) {
5500  delete apProxy;
5501  }
5502  }
5503  m_accessPointProxyList.clear();
5504 }
5505 
5506 #include "network-manager.moc"
5507 #include "network-manager_p.moc"
TDEConfig
Access KDE Configuration entries.
Definition: tdeconfig.h:43
TDENetworkGlobalManagerFlags
Definition: tdenetworkconnections.h:233
TDENetworkConnectionType
Definition: tdenetworkconnections.h:84
TDEStdAccel::key
int key(StdAccel id)
Definition: tdestdaccel.cpp:383
TDEConfigBase::setGroup
void setGroup(const TQString &group)
Specifies the group in which keys will be read and written.
Definition: tdeconfigbase.cpp:79
TDENetworkDeviceType
Definition: tdenetworkconnections.h:66
TDEGlobal::hardwareDevices
static TDEHardwareDevices * hardwareDevices()
Returns a TDEHardwareDevices object.
TDEConfigBase::readEntry
TQString readEntry(const TQString &pKey, const TQString &aDefault=TQString::null) const
Reads the value of an entry specified by pKey in the current group.
Definition: tdeconfigbase.cpp:221
TDENetworkIPConfigurationFlags
Definition: tdenetworkconnections.h:476

tdecore

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

tdecore

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