• 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 TQString::null;
1162  }
1163  else {
1164  // Error!
1165  PRINT_ERROR((error.name() + ": " + error.message()))
1166  return TQString::null;
1167  }
1168  }
1169  else {
1170  return TQString::null;
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.isEmpty()) {
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 
1573  // Query NM for the device type
1574  TQT_DBusError error;
1575  d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
1576  if (!d->m_dbusDeviceString.isEmpty()) {
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 empty DBUS device string"))
1592  return TDENetworkDeviceType::Other;
1593  }
1594 }
1595 
1596 TDENetworkConnectionType::TDENetworkConnectionType TDENetworkConnectionManager_BackendNM::connectionType(TQString dbusPath) {
1597  TDENetworkConnectionType::TDENetworkConnectionType connType = TDENetworkConnectionType::Other;
1598  TQ_UINT32 ret;
1599  TQT_DBusError error;
1600 
1601 #ifndef USE_ASYNC_DBUS_CALLS
1602  // Obtain connection settings from the path specified
1603  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
1604  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
1605  TQT_DBusTQStringDataMap connectionSettingsMap;
1606  ret = connectionSettings.GetSettings(connectionSettingsMap, error);
1607  if (ret && error.isValid()) {
1608  ret = 0;
1609  PRINT_ERROR((error.name() + ": " + error.message()))
1610  }
1611  if (ret) {
1612 #else // USE_ASYNC_DBUS_CALLS
1613  // Obtain connection settings from the path specified
1614  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, dbusPath);
1615  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
1616  connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
1617  int asyncCallID;
1618  ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
1619  if (ret && error.isValid()) {
1620  ret = 0;
1621  PRINT_ERROR((error.name() + ": " + error.message()))
1622  }
1623  if (ret) {
1624  // Wait for the asynchronous call to return...
1625  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
1626  TQTimer nmCallTimeoutTimer;
1627  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
1628  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
1629  tqApp->processEvents();
1630  if (!nmCallTimeoutTimer.isActive()) {
1631  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
1632  break;
1633  }
1634  }
1635  TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
1636  if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
1637  PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
1638  d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
1639  }
1640  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
1641  if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
1642  d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
1643  }
1644 #endif // USE_ASYNC_DBUS_CALLS
1645 
1646  // Parse settings to find connection type
1647  TQT_DBusTQStringDataMap::const_iterator it2;
1648  for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
1649  TQString outerKeyValue = it2.key();
1650  TQT_DBusData dataValue = it2.data();
1651 
1652  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
1653  TQT_DBusTQStringDataMap::const_iterator it3;
1654  for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
1655  TQString keyValue = it3.key();
1656  TQT_DBusData dataValue = it3.data();
1657  if (dataValue.type() == TQT_DBusData::Variant) {
1658  TQT_DBusVariant dataValueVariant = dataValue.toVariant();
1659  TQT_DBusData dataValue2 = dataValueVariant.value;
1660  if (dataValue2.type() != TQT_DBusData::Variant) {
1661  if (outerKeyValue.lower() == "connection") {
1662  if (keyValue.lower() == "type") {
1663  connType = nmConnectionTypeToTDEConnectionType(dataValue2.toString());
1664  }
1665  }
1666  }
1667  }
1668  }
1669  }
1670  }
1671 
1672  return connType;
1673 }
1674 
1675 TQString TDENetworkConnectionManager_BackendNM::backendName() {
1676  return i18n("NetworkManager");
1677 }
1678 
1679 TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags TDENetworkConnectionManager_BackendNM::backendStatus() {
1680  if (d->m_networkManagerProxy) {
1681  TQ_UINT32 ret;
1682  TQT_DBusError error;
1683  ret = d->m_networkManagerProxy->getState(error);
1684  if (error.isValid()) {
1685  // Error!
1686  PRINT_ERROR((error.name() + ": " + error.message()))
1687  return TDENetworkGlobalManagerFlags::BackendUnavailable;
1688  }
1689  else {
1690  TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags globalFlags = nmGlobalStateToTDEGlobalState(ret);
1691  TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags vpnFlags = TDENetworkGlobalManagerFlags::Unknown;
1692  if (d->m_vpnProxy) {
1693  ret = d->m_vpnProxy->getState(error);
1694  if (error.isValid()) {
1695  // Error!
1696  bool print_error = true;
1697  if (error.name() == "org.freedesktop.DBus.Error.ServiceUnknown") {
1698  if (d->vpn_service_error_notified) {
1699  print_error = false;
1700  }
1701  else {
1702  d->vpn_service_error_notified = true;
1703  }
1704  }
1705  if (print_error) {
1706  PRINT_ERROR(TQString("Attempting to access the network-manager VPN service returned: %1").arg(error.name() + ": " + error.message()))
1707  }
1708  vpnFlags = TDENetworkGlobalManagerFlags::VPNUnknown;
1709  }
1710  else {
1711  vpnFlags = nmVPNStateToTDEGlobalState(ret);
1712  }
1713  }
1714  return globalFlags | vpnFlags;
1715  }
1716  }
1717  else {
1718  return TDENetworkGlobalManagerFlags::BackendUnavailable;
1719  }
1720 }
1721 
1722 TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceInformation() {
1723  TQT_DBusError error;
1724  TDENetworkDeviceInformation ret;
1725 
1726  if (d->m_networkDeviceProxy) {
1727  ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
1728  ret.UUID = d->m_networkDeviceProxy->getUdi(error);
1729  ret.backendDriver = d->m_networkDeviceProxy->getDriver(error);
1730  ret.backendDriverVersion = d->m_networkDeviceProxy->getDriverVersion(error);
1731  ret.firmwareVersion = d->m_networkDeviceProxy->getFirmwareVersion(error);
1732  ret.capabilityFlags = nmCapabilityFlagsToTDECapabilityFlags(d->m_networkDeviceProxy->getCapabilities(error));
1733  // ipConfiguration is not filled in, as the TDE HW library provides complementary functionality and is more reliable/easier to use and maintain
1734  ret.managed = d->m_networkDeviceProxy->getManaged(error);
1735  ret.autoConnect = d->m_networkDeviceProxy->getAutoconnect(error);
1736  ret.firmwareMissing = d->m_networkDeviceProxy->getFirmwareMissing(error);
1737  ret.deviceType = nmDeviceTypeToTDEDeviceType(d->m_networkDeviceProxy->getDeviceType(error));
1738  if (error.isValid()) {
1739  // Error!
1740  bool print_error = true;
1741  if (error.name() == "org.freedesktop.DBus.Error.AccessDenied") {
1742  if (error.message().contains("org.freedesktop.NetworkManager.Device")) {
1743  // Unable to determine if device allows autoconnect
1744  // Assume true!
1745  ret.autoConnect = true;
1746  if (d->device_autoconnect_error_notified) {
1747  print_error = false;
1748  }
1749  else {
1750  d->device_autoconnect_error_notified = true;
1751  }
1752  }
1753  }
1754  if (print_error) {
1755  PRINT_ERROR((error.name() + ": " + error.message()))
1756  }
1757 
1758  // Reset error object to avoid spurious error messages on the command line
1759  error = TQT_DBusError();
1760  }
1761 
1762  // Populate wiFiInfo
1763  if ((deviceType() == TDENetworkDeviceType::WiFi) && (d->m_wiFiDeviceProxy)) {
1764  ret.wiFiInfo.valid = true;
1765  ret.wiFiInfo.hwAddress.fromString(d->m_wiFiDeviceProxy->getHwAddress(error));
1766  ret.wiFiInfo.permanentHWAddress.fromString(d->m_wiFiDeviceProxy->getPermHwAddress(error));
1767  ret.wiFiInfo.operatingMode = nmWiFiModeToTDEWiFiMode(d->m_wiFiDeviceProxy->getMode(error));
1768  ret.wiFiInfo.bitrate = d->m_wiFiDeviceProxy->getBitrate(error);
1769  TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(d->m_wiFiDeviceProxy->getActiveAccessPoint(error));
1770  if (error.isValid()) {
1771  PRINT_ERROR((error.name() + ": " + error.message()))
1772 
1773  // Reset error object to avoid spurious error messages on the command line
1774  error = TQT_DBusError();
1775  }
1776  if (apInfo) {
1777  ret.wiFiInfo.activeAccessPointBSSID = apInfo->BSSID;
1778  TDENetworkWiFiAPInfo* neighborListAPInfo = findAccessPointByBSSID(ret.wiFiInfo.activeAccessPointBSSID);
1779  if (neighborListAPInfo) {
1780  *neighborListAPInfo = *apInfo;
1781  }
1782  delete apInfo;
1783  }
1784  else {
1785  ret.wiFiInfo.activeAccessPointBSSID = TDEMACAddress();
1786  }
1787  ret.wiFiInfo.wirelessFlags = tdeWiFiFlagsToNMWiFiFlags(d->m_wiFiDeviceProxy->getWirelessCapabilities(error));
1788  }
1789  else {
1790  ret.wiFiInfo.valid = false;
1791  }
1792 
1793  // Get active connection UUID
1794  TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
1795  if (!error.isValid()) {
1796  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
1797  activeConnection.setConnection(TQT_DBusConnection::systemBus());
1798  ret.activeConnectionUUID = activeConnection.getUuid(error);
1799  if (error.isValid()) {
1800  ret.activeConnectionUUID = TQString::null;
1801  }
1802  }
1803 
1804  ret.valid = true;
1805  }
1806 
1807  return ret;
1808 }
1809 
1810 TDENetworkDeviceInformation TDENetworkConnectionManager_BackendNM::deviceStatus() {
1811  TQT_DBusError error;
1812  TDENetworkDeviceInformation ret;
1813 
1814  if (d->m_networkDeviceProxy) {
1815  ret.statusFlags = nmDeviceStateToTDEDeviceState(d->m_networkDeviceProxy->getState(error));
1816  ret.UUID = d->m_networkDeviceProxy->getUdi(error);
1817 
1818  // Get active connection UUID
1819  TQT_DBusObjectPath connectionPath = d->m_networkDeviceProxy->getActiveConnection(error);
1820  if (!error.isValid()) {
1821  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, connectionPath);
1822  activeConnection.setConnection(TQT_DBusConnection::systemBus());
1823  ret.activeConnectionUUID = activeConnection.getUuid(error);
1824  if (error.isValid()) {
1825  ret.activeConnectionUUID = TQString::null;
1826  }
1827  }
1828 
1829  ret.valid = true;
1830  }
1831 
1832  return ret;
1833 }
1834 
1835 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncReply(int asyncCallId, const TQT_DBusDataMap<TQString>& settings) {
1836  nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
1837  nmConnectionSettingsAsyncSettingsResponse[asyncCallId] = settings;
1838 }
1839 
1840 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncReply(int asyncCallId) {
1841  nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
1842 }
1843 
1844 void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncReply(int asyncCallId, const TQT_DBusObjectPath& path) {
1845  nmConnectionSettingsAsyncCallWaiting[asyncCallId] = false;
1846  nmAddConnectionAsyncResponse[asyncCallId] = path;
1847 }
1848 
1849 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsAsyncError(int asyncCallId, const TQT_DBusError error) {
1850  nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallId] = error;
1851 }
1852 
1853 void TDENetworkConnectionManager_BackendNMPrivate::processConnectionSettingsUpdateAsyncError(int asyncCallId, const TQT_DBusError error) {
1854  nmConnectionSettingsUpdateAsyncSettingsErrorResponse[asyncCallId] = error;
1855 }
1856 
1857 void TDENetworkConnectionManager_BackendNMPrivate::processAddConnectionAsyncError(int asyncCallId, const TQT_DBusError error) {
1858  nmAddConnectionAsyncErrorResponse[asyncCallId] = error;
1859 }
1860 
1861 void TDENetworkConnectionManager_BackendNM::loadConnectionInformation() {
1862  if (d->nonReentrantCallActive) return;
1863 
1864  d->nonReentrantCallActive = true;
1865 
1866  TDEMACAddress deviceMACAddress;
1867  deviceMACAddress.fromString(this->deviceMACAddress());
1868 
1869  if (d->m_networkManagerSettings) {
1870  clearTDENetworkConnectionList();
1871  TQT_DBusObjectPathList connections;
1872  TQT_DBusError error;
1873  bool ret;
1874  int state;
1875  ret = d->m_networkManagerSettings->ListConnections(connections, error);
1876  if (ret) {
1877  TQT_DBusObjectPathList::iterator it;
1878  for (it = connections.begin(); it != connections.end(); ++it) {
1879  TDENetworkConnection* connection;
1880  TDEWiredEthernetConnection* ethernetConnection = NULL;
1881  TDEWiredInfinibandConnection* infinibandConnection = NULL;
1882  TDEWiFiConnection* wiFiConnection = NULL;
1883  TDEVPNConnection* vpnConnection = NULL;
1884  TDEWiMaxConnection* wiMaxConnection = NULL;
1885  TDEVLANConnection* vlanConnection = NULL;
1886  TDEOLPCMeshConnection* olpcMeshConnection = NULL;
1887  TDEBluetoothConnection* bluetoothConnection = NULL;
1888  TDEModemConnection* modemConnection = NULL;
1889  TDENetworkConnectionType::TDENetworkConnectionType connType = connectionType((*it));
1890  if (connType == TDENetworkConnectionType::WiredEthernet) {
1891  connection = ethernetConnection = new TDEWiredEthernetConnection;
1892  }
1893  else if (connType == TDENetworkConnectionType::Infiniband) {
1894  connection = infinibandConnection = new TDEWiredInfinibandConnection;
1895  }
1896  else if (connType == TDENetworkConnectionType::WiFi) {
1897  connection = wiFiConnection = new TDEWiFiConnection;
1898  }
1899  else if (connType == TDENetworkConnectionType::VPN) {
1900  connection = vpnConnection = new TDEVPNConnection;
1901  }
1902  else if (connType == TDENetworkConnectionType::WiMax) {
1903  connection = wiMaxConnection = new TDEWiMaxConnection;
1904  }
1905  else if (connType == TDENetworkConnectionType::VLAN) {
1906  connection = vlanConnection = new TDEVLANConnection;
1907  }
1908  else if (connType == TDENetworkConnectionType::OLPCMesh) {
1909  connection = olpcMeshConnection = new TDEOLPCMeshConnection;
1910  }
1911  else if (connType == TDENetworkConnectionType::Bluetooth) {
1912  connection = bluetoothConnection = new TDEBluetoothConnection;
1913  }
1914  else if (connType == TDENetworkConnectionType::Modem) {
1915  connection = modemConnection = new TDEModemConnection;
1916  }
1917  else {
1918  connection = new TDENetworkConnection;
1919  }
1920  // Set up defaults
1921  connection->ipConfig.connectionFlags = TDENetworkIPConfigurationFlags::IPV4DHCPIP | \
1922  TDENetworkIPConfigurationFlags::IPV4DHCPDNS | \
1923  TDENetworkIPConfigurationFlags::IPV4DHCPRoutes | \
1924  TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute | \
1925  TDENetworkIPConfigurationFlags::IPV6DHCPIP | \
1926  TDENetworkIPConfigurationFlags::IPV6DHCPDNS | \
1927  TDENetworkIPConfigurationFlags::IPV6DHCPRoutes | \
1928  TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
1929  // Set up NM-specific defaults
1930  // Keep in sync with latest NM default settings!
1931  // NM 0.9 setting descriptions and default values are available at:
1932  // http://projects.gnome.org/NetworkManager/developers/api/09/ref-settings.html
1933  connection->autoConnect = true;
1934 
1935  if (wiFiConnection) {
1936  wiFiConnection->securitySettings.authType = TDENetworkWiFiAuthType::Open;
1937  }
1938 
1939 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
1940  printf("[network-manager comm debug] %s\n", (*it).data()); fflush(stdout);
1941 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
1942 
1943 #ifndef USE_ASYNC_DBUS_CALLS
1944  // Obtain connection settings from the path specified
1945  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
1946  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
1947  TQT_DBusTQStringDataMap connectionSettingsMap;
1948  ret = connectionSettings.GetSettings(connectionSettingsMap, error);
1949  if (ret && error.isValid()) {
1950  ret = 0;
1951  PRINT_ERROR((error.name() + ": " + error.message()))
1952  }
1953  if (ret) {
1954 #else // USE_ASYNC_DBUS_CALLS
1955  // Obtain connection settings from the path specified
1956  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, (*it));
1957  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
1958  connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
1959  connect(&connectionSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processConnectionSettingsAsyncError(int, const TQT_DBusError)));
1960  int asyncCallID;
1961  ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
1962  if (ret && error.isValid()) {
1963  ret = 0;
1964  PRINT_ERROR((error.name() + ": " + error.message()))
1965  }
1966  if (ret) {
1967  // Wait for the asynchronous call to return...
1968  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
1969  TQTimer nmCallTimeoutTimer;
1970  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
1971  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
1972  tqApp->processEvents();
1973  if (!nmCallTimeoutTimer.isActive()) {
1974  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
1975  break;
1976  }
1977  }
1978  TQT_DBusTQStringDataMap connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
1979  if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
1980  PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
1981  d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
1982  }
1983  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
1984  if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
1985  d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
1986  }
1987 #endif // USE_ASYNC_DBUS_CALLS
1988 
1989 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
1990  printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
1991  printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
1992 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
1993 
1994  // Parse settings
1995  TQT_DBusTQStringDataMap::const_iterator it2;
1996  for (it2 = connectionSettingsMap.begin(); it2 != connectionSettingsMap.end(); ++it2) {
1997  TQString outerKeyValue = it2.key();
1998  TQT_DBusData dataValue = it2.data();
1999 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2000  printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
2001 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2002  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
2003  TQT_DBusTQStringDataMap::const_iterator it3;
2004  for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
2005  TQString keyValue = it3.key();
2006  TQT_DBusData dataValue = it3.data();
2007  if (dataValue.type() != TQT_DBusData::Variant) {
2008 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2009  printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
2010 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2011  // No NM settings are known which use this style
2012  }
2013  else {
2014  TQT_DBusVariant dataValueVariant = dataValue.toVariant();
2015  TQT_DBusData dataValue2 = dataValueVariant.value;
2016  if (dataValue2.type() != TQT_DBusData::Variant) {
2017 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2018  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);
2019 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
2020  // Most NM settings use this style
2021  if (outerKeyValue.lower() == "connection") {
2022  if (keyValue.lower() == "id") {
2023  connection->friendlyName = dataValue2.toString();
2024  }
2025  else if (keyValue.lower() == "uuid") {
2026  connection->UUID = dataValue2.toString().lower();
2027  }
2028  else if (keyValue.lower() == "permissions") {
2029  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2030  TQT_DBusDataValueList::const_iterator it4;
2031  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2032  TQT_DBusData innerDataValue = *it4;
2033  TQString authString = innerDataValue.toString();
2034  TQStringList pieces = TQStringList::split(":", authString);
2035  if (pieces[0].lower() == "user") {
2036  connection->authorizedUsers.append(pieces[1]);
2037  }
2038  }
2039  }
2040  else if (keyValue.lower() == "autoconnect") {
2041  connection->autoConnect = dataValue2.toBool();
2042  }
2043  else if (keyValue.lower() == "read-only") {
2044  connection->readOnly = dataValue2.toBool();
2045  }
2046  else if (keyValue.lower() == "master") {
2047  connection->masterConnectionUUID = dataValue2.toString().lower();
2048  }
2049  else if (keyValue.lower() == "slave-type") {
2050  connection->slaveType = nmSlaveTypeToTDESlaveType(dataValue2.toString());
2051  }
2052  else if (keyValue.lower() == "timestamp") {
2053  connection->lastKnownConnection.setTime_t(dataValue2.toUInt64());
2054  }
2055  }
2056  else if (outerKeyValue.lower() == "802-1x") {
2057  if (keyValue.lower() == "eap") {
2058  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2059  TQT_DBusDataValueList::const_iterator it4;
2060  state = 0;
2061  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2062  TQT_DBusData innerDataValue = *it4;
2063  if (state == 0) {
2064  // EAP type
2065  connection->eapConfig.type = nmEAPTypeToTDEEAPType(innerDataValue.toString());
2066  }
2067  state++;
2068  }
2069  }
2070  else if (keyValue.lower() == "identity") {
2071  connection->eapConfig.userName = dataValue2.toString();
2072  }
2073  else if (keyValue.lower() == "anonymous-identity") {
2074  connection->eapConfig.anonymousUserName = dataValue2.toString();
2075  }
2076  else if (keyValue.lower() == "pac-file") {
2077  connection->eapConfig.pacFileName = dataValue2.toString();
2078  }
2079  else if (keyValue.lower() == "ca-cert") {
2080  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2081  TQT_DBusDataValueList::const_iterator it4;
2082  int count=0;
2083  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2084  TQT_DBusData innerDataValue = *it4;
2085  count++;
2086  connection->eapConfig.caCertificate.resize(count+1);
2087  connection->eapConfig.caCertificate[count] = innerDataValue.toByte();
2088  }
2089  }
2090  else if (keyValue.lower() == "ca-path") {
2091  connection->eapConfig.additionalCAFilesPath = dataValue2.toString();
2092  }
2093  else if (keyValue.lower() == "subject-match") {
2094  connection->eapConfig.authServerCertSubjectMatch = dataValue2.toString();
2095  }
2096  else if (keyValue.lower() == "altsubject-matches") {
2097  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2098  TQT_DBusDataValueList::const_iterator it4;
2099  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2100  TQT_DBusData innerDataValue = *it4;
2101  connection->eapConfig.alternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
2102  }
2103  }
2104  else if (keyValue.lower() == "client-cert") {
2105  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2106  TQT_DBusDataValueList::const_iterator it4;
2107  int count=0;
2108  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2109  TQT_DBusData innerDataValue = *it4;
2110  count++;
2111  connection->eapConfig.clientCertificate.resize(count+1);
2112  connection->eapConfig.clientCertificate[count] = innerDataValue.toByte();
2113  }
2114  }
2115  else if (keyValue.lower() == "phase1-peapver") {
2116  connection->eapConfig.forcePEAPVersion = dataValue2.toString();
2117  }
2118  else if (keyValue.lower() == "phase1-peaplabel") {
2119  connection->eapConfig.forcePEAPLabel = dataValue2.toString();
2120  }
2121  else if (keyValue.lower() == "phase1-fast-provisioning") {
2122  connection->eapConfig.fastProvisioningFlags = nmEAPFastFlagsToTDEEAPFastFlags(dataValue2.toString());
2123  }
2124  else if (keyValue.lower() == "phase2-auth") {
2125  connection->eapConfig.phase2NonEAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
2126  }
2127  else if (keyValue.lower() == "phase2-autheap") {
2128  connection->eapConfig.phase2EAPAuthMethod = nmEAPTypeToTDEEAPType(dataValue2.toString());
2129  }
2130  else if (keyValue.lower() == "phase2-ca-cert") {
2131  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2132  TQT_DBusDataValueList::const_iterator it4;
2133  int count=0;
2134  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2135  TQT_DBusData innerDataValue = *it4;
2136  count++;
2137  connection->eapConfig.phase2CaCertificate.resize(count+1);
2138  connection->eapConfig.phase2CaCertificate[count] = innerDataValue.toByte();
2139  }
2140  }
2141  else if (keyValue.lower() == "phase2-ca-path") {
2142  connection->eapConfig.phase2CaFilesPath = dataValue2.toString();
2143  }
2144  else if (keyValue.lower() == "phase2-subject-match") {
2145  connection->eapConfig.phase2AuthServerCertSubjectMatch = dataValue2.toString();
2146  }
2147  else if (keyValue.lower() == "phase2-altsubject-matches") {
2148  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2149  TQT_DBusDataValueList::const_iterator it4;
2150  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2151  TQT_DBusData innerDataValue = *it4;
2152  connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.append(innerDataValue.toString());
2153  }
2154  }
2155  else if (keyValue.lower() == "phase2-client-cert") {
2156  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2157  TQT_DBusDataValueList::const_iterator it4;
2158  int count=0;
2159  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2160  TQT_DBusData innerDataValue = *it4;
2161  count++;
2162  connection->eapConfig.phase2ClientCertificate.resize(count+1);
2163  connection->eapConfig.phase2ClientCertificate[count] = innerDataValue.toByte();
2164  }
2165  }
2166  else if (keyValue.lower() == "password-flags") {
2167  connection->eapConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2168  }
2169  else if (keyValue.lower() == "password-raw-flags") {
2170  connection->eapConfig.binaryPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2171  }
2172  else if (keyValue.lower() == "private-key") {
2173  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2174  TQT_DBusDataValueList::const_iterator it4;
2175  int count=0;
2176  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2177  TQT_DBusData innerDataValue = *it4;
2178  count++;
2179  connection->eapConfig.privateKey.resize(count+1);
2180  connection->eapConfig.privateKey[count] = innerDataValue.toByte();
2181  }
2182  }
2183  else if (keyValue.lower() == "private-key-password-flags") {
2184  connection->eapConfig.privateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2185  }
2186  else if (keyValue.lower() == "phase2-private-key") {
2187  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2188  TQT_DBusDataValueList::const_iterator it4;
2189  int count=0;
2190  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2191  TQT_DBusData innerDataValue = *it4;
2192  count++;
2193  connection->eapConfig.phase2PrivateKey.resize(count+1);
2194  connection->eapConfig.phase2PrivateKey[count] = innerDataValue.toByte();
2195  }
2196  }
2197  else if (keyValue.lower() == "phase2-private-key-password-flags") {
2198  connection->eapConfig.phase2PrivateKeyPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2199  }
2200  else if (keyValue.lower() == "system-ca-certs") {
2201  connection->eapConfig.forceSystemCaCertificates = dataValue2.toBool();
2202  }
2203  connection->eapConfig.valid = true;
2204  }
2205  else if (outerKeyValue.lower() == "802-3-ethernet") {
2206  if (keyValue.lower() == "duplex") {
2207  connection->fullDuplex = (dataValue2.toString().lower() == "full")?true:false;
2208  }
2209  else if (keyValue.lower() == "mac-address") {
2210  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2211  TQT_DBusDataValueList::const_iterator it4;
2212  TDENetworkByteList macAddress;
2213  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2214  TQT_DBusData innerDataValue = *it4;
2215  macAddress.append(innerDataValue.toByte());
2216  }
2217  connection->lockedHWAddress.setAddress(macAddress);
2218  }
2219  else if (keyValue.lower() == "cloned-mac-address") {
2220  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2221  TQT_DBusDataValueList::const_iterator it4;
2222  TDENetworkByteList macAddress;
2223  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2224  TQT_DBusData innerDataValue = *it4;
2225  macAddress.append(innerDataValue.toByte());
2226  }
2227  connection->manualHWAddress.setAddress(macAddress);
2228  }
2229  else if (keyValue.lower() == "mtu") {
2230  connection->mtu = dataValue2.toUInt32();
2231  }
2232  }
2233  else if (outerKeyValue.lower() == "infiniband") {
2234  if (keyValue.lower() == "mac-address") {
2235  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2236  TQT_DBusDataValueList::const_iterator it4;
2237  TDENetworkByteList macAddress;
2238  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2239  TQT_DBusData innerDataValue = *it4;
2240  macAddress.append(innerDataValue.toByte());
2241  }
2242  connection->lockedHWAddress.setAddress(macAddress);
2243  }
2244  else if (keyValue.lower() == "mtu") {
2245  connection->mtu = dataValue2.toUInt32();
2246  }
2247  else if (keyValue.lower() == "transport-mode") {
2248  infinibandConnection->transportMode = nmIBTransportToTDEIBTransport(dataValue2.toString());
2249  }
2250  }
2251  else if (outerKeyValue.lower() == "802-11-wireless") {
2252  if (keyValue.lower() == "ssid") {
2253  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2254  TQT_DBusDataValueList::const_iterator it4;
2255  int count = 0;
2256  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2257  TQT_DBusData innerDataValue = *it4;
2258  wiFiConnection->SSID.resize(count+1);
2259  wiFiConnection->SSID[count] = innerDataValue.toByte();
2260  count++;
2261  }
2262  }
2263  else if (keyValue.lower() == "mac-address") {
2264  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2265  TQT_DBusDataValueList::const_iterator it4;
2266  TDENetworkByteList macAddress;
2267  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2268  TQT_DBusData innerDataValue = *it4;
2269  macAddress.append(innerDataValue.toByte());
2270  }
2271  connection->lockedHWAddress.setAddress(macAddress);
2272  }
2273  else if (keyValue.lower() == "cloned-mac-address") {
2274  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2275  TQT_DBusDataValueList::const_iterator it4;
2276  TDENetworkByteList macAddress;
2277  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2278  TQT_DBusData innerDataValue = *it4;
2279  macAddress.append(innerDataValue.toByte());
2280  }
2281  connection->manualHWAddress.setAddress(macAddress);
2282  }
2283  else if (keyValue.lower() == "mtu") {
2284  connection->mtu = dataValue2.toUInt32();
2285  }
2286  else if (keyValue.lower() == "mode") {
2287  wiFiConnection->operatingMode = nmWiFiModeToTDEWiFiMode(dataValue2.toString());
2288  }
2289  else if (keyValue.lower() == "band") {
2290  wiFiConnection->bandRestriction = nmWiFiFrequencyBandToTDEWiFiFrequencyBand(dataValue2.toString());
2291  }
2292  else if (keyValue.lower() == "channel") {
2293  wiFiConnection->channelRestriction = dataValue2.toUInt32();
2294  if (wiFiConnection->channelRestriction == 0) wiFiConnection->channelRestriction = -1;
2295  }
2296  else if (keyValue.lower() == "rate") {
2297  wiFiConnection->bitRateRestriction = dataValue2.toUInt32()*1000;
2298  if (wiFiConnection->bitRateRestriction == 0) wiFiConnection->bitRateRestriction = -1;
2299  }
2300  else if (keyValue.lower() == "tx-power") {
2301  wiFiConnection->powerRestriction = dataValue2.toUInt32();
2302  if (wiFiConnection->powerRestriction == 0) wiFiConnection->powerRestriction = -1;
2303  }
2304  else if (keyValue.lower() == "bssid") {
2305  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2306  TQT_DBusDataValueList::const_iterator it4;
2307  TDENetworkByteList macAddress;
2308  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2309  TQT_DBusData innerDataValue = *it4;
2310  macAddress.append(innerDataValue.toByte());
2311  }
2312  wiFiConnection->accessPointRestriction.setAddress(macAddress);
2313  }
2314  else if (keyValue.lower() == "mac-address-blacklist") {
2315  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2316  TQT_DBusDataValueList::const_iterator it4;
2317  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2318  TQT_DBusData innerDataValue = *it4;
2319  TDEMACAddress hwAddress;
2320  hwAddress.fromString(innerDataValue.toString());
2321  wiFiConnection->blacklistedBSSIDs.append(hwAddress);
2322  }
2323  }
2324  else if (keyValue.lower() == "seen-bssids") {
2325  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2326  TQT_DBusDataValueList::const_iterator it4;
2327  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2328  TQT_DBusData innerDataValue = *it4;
2329  TDEMACAddress hwAddress;
2330  hwAddress.fromString(innerDataValue.toString());
2331  wiFiConnection->heardBSSIDs.append(hwAddress);
2332  }
2333  }
2334  else if (keyValue.lower() == "security") {
2335  TQString setting;
2336  if (setting.lower() == "802-11-wireless-security") {
2337  wiFiConnection->securityRequired = true;
2338  }
2339  else {
2340  wiFiConnection->securityRequired = false;
2341  }
2342  }
2343  else if (keyValue.lower() == "hidden") {
2344  wiFiConnection->isHiddenNetwork = dataValue2.toBool();
2345  }
2346  }
2347  else if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
2348  if (keyValue.lower() == "key-mgmt") {
2349  wiFiConnection->securitySettings.keyType = nmWiFiKeyTypeToTDEWiFiKeyType(dataValue2.toString());
2350  }
2351  else if (keyValue.lower() == "wep-tx-keyidx") {
2352  wiFiConnection->securitySettings.wepKeyIndex = dataValue2.toUInt32();
2353  }
2354  else if (keyValue.lower() == "auth-alg") {
2355  wiFiConnection->securitySettings.authType = nmWiFiAuthTypeToTDEWiFiAuthType(dataValue2.toString());
2356  }
2357  else if (keyValue.lower() == "proto") {
2358  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2359  TQT_DBusDataValueList::const_iterator it4;
2360  TQStringList strings;
2361  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2362  TQT_DBusData innerDataValue = *it4;
2363  strings.append(innerDataValue.toString());
2364  }
2365  wiFiConnection->securitySettings.wpaVersion = nmWiFiWPAVersionToTDEWiFiWPAVersion(strings);
2366  }
2367  else if (keyValue.lower() == "pairwise") {
2368  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2369  TQT_DBusDataValueList::const_iterator it4;
2370  TQStringList strings;
2371  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2372  TQT_DBusData innerDataValue = *it4;
2373  wiFiConnection->securitySettings.allowedPairWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
2374  }
2375  if ((wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
2376  || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
2377  || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
2378  || (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
2379  wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
2380  }
2381  }
2382  else if (keyValue.lower() == "group") {
2383  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2384  TQT_DBusDataValueList::const_iterator it4;
2385  TQStringList strings;
2386  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2387  TQT_DBusData innerDataValue = *it4;
2388  wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(nmWiFiCipherToTDEWiFiCipher(innerDataValue.toString()));
2389  }
2390  if ((wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40))
2391  || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104))
2392  || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP))
2393  || (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP))) {
2394  wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::Any);
2395  }
2396  }
2397  else if (keyValue.lower() == "leap-username") {
2398  wiFiConnection->securitySettings.leapUsername = dataValue2.toString();
2399  }
2400  else if (keyValue.lower() == "wep-key-flags") {
2401  wiFiConnection->securitySettings.wepKeyFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2402  }
2403  else if (keyValue.lower() == "wep-key-type") {
2404  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(dataValue2.toUInt32());
2405  }
2406  else if (keyValue.lower() == "psk-flags") {
2407  wiFiConnection->securitySettings.pskFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2408  }
2409  else if (keyValue.lower() == "leap-password-flags") {
2410  wiFiConnection->securitySettings.leapPasswordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2411  }
2412  wiFiConnection->securitySettings.valid = true;
2413  }
2414  else if (outerKeyValue.lower() == "vpn") {
2415  if (keyValue.lower() == "service-type") {
2416  TQString plugin = dataValue2.toString();
2417  plugin.replace("org.freedesktop.NetworkManager.", "");
2418  vpnConnection->vpnPluginID = plugin;
2419  }
2420  else if (keyValue.lower() == "user-name") {
2421  vpnConnection->lockedUserName = dataValue2.toString();
2422  }
2423  else if (keyValue.lower() == "data") {
2424  vpnConnection->pluginData.clear();
2425  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
2426  TQT_DBusTQStringDataMap::const_iterator it4;
2427  for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
2428  TQString keyValue4 = it4.key();
2429  TQT_DBusData dataValue4 = it4.data();
2430  if (dataValue4.type() == TQT_DBusData::String) {
2431  vpnConnection->pluginData[keyValue4] = dataValue4.toString();
2432  }
2433  }
2434  }
2435  }
2436  else if (outerKeyValue.lower() == "wimax") {
2437  if (keyValue.lower() == "mac-address") {
2438  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2439  TQT_DBusDataValueList::const_iterator it4;
2440  TDENetworkByteList macAddress;
2441  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2442  TQT_DBusData innerDataValue = *it4;
2443  macAddress.append(innerDataValue.toByte());
2444  }
2445  connection->lockedHWAddress.setAddress(macAddress);
2446  }
2447  else if (keyValue.lower() == "network-name") {
2448  wiMaxConnection->networkServiceProvider = dataValue2.toString();
2449  }
2450  }
2451  else if (outerKeyValue.lower() == "vlan") {
2452  if (keyValue.lower() == "interface-name") {
2453  vlanConnection->kernelName = dataValue2.toString();
2454  }
2455  else if (keyValue.lower() == "parent") {
2456  vlanConnection->parentConnectionUUID = dataValue2.toString();
2457  }
2458  else if (keyValue.lower() == "id") {
2459  vlanConnection->vlanID = dataValue2.toUInt32();
2460  }
2461  else if (keyValue.lower() == "flags") {
2462  vlanConnection->vlanFlags = nmVLANFlagsToTDEVLANFlags(dataValue2.toUInt32());
2463  }
2464  else if (keyValue.lower() == "ingress-priority-map") {
2465  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2466  TQT_DBusDataValueList::const_iterator it4;
2467  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2468  TQT_DBusData innerDataValue = *it4;
2469  TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
2470  vlanConnection->ingressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
2471  }
2472  }
2473  else if (keyValue.lower() == "egress-priority-map") {
2474  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2475  TQT_DBusDataValueList::const_iterator it4;
2476  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2477  TQT_DBusData innerDataValue = *it4;
2478  TQStringList pieces = TQStringList::split(":", innerDataValue.toString(), TRUE);
2479  vlanConnection->egressPriorityMap[pieces[0].toUInt()] = pieces[1].toUInt();;
2480  }
2481  }
2482  }
2483  else if (outerKeyValue.lower() == "serial") {
2484  if (keyValue.lower() == "baud") {
2485  connection->serialConfig.baudRate = dataValue2.toUInt32();
2486  }
2487  else if (keyValue.lower() == "bits") {
2488  connection->serialConfig.byteWidth = dataValue2.toUInt32();
2489  }
2490  else if (keyValue.lower() == "parity") {
2491  connection->serialConfig.parity = nmParityToTDEParity(dataValue2.toByte());
2492  }
2493  else if (keyValue.lower() == "stopbits") {
2494  connection->serialConfig.stopBits = dataValue2.toUInt32();
2495  }
2496  else if (keyValue.lower() == "send-delay") {
2497  connection->serialConfig.txDelay = dataValue2.toUInt64();
2498  }
2499  connection->serialConfig.valid = true;
2500  }
2501  else if (outerKeyValue.lower() == "ppp") {
2502  if (keyValue.lower() == "noauth") {
2503  connection->pppConfig.requireServerAuthentication = !(dataValue2.toBool());
2504  }
2505  else if (keyValue.lower() == "refuse-eap") {
2506  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisableEAP;
2507  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableEAP;
2508  }
2509  else if (keyValue.lower() == "refuse-pap") {
2510  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisablePAP;
2511  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisablePAP;
2512  }
2513  else if (keyValue.lower() == "refuse-chap") {
2514  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisableCHAP;
2515  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableCHAP;
2516  }
2517  else if (keyValue.lower() == "refuse-mschap") {
2518  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisableMSCHAP;
2519  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAP;
2520  }
2521  else if (keyValue.lower() == "refuse-mschapv2") {
2522  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::DisableMSCHAPv2;
2523  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::DisableMSCHAPv2;
2524  }
2525  else if (keyValue.lower() == "nobsdcomp") {
2526  if (dataValue2.toBool()) connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowBSDCompression;
2527  else connection->pppConfig.flags |= TDENetworkPPPFlags::AllowBSDCompression;
2528  }
2529  else if (keyValue.lower() == "nodeflate") {
2530  if (dataValue2.toBool()) connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowDeflateCompression;
2531  else connection->pppConfig.flags |= TDENetworkPPPFlags::AllowDeflateCompression;
2532  }
2533  else if (keyValue.lower() == "no-vj-comp") {
2534  if (dataValue2.toBool()) connection->pppConfig.flags &= ~TDENetworkPPPFlags::AllowVJCompression;
2535  else connection->pppConfig.flags |= TDENetworkPPPFlags::AllowVJCompression;
2536  }
2537  else if (keyValue.lower() == "require-mppe") {
2538  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::RequireMPPE;
2539  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE;
2540  }
2541  else if (keyValue.lower() == "require-mppe-128") {
2542  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::RequireMPPE128;
2543  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::RequireMPPE128;
2544  }
2545  else if (keyValue.lower() == "mppe-stateful") {
2546  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::StatefulMPPE;
2547  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::StatefulMPPE;
2548  }
2549  else if (keyValue.lower() == "crtscts") {
2550  if (dataValue2.toBool()) connection->pppConfig.flags |= TDENetworkPPPFlags::UseHardwareFlowControl;
2551  else connection->pppConfig.flags &= ~TDENetworkPPPFlags::UseHardwareFlowControl;
2552  }
2553  else if (keyValue.lower() == "baud") {
2554  connection->pppConfig.baudRate = dataValue2.toUInt32();
2555  }
2556  else if (keyValue.lower() == "mru") {
2557  connection->pppConfig.mru = dataValue2.toUInt32();
2558  }
2559  else if (keyValue.lower() == "mtu") {
2560  connection->pppConfig.mtu = dataValue2.toUInt32();
2561  }
2562  else if (keyValue.lower() == "lcp-echo-interval") {
2563  connection->pppConfig.lcpEchoPingInterval = dataValue2.toUInt32();
2564  }
2565  else if (keyValue.lower() == "lcp-echo-failure") {
2566  connection->pppConfig.lcpEchoFailureThreshold = dataValue2.toUInt32();
2567  }
2568  connection->pppConfig.valid = true;
2569  }
2570  else if (outerKeyValue.lower() == "pppoe") {
2571  if (keyValue.lower() == "service") {
2572  connection->pppoeConfig.networkServiceProvider = dataValue2.toString();
2573  }
2574  else if (keyValue.lower() == "username") {
2575  connection->pppoeConfig.username = dataValue2.toString();
2576  }
2577  else if (keyValue.lower() == "password-flags") {
2578  connection->pppoeConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2579  }
2580  connection->pppoeConfig.secretsValid = true;
2581  }
2582  else if ((outerKeyValue.lower() == "802-11-olpc-mesh") && (olpcMeshConnection)) {
2583  if (keyValue.lower() == "ssid") {
2584  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2585  TQT_DBusDataValueList::const_iterator it4;
2586  int count = 0;
2587  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2588  TQT_DBusData innerDataValue = *it4;
2589  olpcMeshConnection->SSID.resize(count+1);
2590  olpcMeshConnection->SSID[count] = innerDataValue.toByte();
2591  count++;
2592  }
2593  }
2594  else if (keyValue.lower() == "channel") {
2595  olpcMeshConnection->channel = dataValue2.toUInt32();
2596  }
2597  else if (keyValue.lower() == "dhcp-anycast-address") {
2598  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2599  TQT_DBusDataValueList::const_iterator it4;
2600  int count = 0;
2601  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2602  TQT_DBusData innerDataValue = *it4;
2603  olpcMeshConnection->anycastDHCPHWAddress.resize(count+1);
2604  olpcMeshConnection->anycastDHCPHWAddress[count] = innerDataValue.toByte();
2605  count++;
2606  }
2607  }
2608  }
2609  else if ((outerKeyValue.lower() == "bluetooth") && (bluetoothConnection)) {
2610  if (keyValue.lower() == "bdaddr") {
2611  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2612  TQT_DBusDataValueList::const_iterator it4;
2613  TDENetworkByteList macAddress;
2614  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2615  TQT_DBusData innerDataValue = *it4;
2616  macAddress.append(innerDataValue.toByte());
2617  }
2618  connection->lockedHWAddress.setAddress(macAddress);
2619  }
2620  else if (keyValue.lower() == "type") {
2621  bluetoothConnection->type = nmBluetoothModeToTDEBluetoothMode(dataValue2.toString());
2622  }
2623  }
2624  else if ((outerKeyValue.lower() == "cdma") && (modemConnection)) {
2625  if (keyValue.lower() == "number") {
2626  modemConnection->cdmaConfig.providerDataNumber = dataValue2.toString();
2627  }
2628  else if (keyValue.lower() == "username") {
2629  modemConnection->cdmaConfig.username = dataValue2.toString();
2630  }
2631  else if (keyValue.lower() == "password-flags") {
2632  modemConnection->cdmaConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2633  }
2634  modemConnection->type = TDEModemConnectionType::CDMA;
2635  modemConnection->cdmaConfig.valid = true;
2636  }
2637  else if ((outerKeyValue.lower() == "gsm") && (modemConnection)) {
2638  if (keyValue.lower() == "number") {
2639  modemConnection->gsmConfig.providerDataNumber = dataValue2.toString();
2640  }
2641  else if (keyValue.lower() == "username") {
2642  modemConnection->gsmConfig.username = dataValue2.toString();
2643  }
2644  else if (keyValue.lower() == "password-flags") {
2645  modemConnection->gsmConfig.passwordFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2646  }
2647  else if (keyValue.lower() == "apn") {
2648  modemConnection->gsmConfig.accessPointName = dataValue2.toString();
2649  }
2650  else if (keyValue.lower() == "network-id") {
2651  modemConnection->gsmConfig.networkID = dataValue2.toString();
2652  }
2653  else if (keyValue.lower() == "network-type") {
2654  modemConnection->gsmConfig.networkType = nmGSMModeToTDEGSMMode(dataValue2.toInt32());
2655  }
2656  else if (keyValue.lower() == "pin-flags") {
2657  modemConnection->gsmConfig.pinFlags = nmPasswordFlagsToTDEPasswordFlags(dataValue2.toUInt32());
2658  }
2659  else if (keyValue.lower() == "allowed-bands") {
2660  modemConnection->gsmConfig.allowedFrequencyBands = dataValue2.toUInt32();
2661  }
2662  else if (keyValue.lower() == "home-only") {
2663  modemConnection->gsmConfig.allowRoaming = !dataValue2.toBool();
2664  }
2665  modemConnection->type = TDEModemConnectionType::GSM;
2666  modemConnection->gsmConfig.valid = true;
2667  }
2668  else if (outerKeyValue.lower() == "ipv4") {
2669  if (keyValue.lower() == "addresses") {
2670  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2671  TQT_DBusDataValueList::const_iterator it4;
2672  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2673  TQT_DBusData innerDataValue = *it4;
2674  TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
2675  TQT_DBusDataValueList::const_iterator it5;
2676  state = 0;
2677  TDENetworkSingleIPConfiguration ipConfig;
2678  for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
2679  TQT_DBusData innerMostDataValue = *it5;
2680  if (state == 0) {
2681  // Address
2682  ipConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
2683  }
2684  else if (state == 1) {
2685  // Network mask
2686  ipConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
2687  }
2688  else if (state == 2) {
2689  // Gateway
2690  ipConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
2691  }
2692  state++;
2693  }
2694  ipConfig.valid = true;
2695  connection->ipConfig.ipConfigurations.append(ipConfig);
2696  }
2697  }
2698  else if (keyValue.lower() == "dhcp-client-id") {
2699  connection->ipConfig.dhcpClientIdentifier = dataValue2.toString();
2700  }
2701  else if (keyValue.lower() == "dns") {
2702  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2703  TQT_DBusDataValueList::const_iterator it4;
2704  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2705  TQT_DBusData innerDataValue = *it4;
2706  connection->ipConfig.resolvers.append(TQHostAddress(reverseIPV4ByteOrder(innerDataValue.toUInt32())));
2707  }
2708  }
2709  else if (keyValue.lower() == "dns-search") {
2710  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2711  TQT_DBusDataValueList::const_iterator it4;
2712  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2713  TQT_DBusData innerDataValue = *it4;
2714  connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), false));
2715  }
2716  }
2717  else if (keyValue.lower() == "ignore-auto-dns") {
2718  bool nm_static_dns = dataValue2.toBool();
2719  if (nm_static_dns) {
2720  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
2721  }
2722  else {
2723  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
2724  }
2725  }
2726  else if (keyValue.lower() == "may-fail") {
2727  bool nm_may_fail = dataValue2.toBool();
2728  connection->requireIPV4 = !nm_may_fail;
2729  }
2730  else if (keyValue.lower() == "method") {
2731  TQString nm_method = dataValue2.toString().lower();
2732  if (nm_method == "auto") {
2733  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPIP;
2734  }
2735  else if (nm_method == "manual") {
2736  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPIP;
2737  }
2738  else if (nm_method == "link-local") {
2739  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4LocalOnly;
2740  }
2741  else if (nm_method == "shared") {
2742  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer;
2743  }
2744  else if (nm_method == "disabled") {
2745  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4Disabled;
2746  }
2747  }
2748  else if (keyValue.lower() == "ignore-auto-routes") {
2749  bool nm_static_routes = dataValue2.toBool();
2750  if (nm_static_routes) {
2751  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
2752  }
2753  else {
2754  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPRoutes;
2755  }
2756  }
2757  else if (keyValue.lower() == "never-default") {
2758  bool nm_can_default_route = !dataValue2.toBool();
2759  if (nm_can_default_route) {
2760  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
2761  }
2762  else {
2763  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute;
2764  }
2765  }
2766  else if (keyValue.lower() == "routes") {
2767  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2768  TQT_DBusDataValueList::const_iterator it4;
2769  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2770  TQT_DBusData innerDataValue = *it4;
2771  TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
2772  TQT_DBusDataValueList::const_iterator it5;
2773  state = 0;
2774  TDENetworkSingleRouteConfiguration routeConfig;
2775  for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
2776  TQT_DBusData innerMostDataValue = *it5;
2777  if (state == 0) {
2778  // Address
2779  routeConfig.ipAddress = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
2780  }
2781  else if (state == 1) {
2782  // Network mask
2783  routeConfig.networkMask.fromCIDRMask(innerMostDataValue.toUInt32());
2784  }
2785  else if (state == 2) {
2786  // Gateway
2787  routeConfig.gateway = TQHostAddress(reverseIPV4ByteOrder(innerMostDataValue.toUInt32()));
2788  }
2789  else if (state == 3) {
2790  // Metric
2791  routeConfig.metric = innerMostDataValue.toUInt32();
2792  }
2793  state++;
2794  }
2795  routeConfig.valid = true;
2796  connection->ipConfig.routeConfigurations.append(routeConfig);
2797  }
2798  }
2799  connection->ipConfig.valid = true;
2800  }
2801  else if (outerKeyValue.lower() == "ipv6") {
2802  if (keyValue.lower() == "addresses") {
2803  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2804  TQT_DBusDataValueList::const_iterator it4;
2805  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2806  TQT_DBusData innerDataValue = *it4;
2807  TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
2808  TQT_DBusDataValueList::const_iterator it5;
2809  TDENetworkSingleIPConfiguration ipConfig;
2810  // Address
2811  TQT_DBusDataValueList innerMostValueList;
2812  innerMostValueList = innerValueList[0].toTQValueList();
2813  TQ_UINT8 nm_v6address[16];
2814  unsigned char nm_addr_ptr = 0;
2815  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2816  for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
2817  TQT_DBusData innerMostDataValue = *it5;
2818  if (nm_addr_ptr < 16) {
2819  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2820  nm_addr_ptr++;
2821  }
2822  }
2823  ipConfig.ipAddress = TQHostAddress(nm_v6address);
2824 
2825  // Netmask
2826  ipConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);
2827 
2828  // Gateway
2829  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2830  for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
2831  TQT_DBusData innerMostDataValue = *it5;
2832  if (nm_addr_ptr < 16) {
2833  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2834  nm_addr_ptr++;
2835  }
2836  }
2837  ipConfig.gateway = TQHostAddress(nm_v6address);
2838 
2839  ipConfig.valid = true;
2840  connection->ipConfig.ipConfigurations.append(ipConfig);
2841  }
2842  }
2843  else if (keyValue.lower() == "dns") {
2844  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2845  TQT_DBusDataValueList::const_iterator it4;
2846  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2847  TQT_DBusData innerDataValue = *it4;
2848  TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
2849  TQT_DBusDataValueList::const_iterator it5;
2850  TQ_UINT8 nm_v6address[16];
2851  unsigned char nm_addr_ptr = 0;
2852  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2853  for (it5 = innerValueList.begin(); it5 != innerValueList.end(); ++it5) {
2854  TQT_DBusData innerMostDataValue = *it5;
2855  if (nm_addr_ptr < 16) {
2856  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2857  nm_addr_ptr++;
2858  }
2859  }
2860  connection->ipConfig.resolvers.append(TQHostAddress(nm_v6address));
2861  }
2862  }
2863  else if (keyValue.lower() == "dns-search") {
2864  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2865  TQT_DBusDataValueList::const_iterator it4;
2866  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2867  TQT_DBusData innerDataValue = *it4;
2868  TQT_DBusDataValueList innerValueList = innerDataValue.toTQValueList();
2869  TQT_DBusDataValueList::const_iterator it5;
2870  connection->ipConfig.searchDomains.append(TDENetworkSearchDomain(innerDataValue.toString(), true));
2871  }
2872  }
2873  else if (keyValue.lower() == "ignore-auto-dns") {
2874  bool nm_static_dns = dataValue2.toBool();
2875  if (nm_static_dns) {
2876  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
2877  }
2878  else {
2879  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV4DHCPDNS;
2880  }
2881  }
2882  else if (keyValue.lower() == "may-fail") {
2883  bool nm_may_fail = dataValue2.toBool();
2884  connection->requireIPV6 = !nm_may_fail;
2885  }
2886  else if (keyValue.lower() == "method") {
2887  TQString nm_method = dataValue2.toString().lower();
2888  if (nm_method == "auto") {
2889  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPIP;
2890  }
2891  else if (nm_method == "manual") {
2892  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPIP;
2893  }
2894  else if (nm_method == "link-local") {
2895  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6LocalOnly;
2896  }
2897  else if (nm_method == "shared") {
2898  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer;
2899  }
2900  else if (nm_method == "ignore") {
2901  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6Disabled;
2902  }
2903  }
2904  else if (keyValue.lower() == "ignore-auto-routes") {
2905  bool nm_static_routes = dataValue2.toBool();
2906  if (nm_static_routes) {
2907  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
2908  }
2909  else {
2910  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6DHCPRoutes;
2911  }
2912  }
2913  else if (keyValue.lower() == "never-default") {
2914  bool nm_can_default_route = !dataValue2.toBool();
2915  if (nm_can_default_route) {
2916  connection->ipConfig.connectionFlags |= TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
2917  }
2918  else {
2919  connection->ipConfig.connectionFlags &= ~TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
2920  }
2921  }
2922  else if (keyValue.lower() == "routes") {
2923  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
2924  TQT_DBusDataValueList::const_iterator it4;
2925  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
2926  TQT_DBusData innerDataValue = *it4;
2927  TQT_DBusDataValueList innerValueList = innerDataValue.toStruct();
2928  TQT_DBusDataValueList::const_iterator it5;
2929  TDENetworkSingleRouteConfiguration routeConfig;
2930  // Address
2931  TQT_DBusDataValueList innerMostValueList;
2932  innerMostValueList = innerValueList[0].toTQValueList();
2933  TQ_UINT8 nm_v6address[16];
2934  unsigned char nm_addr_ptr = 0;
2935  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2936  for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
2937  TQT_DBusData innerMostDataValue = *it5;
2938  if (nm_addr_ptr < 16) {
2939  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2940  nm_addr_ptr++;
2941  }
2942  }
2943  routeConfig.ipAddress = TQHostAddress(nm_v6address);
2944 
2945  // Netmask
2946  routeConfig.networkMask.fromCIDRMask(innerValueList[1].toUInt32(), true);
2947 
2948  // Gateway
2949  innerMostValueList = innerValueList[2].toTQValueList();
2950  nm_addr_ptr = 0;
2951  memset(nm_v6address, 0, sizeof(TQ_UINT8)*16);
2952  for (it5 = innerMostValueList.begin(); it5 != innerMostValueList.end(); ++it5) {
2953  TQT_DBusData innerMostDataValue = *it5;
2954  if (nm_addr_ptr < 16) {
2955  nm_v6address[nm_addr_ptr] = innerMostDataValue.toByte();
2956  nm_addr_ptr++;
2957  }
2958  }
2959  routeConfig.gateway = TQHostAddress(nm_v6address);
2960 
2961  // Metric
2962  routeConfig.metric = innerValueList[3].toUInt32();
2963 
2964  routeConfig.valid = true;
2965  connection->ipConfig.routeConfigurations.append(routeConfig);
2966  }
2967  }
2968  connection->ipConfig.valid = true;
2969  }
2970  }
2971  else {
2972  // FIXME
2973  // There are several advanced properties which appear to use string maps
2974  // For example, s390-options
2975  // Support should eventually be added for these, e.g. in a backend-specific Advanced tab somewhere
2976  }
2977  }
2978  }
2979  }
2980 
2981  // If the connection's MAC matches my MAC, or if the connection is not locked to any MAC address,
2982  // or if this manager object is not locked to a device, then add this connection to the list
2983  if ((deviceMACAddress == connection->lockedHWAddress) || (!connection->lockedHWAddress.isValid()) || (!deviceMACAddress.isValid())) {
2984  loadConnectionAllowedValues(connection);
2985  m_connectionList->append(connection);
2986  }
2987  }
2988  else {
2989  // Error!
2990  PRINT_ERROR((error.name() + ": " + error.message()))
2991  }
2992  }
2993  }
2994  else {
2995  // Error!
2996  PRINT_ERROR((error.name() + ": " + error.message()))
2997  }
2998  internalNetworkManagementEvent(TDENetworkGlobalEventType::ConnectionListChanged);
2999  }
3000 
3001  d->nonReentrantCallActive = false;
3002 }
3003 
3004 void TDENetworkConnectionManager_BackendNM::loadConnectionAllowedValues(TDENetworkConnection* connection) {
3005  if (connection) {
3006  // Insert all allowed EAP phase 2 methods
3007  connection->eapConfig.allowedPhase2NonEAPMethods.clear();
3008  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MD5);
3009  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
3010  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::OTP);
3011  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::GTC);
3012  connection->eapConfig.allowedPhase2NonEAPMethods.append(TDENetworkIEEE8021xType::TLS);
3013 
3014  connection->eapConfig.allowedPhase2EAPMethods.clear();
3015  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::PAP);
3016  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::CHAP);
3017  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAP);
3018  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::MSCHAPV2);
3019  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::OTP);
3020  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::GTC);
3021  connection->eapConfig.allowedPhase2EAPMethods.append(TDENetworkIEEE8021xType::TLS);
3022 
3023  connection->eapConfig.allowedValid = true;
3024  }
3025 }
3026 
3027 // NOTE
3028 // While this separate separate routine is needed to get the secrets, note that secrets must
3029 // be saved using the same connection map save routine that all other settings use above.
3030 bool TDENetworkConnectionManager_BackendNM::loadConnectionSecrets(TQString uuid) {
3031  TDENetworkConnection* connection = findConnectionByUUID(uuid);
3032  if (!connection) {
3033  PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database. Did you run loadConnectionInformation() first?"));
3034  return FALSE;
3035  }
3036  //TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
3037  //TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
3038  TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
3039  TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
3040  //TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
3041  //TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
3042  //TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
3043  //TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
3044  TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
3045 
3046  bool ret = TRUE;
3047  ret = ret && loadConnectionSecretsForGroup(uuid, "802-1x");
3048  if (wiFiConnection) {
3049  ret = ret && loadConnectionSecretsForGroup(uuid, "802-11-wireless-security");
3050  }
3051  if (vpnConnection) {
3052  ret = ret && loadConnectionSecretsForGroup(uuid, "vpn");
3053  }
3054  ret = ret && loadConnectionSecretsForGroup(uuid, "pppoe");
3055  if (modemConnection) {
3056  ret = ret && loadConnectionSecretsForGroup(uuid, "cdma");
3057  ret = ret && loadConnectionSecretsForGroup(uuid, "gsm");
3058  }
3059  return ret;
3060 }
3061 
3062 bool TDENetworkConnectionManager_BackendNM::loadConnectionSecretsForGroup(TQString uuid, TQString group) {
3063  TDENetworkConnection* connection = findConnectionByUUID(uuid);
3064  if (!connection) {
3065  PRINT_ERROR(TQString("Unable to locate connection with uuid '%1' in local database. Did you run loadConnectionInformation() first?"));
3066  return FALSE;
3067  }
3068  //TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
3069  //TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
3070  TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
3071  TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
3072  //TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
3073  //TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
3074  //TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEVLANConnection*>(connection);
3075  //TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
3076  TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
3077  TQT_DBusObjectPath existingConnection;
3078  TQT_DBusError error;
3079  bool ret;
3080  TQT_DBusTQStringDataMap connectionSecretsMap(TQT_DBusData::String);
3081  ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
3082  if (ret) {
3083 #ifndef USE_ASYNC_DBUS_CALLS
3084  // Obtain connection settings from the path specified
3085  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
3086  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
3087  ret = connectionSettings.GetSecrets(group, connectionSecretsMap, error);
3088  if (ret && error.isValid()) {
3089  ret = 0;
3090  PRINT_ERROR((error.name() + ": " + error.message()))
3091  }
3092  if (ret) {
3093 #else // USE_ASYNC_DBUS_CALLS
3094  // Obtain connection secrets from the path specified
3095  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
3096  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
3097  connect(&connectionSettings, SIGNAL(GetSecretsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
3098  int asyncCallID;
3099  ret = connectionSettings.GetSecretsAsync(asyncCallID, group, error);
3100  if (ret && error.isValid()) {
3101  ret = 0;
3102  PRINT_ERROR((error.name() + ": " + error.message()))
3103  }
3104  if (ret) {
3105  // Wait for the asynchronous call to return...
3106  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
3107  TQTimer nmCallTimeoutTimer;
3108  nmCallTimeoutTimer.start(NM_ASYNC_SECRETS_INTERACTION_TIMEOUT_MS, TRUE);
3109  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
3110  tqApp->processEvents();
3111  if (!nmCallTimeoutTimer.isActive()) {
3112  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
3113  break;
3114  }
3115  }
3116  connectionSecretsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
3117  if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
3118  PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
3119  d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
3120  }
3121  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
3122  if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
3123  d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
3124  }
3125 #endif // USE_ASYNC_DBUS_CALLS
3126 
3127 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3128  printf("[network-manager comm debug] received DBUS object structure map follows:\n"); fflush(stdout);
3129  printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSecretsMap));
3130 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3131 
3132  // Parse settings
3133  TQT_DBusTQStringDataMap::const_iterator it2;
3134  for (it2 = connectionSecretsMap.begin(); it2 != connectionSecretsMap.end(); ++it2) {
3135  TQString outerKeyValue = it2.key();
3136  TQT_DBusData dataValue = it2.data();
3137 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3138  printf("[network-manager comm debug] [%s]\n", outerKeyValue.ascii()); fflush(stdout);
3139 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3140  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue.toStringKeyMap();
3141  TQT_DBusTQStringDataMap::const_iterator it3;
3142  for (it3 = nestedConnectionSettingsMap.begin(); it3 != nestedConnectionSettingsMap.end(); ++it3) {
3143  TQString keyValue = it3.key();
3144  TQT_DBusData dataValue = it3.data();
3145  if (dataValue.type() != TQT_DBusData::Variant) {
3146 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3147  printf("[network-manager comm debug] %s = %s (type %d(%s))\n", keyValue.ascii(), dataValue.toString().ascii(), dataValue.type(), dataValue.typeName()); fflush(stdout);
3148 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3149  // No NM settings are known which use this style
3150  }
3151  else {
3152  TQT_DBusVariant dataValueVariant = dataValue.toVariant();
3153  TQT_DBusData dataValue2 = dataValueVariant.value;
3154  if (dataValue2.type() != TQT_DBusData::Variant) {
3155 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3156  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);
3157 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
3158  // Most NM settings use this style
3159  if (outerKeyValue.lower() == "802-1x") {
3160  if (keyValue.lower() == "password") {
3161  connection->eapConfig.password = dataValue2.toString();
3162  }
3163  else if (keyValue.lower() == "password-raw") {
3164  TQT_DBusDataValueList valueList = dataValue2.toTQValueList();
3165  TQT_DBusDataValueList::const_iterator it4;
3166  int count=0;
3167  for (it4 = valueList.begin(); it4 != valueList.end(); ++it4) {
3168  TQT_DBusData innerDataValue = *it4;
3169  count++;
3170  connection->eapConfig.binaryPassword.resize(count+1);
3171  connection->eapConfig.binaryPassword[count] = innerDataValue.toByte();
3172  }
3173  }
3174  else if (keyValue.lower() == "private-key-password") {
3175  connection->eapConfig.privateKeyPassword = dataValue2.toString();
3176  }
3177  else if (keyValue.lower() == "phase2-private-key-password") {
3178  connection->eapConfig.phase2PrivateKeyPassword = dataValue2.toString();
3179  }
3180  connection->eapConfig.secretsValid = true;
3181  }
3182  if ((outerKeyValue.lower() == "802-11-wireless-security") && (wiFiConnection)) {
3183  if (keyValue.lower() == "wep-key0") {
3184  wiFiConnection->securitySettings.wepKey0 = dataValue2.toString();
3185  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey0);
3186  }
3187  else if (keyValue.lower() == "wep-key1") {
3188  wiFiConnection->securitySettings.wepKey1 = dataValue2.toString();
3189  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey1);
3190  }
3191  else if (keyValue.lower() == "wep-key2") {
3192  wiFiConnection->securitySettings.wepKey2 = dataValue2.toString();
3193  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey2);
3194  }
3195  else if (keyValue.lower() == "wep-key3") {
3196  wiFiConnection->securitySettings.wepKey3 = dataValue2.toString();
3197  wiFiConnection->securitySettings.wepKeyType = nmWepKeyTypeToTDEWepKeyType(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType), wiFiConnection->securitySettings.wepKey3);
3198  }
3199  else if (keyValue.lower() == "psk") {
3200  wiFiConnection->securitySettings.psk = dataValue2.toString();
3201  }
3202  else if (keyValue.lower() == "eap-password") {
3203  wiFiConnection->securitySettings.leapPassword = dataValue2.toString();
3204  }
3205  }
3206  if ((outerKeyValue.lower() == "vpn") && (vpnConnection)) {
3207  if (keyValue.lower() == "secrets") {
3208  TQT_DBusTQStringDataMap nestedConnectionSettingsMap = dataValue2.toStringKeyMap();
3209  TQT_DBusTQStringDataMap::const_iterator it4;
3210  for (it4 = nestedConnectionSettingsMap.begin(); it4 != nestedConnectionSettingsMap.end(); ++it4) {
3211  vpnConnection->pluginSecrets.clear();
3212  TQString keyValue4 = it4.key();
3213  TQT_DBusData dataValue4 = it4.data();
3214  if (dataValue4.type() == TQT_DBusData::String) {
3215  vpnConnection->pluginSecrets[keyValue4] = dataValue4.toString();
3216  }
3217  }
3218  vpnConnection->secretsValid = true;
3219  }
3220  }
3221  if (outerKeyValue.lower() == "pppoe") {
3222  if (keyValue.lower() == "password") {
3223  connection->pppoeConfig.password = dataValue2.toString();
3224  }
3225  connection->pppoeConfig.secretsValid = true;
3226  }
3227  if (outerKeyValue.lower() == "cdma") {
3228  if (keyValue.lower() == "password") {
3229  modemConnection->cdmaConfig.password = dataValue2.toString();
3230  }
3231  modemConnection->cdmaConfig.secretsValid = true;
3232  }
3233  if (outerKeyValue.lower() == "gsm") {
3234  if (keyValue.lower() == "password") {
3235  modemConnection->gsmConfig.password = dataValue2.toString();
3236  }
3237  else if (keyValue.lower() == "pin") {
3238  modemConnection->gsmConfig.pin = dataValue2.toString();
3239  }
3240  modemConnection->gsmConfig.secretsValid = true;
3241  }
3242  }
3243  }
3244  }
3245  }
3246  return TRUE;
3247  }
3248  else {
3249  PRINT_ERROR(TQString("Unable to load secrets for connection with uuid '%1'").arg(uuid))
3250  return FALSE;
3251  }
3252  }
3253  else {
3254  PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
3255  return FALSE;
3256  }
3257 }
3258 
3259 bool TDENetworkConnectionManager_BackendNM::saveConnection(TDENetworkConnection* connection) {
3260  bool timed_out = FALSE;
3261  bool command_failed = FALSE;
3262 
3263  if (!connection) {
3264  PRINT_ERROR(TQString("connection cannot be NULL!"));
3265  return FALSE;
3266  }
3267 
3268  // If the UUID is blank, generate a new UUID for this connection and also guarantee that it it truly unique
3269  if (connection->UUID == "") {
3270  bool unique = false;
3271  while (!unique) {
3272  connection->UUID = TQUuid::createUuid().toString();
3273  connection->UUID.replace("{", "");
3274  connection->UUID.replace("}", "");
3275  if (!findConnectionByUUID(connection->UUID)) {
3276  unique = true;
3277  }
3278  }
3279  }
3280 
3281  // Find path for connection with specified UUID, if it exists
3282  // This is so that any settings that we are not aware of can be loaded now and preserved through the update operation
3283  TDEWiredEthernetConnection* ethernetConnection = dynamic_cast<TDEWiredEthernetConnection*>(connection);
3284  TDEWiredInfinibandConnection* infinibandConnection = dynamic_cast<TDEWiredInfinibandConnection*>(connection);
3285  TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
3286  TDEVPNConnection* vpnConnection = dynamic_cast<TDEVPNConnection*>(connection);
3287  TDEWiMaxConnection* wiMaxConnection = dynamic_cast<TDEWiMaxConnection*>(connection);
3288  TDEVLANConnection* vlanConnection = dynamic_cast<TDEVLANConnection*>(connection);
3289  TDEOLPCMeshConnection* olpcMeshConnection = dynamic_cast<TDEOLPCMeshConnection*>(connection);
3290  TDEBluetoothConnection* bluetoothConnection = dynamic_cast<TDEBluetoothConnection*>(connection);
3291  TDEModemConnection* modemConnection = dynamic_cast<TDEModemConnection*>(connection);
3292  TQT_DBusObjectPath existingConnection;
3293  TQT_DBusError error;
3294  bool ret;
3295  bool existing;
3296  TQT_DBusTQStringDataMap connectionSettingsMap(TQT_DBusData::String);
3297  existing = false;
3298  ret = d->m_networkManagerSettings->GetConnectionByUuid(connection->UUID, existingConnection, error);
3299  if (ret) {
3300 #ifndef USE_ASYNC_DBUS_CALLS
3301  // Obtain connection settings from the path specified
3302  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
3303  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
3304  ret = connectionSettings.GetSettings(connectionSettingsMap, error);
3305  if (ret && error.isValid()) {
3306  ret = 0;
3307  PRINT_ERROR((error.name() + ": " + error.message()))
3308  }
3309  if (ret) {
3310 #else // USE_ASYNC_DBUS_CALLS
3311  // Obtain connection settings from the path specified
3312  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
3313  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
3314  connect(&connectionSettings, SIGNAL(GetSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)), d, SLOT(processConnectionSettingsAsyncReply(int, const TQT_DBusDataMap<TQString>&)));
3315  int asyncCallID;
3316  ret = connectionSettings.GetSettingsAsync(asyncCallID, error);
3317  if (ret && error.isValid()) {
3318  ret = 0;
3319  PRINT_ERROR((error.name() + ": " + error.message()))
3320  }
3321  if (ret) {
3322  // Wait for the asynchronous call to return...
3323  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
3324  TQTimer nmCallTimeoutTimer;
3325  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
3326  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
3327  tqApp->processEvents();
3328  if (!nmCallTimeoutTimer.isActive()) {
3329  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
3330  timed_out = true;
3331  break;
3332  }
3333  }
3334  connectionSettingsMap = d->nmConnectionSettingsAsyncSettingsResponse[asyncCallID];
3335  if (d->nmConnectionSettingsAsyncSettingsErrorResponse.contains(asyncCallID)) {
3336  PRINT_ERROR((d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].name() + ": " + d->nmConnectionSettingsAsyncSettingsErrorResponse[asyncCallID].message()));
3337  d->nmConnectionSettingsAsyncSettingsErrorResponse.remove(asyncCallID);
3338  }
3339  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
3340  if (d->nmConnectionSettingsAsyncSettingsResponse.contains(asyncCallID)) {
3341  d->nmConnectionSettingsAsyncSettingsResponse.remove(asyncCallID);
3342  }
3343 #endif // USE_ASYNC_DBUS_CALLS
3344  existing = true;
3345  }
3346  }
3347 
3348  // Create and/or update settings map from provided connection information
3349  // We start at the outermost layer and work our way inwards, in a structure which should match the parser in loadConnectionInformation() very closely
3350  bool groupValid;
3351  TQT_DBusData dbusData;
3352  TQT_DBusData innerDbusData;
3353  TQMap<TQString, TQT_DBusData> outerMap = connectionSettingsMap.toTQMap();
3354  {
3355  groupValid = false;
3356  dbusData = outerMap["connection"];
3357  {
3358  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3359  {
3360  settingsMap["id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->friendlyName));
3361  {
3362  TQString type;
3363  if (ethernetConnection) type = "802-3-ethernet";
3364  else if (infinibandConnection) type = "infiniband";
3365  else if (wiFiConnection) type = "802-11-wireless";
3366  else if (vpnConnection) type = "vpn";
3367  else if (wiMaxConnection) type = "wimax";
3368  else if (vlanConnection) type = "vlan";
3369  else if (olpcMeshConnection) type = "802-11-olpc-mesh";
3370  else if (bluetoothConnection) type = "bluetooth";
3371  else if (modemConnection) {
3372  if (modemConnection->type == TDEModemConnectionType::CDMA) {
3373  type = "cdma";
3374  }
3375  else if (modemConnection->type == TDEModemConnectionType::GSM) {
3376  type = "gsm";
3377  }
3378  }
3379  if (!type.isNull()) settingsMap["type"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(type));
3380  }
3381  settingsMap["uuid"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->UUID));
3382  {
3383  TQT_DBusDataValueList valueList;
3384  {
3385  for (TQStringList::Iterator it = connection->authorizedUsers.begin(); it != connection->authorizedUsers.end(); ++it) {
3386  TQString assembledString = TQString("user:%1:").arg(*it);
3387  valueList.append(TQT_DBusData::fromString(assembledString));
3388  }
3389  }
3390  if (valueList.count() > 0) settingsMap["permissions"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3391  else settingsMap.remove("permissions");
3392  }
3393  settingsMap["autoconnect"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->autoConnect));
3394  settingsMap["read-only"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->readOnly));
3395  UPDATE_STRING_SETTING_IF_VALID(connection->masterConnectionUUID, "master", settingsMap)
3396  {
3397  TQString slaveType = tdeSlaveTypeToNMSlaveType(connection->slaveType);
3398  if (slaveType != "") settingsMap["slave-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(slaveType));
3399  else settingsMap.remove("slave-type");
3400  }
3401  // settingsMap["timestamp"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt64(connection->lastKnownConnection.toTime_t())); // Probably read-only to us
3402  }
3403  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3404  groupValid = (settingsMap.count() > 0);
3405  }
3406  if (groupValid) outerMap.insert("connection", dbusData, TRUE); else outerMap.remove("connection");
3407 
3408  groupValid = false;
3409  dbusData = outerMap["802-1x"];
3410  {
3411  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3412  {
3413  if (connection->eapConfig.valid) {
3414  TQT_DBusDataValueList valueList;
3415  {
3416  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
3417  // EAP type
3418  valueList.append(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.type)));
3419  }
3420  settingsMap["eap"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3421  }
3422  else {
3423  settingsMap.remove("eap");
3424  }
3425  if (connection->eapConfig.valid) {
3426  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.userName, "identity", settingsMap)
3427  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.anonymousUserName, "anonymous-identity", settingsMap)
3428  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.pacFileName, "pac-file", settingsMap)
3429  }
3430  else {
3431  settingsMap.remove("identity");
3432  settingsMap.remove("anonymous-identity");
3433  settingsMap.remove("pac-file");
3434  }
3435  if (connection->eapConfig.valid) {
3436  TQT_DBusDataValueList valueList;
3437  {
3438  unsigned int count;
3439  for (count=0; count<connection->eapConfig.caCertificate.count(); count++) {
3440  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.caCertificate[count]));
3441  }
3442  }
3443  if (valueList.count() > 0) settingsMap["ca-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3444  else settingsMap.remove("ca-cert");
3445  }
3446  else {
3447  settingsMap.remove("ca-cert");
3448  }
3449  if (connection->eapConfig.valid) {
3450  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.additionalCAFilesPath, "ca-path", settingsMap)
3451  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.authServerCertSubjectMatch, "subject-match", settingsMap)
3452  }
3453  else {
3454  settingsMap.remove("ca-path");
3455  settingsMap.remove("subject-match");
3456  }
3457  if (connection->eapConfig.valid) {
3458  TQT_DBusDataValueList valueList;
3459  {
3460  for (TQStringList::Iterator it = connection->eapConfig.alternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.alternateAuthServerCertSubjectMatch.end(); ++it) {
3461  valueList.append(TQT_DBusData::fromString(*it));
3462  }
3463  }
3464  if (valueList.count() > 0) settingsMap["altsubject-matches"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3465  else settingsMap.remove("altsubject-matches");
3466  }
3467  else {
3468  settingsMap.remove("altsubject-matches");
3469  }
3470  if (connection->eapConfig.valid) {
3471  TQT_DBusDataValueList valueList;
3472  {
3473  unsigned int count;
3474  for (count=0; count<connection->eapConfig.clientCertificate.count(); count++) {
3475  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.clientCertificate[count]));
3476  }
3477  }
3478  if (valueList.count() > 0) settingsMap["client-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3479  else settingsMap.remove("client-cert");
3480  }
3481  else {
3482  settingsMap.remove("client-cert");
3483  }
3484  if (connection->eapConfig.valid) {
3485  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPVersion, "phase1-peapver", settingsMap)
3486  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.forcePEAPLabel, "phase1-peaplabel", settingsMap)
3487  UPDATE_STRING_SETTING_IF_VALID(tdeEAPFastFlagsToNMEAPFastFlags(connection->eapConfig.fastProvisioningFlags), "phase1-fast-provisioning", settingsMap)
3488  }
3489  else {
3490  settingsMap.remove("phase1-peapver");
3491  settingsMap.remove("phase1-peaplabel");
3492  settingsMap.remove("phase1-fast-provisioning");
3493  }
3494  if (connection->eapConfig.valid) {
3495  settingsMap["phase2-auth"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2NonEAPAuthMethod)));
3496  settingsMap["phase2-autheap"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeEAPTypeToNMEAPType(connection->eapConfig.phase2EAPAuthMethod)));
3497  }
3498  else {
3499  settingsMap.remove("phase2-auth");
3500  settingsMap.remove("phase2-autheap");
3501  }
3502  if (connection->eapConfig.valid) {
3503  TQT_DBusDataValueList valueList;
3504  {
3505  unsigned int count;
3506  for (count=0; count<connection->eapConfig.phase2CaCertificate.count(); count++) {
3507  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2CaCertificate[count]));
3508  }
3509  }
3510  if (valueList.count() > 0) settingsMap["phase2-ca-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3511  else settingsMap.remove("phase2-ca-cert");
3512  }
3513  else {
3514  settingsMap.remove("phase2-ca-cert");
3515  }
3516  if (connection->eapConfig.valid) {
3517  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2CaFilesPath, "phase2-ca-path", settingsMap)
3518  UPDATE_STRING_SETTING_IF_VALID(connection->eapConfig.phase2AuthServerCertSubjectMatch, "phase2-subject-match", settingsMap)
3519  }
3520  else {
3521  settingsMap.remove("phase2-ca-path");
3522  settingsMap.remove("phase2-subject-match");
3523  }
3524  if (connection->eapConfig.valid) {
3525  TQT_DBusDataValueList valueList;
3526  {
3527  for (TQStringList::Iterator it = connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.begin(); it != connection->eapConfig.phase2AlternateAuthServerCertSubjectMatch.end(); ++it) {
3528  valueList.append(TQT_DBusData::fromString(*it));
3529  }
3530  }
3531  if (valueList.count() > 0) settingsMap["phase2-altsubject-matches"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3532  else settingsMap.remove("phase2-altsubject-matches");
3533  }
3534  else {
3535  settingsMap.remove("phase2-altsubject-matches");
3536  }
3537  if (connection->eapConfig.valid) {
3538  TQT_DBusDataValueList valueList;
3539  {
3540  unsigned int count;
3541  for (count=0; count<connection->eapConfig.phase2ClientCertificate.count(); count++) {
3542  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2ClientCertificate[count]));
3543  }
3544  }
3545  if (valueList.count() > 0) settingsMap["phase2-client-cert"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3546  else settingsMap.remove("phase2-client-cert");
3547  }
3548  else {
3549  settingsMap.remove("phase2-client-cert");
3550  }
3551  if (connection->eapConfig.valid) {
3552  settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.passwordFlags)));
3553  settingsMap["password-raw-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.binaryPasswordFlags)));
3554  }
3555  else {
3556  settingsMap.remove("password-flags");
3557  settingsMap.remove("password-raw-flags");
3558  }
3559  if (connection->eapConfig.valid) {
3560  TQT_DBusDataValueList valueList;
3561  {
3562  unsigned int count;
3563  for (count=0; count<connection->eapConfig.privateKey.count(); count++) {
3564  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.privateKey[count]));
3565  }
3566  }
3567  if (valueList.count() > 0) settingsMap["private-key"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3568  else settingsMap.remove("private-key");
3569  }
3570  else {
3571  settingsMap.remove("private-key");
3572  }
3573  if (connection->eapConfig.valid) {
3574  settingsMap["private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.privateKeyPasswordFlags)));
3575  }
3576  else {
3577  settingsMap.remove("private-key-password-flags");
3578  }
3579  if (connection->eapConfig.valid) {
3580  TQT_DBusDataValueList valueList;
3581  {
3582  unsigned int count;
3583  for (count=0; count<connection->eapConfig.phase2PrivateKey.count(); count++) {
3584  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.phase2PrivateKey[count]));
3585  }
3586  }
3587  if (valueList.count() > 0) settingsMap["phase2-private-key"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3588  else settingsMap.remove("phase2-private-key");
3589  }
3590  else {
3591  settingsMap.remove("phase2-private-key");
3592  }
3593  if (connection->eapConfig.valid) {
3594  settingsMap["phase2-private-key-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->eapConfig.phase2PrivateKeyPasswordFlags)));
3595  }
3596  else {
3597  settingsMap.remove("phase2-private-key-password-flags");
3598  }
3599  if (connection->eapConfig.valid) {
3600  settingsMap["system-ca-certs"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->eapConfig.forceSystemCaCertificates));
3601  }
3602  else {
3603  settingsMap.remove("system-ca-certs");
3604  }
3605  if (connection->eapConfig.secretsValid) {
3606  settingsMap["password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.password));
3607  }
3608  else {
3609  settingsMap.remove("password");
3610  }
3611  if (connection->eapConfig.valid) {
3612  TQT_DBusDataValueList valueList;
3613  {
3614  unsigned int count;
3615  for (count=0; count<connection->eapConfig.binaryPassword.count(); count++) {
3616  valueList.append(TQT_DBusData::fromByte(connection->eapConfig.binaryPassword[count]));
3617  }
3618  }
3619  if (valueList.count() > 0) settingsMap["password-raw"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3620  else settingsMap.remove("password-raw");
3621  }
3622  else {
3623  settingsMap.remove("password-raw");
3624  }
3625  if (connection->eapConfig.secretsValid) {
3626  settingsMap["private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.privateKeyPassword));
3627  settingsMap["phase2-private-key-password"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->eapConfig.phase2PrivateKeyPassword));
3628  }
3629  else {
3630  settingsMap.remove("private-key-password");
3631  settingsMap.remove("phase2-private-key-password");
3632  }
3633  }
3634  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3635  groupValid = (settingsMap.count() > 0);
3636  }
3637  if (groupValid) outerMap.insert("802-1x", dbusData, TRUE); else outerMap.remove("802-1x");
3638 
3639  groupValid = false;
3640  dbusData = outerMap["802-3-ethernet"];
3641  if (ethernetConnection) {
3642  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3643  {
3644  settingsMap["duplex"] = convertDBUSDataToVariantData(TQT_DBusData::fromString((connection->fullDuplex)?"full":"half"));
3645  if (connection->lockedHWAddress.isValid()) {
3646  TDENetworkByteList address = connection->lockedHWAddress.address();
3647  TQT_DBusDataValueList valueList;
3648  TDENetworkByteList::iterator it;
3649  for (it = address.begin(); it != address.end(); ++it) {
3650  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3651  valueList.append(innerDataValue);
3652  }
3653  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3654  settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3655  }
3656  else {
3657  settingsMap.remove("mac-address");
3658  }
3659  if (connection->manualHWAddress.isValid()) {
3660  TDENetworkByteList address = connection->manualHWAddress.address();
3661  TQT_DBusDataValueList valueList;
3662  TDENetworkByteList::iterator it;
3663  for (it = address.begin(); it != address.end(); ++it) {
3664  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3665  valueList.append(innerDataValue);
3666  }
3667  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3668  settingsMap["cloned-mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3669  }
3670  else {
3671  settingsMap.remove("cloned-mac-address");
3672  }
3673  if (connection->mtu > 0) {
3674  settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
3675  }
3676  else {
3677  settingsMap.remove("mtu");
3678  }
3679  }
3680  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3681  groupValid = (settingsMap.count() > 0);
3682  }
3683  if (groupValid) outerMap.insert("802-3-ethernet", dbusData, TRUE); else outerMap.remove("802-3-ethernet");
3684 
3685  groupValid = false;
3686  dbusData = outerMap["infiniband"];
3687  if (infinibandConnection) {
3688  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3689  {
3690  if (connection->lockedHWAddress.isValid()) {
3691  TDENetworkByteList address = connection->lockedHWAddress.address();
3692  TQT_DBusDataValueList valueList;
3693  TDENetworkByteList::iterator it;
3694  for (it = address.begin(); it != address.end(); ++it) {
3695  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3696  valueList.append(innerDataValue);
3697  }
3698  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3699  settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3700  }
3701  else {
3702  settingsMap.remove("mac-address");
3703  }
3704  if (connection->mtu > 0) {
3705  settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
3706  }
3707  else {
3708  settingsMap.remove("mtu");
3709  }
3710  UPDATE_STRING_SETTING_IF_VALID(tdeIBTransportToNMIBTransport(infinibandConnection->transportMode), "transport-mode", settingsMap)
3711  }
3712  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3713  groupValid = (settingsMap.count() > 0);
3714  }
3715  if (groupValid) outerMap.insert("infiniband", dbusData, TRUE); else outerMap.remove("infiniband");
3716 
3717  groupValid = false;
3718  dbusData = outerMap["802-11-wireless"];
3719  if (wiFiConnection) {
3720  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3721  {
3722  {
3723  unsigned int i;
3724  TQT_DBusDataValueList valueList;
3725  for (i=0; i<wiFiConnection->SSID.count(); i++) {
3726  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(wiFiConnection->SSID[i]);
3727  valueList.append(innerDataValue);
3728  }
3729  settingsMap["ssid"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3730  }
3731  if (connection->lockedHWAddress.isValid()) {
3732  TDENetworkByteList address = connection->lockedHWAddress.address();
3733  TQT_DBusDataValueList valueList;
3734  TDENetworkByteList::iterator it;
3735  for (it = address.begin(); it != address.end(); ++it) {
3736  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3737  valueList.append(innerDataValue);
3738  }
3739  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3740  settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3741  }
3742  else {
3743  settingsMap.remove("mac-address");
3744  }
3745  if (connection->manualHWAddress.isValid()) {
3746  TDENetworkByteList address = connection->manualHWAddress.address();
3747  TQT_DBusDataValueList valueList;
3748  TDENetworkByteList::iterator it;
3749  for (it = address.begin(); it != address.end(); ++it) {
3750  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3751  valueList.append(innerDataValue);
3752  }
3753  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3754  settingsMap["cloned-mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3755  }
3756  else {
3757  settingsMap.remove("cloned-mac-address");
3758  }
3759  if (connection->mtu > 0) {
3760  settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->mtu));
3761  }
3762  else {
3763  settingsMap.remove("mtu");
3764  }
3765  UPDATE_STRING_SETTING_IF_VALID(tdeWiFiModeToNMWiFiMode(wiFiConnection->operatingMode), "mode", settingsMap)
3766  UPDATE_STRING_SETTING_IF_VALID(tdeWiFiFrequencyBandToNMWiFiFrequencyBand(wiFiConnection->bandRestriction), "band", settingsMap)
3767  if (wiFiConnection->channelRestriction > 0) {
3768  settingsMap["channel"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->channelRestriction));
3769  }
3770  else {
3771  settingsMap.remove("channel");
3772  }
3773  if (wiFiConnection->bitRateRestriction > 0) {
3774  settingsMap["rate"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->bitRateRestriction/1000));
3775  }
3776  else {
3777  settingsMap.remove("rate");
3778  }
3779  if (wiFiConnection->powerRestriction > 0) {
3780  settingsMap["tx-power"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->powerRestriction));
3781  }
3782  else {
3783  settingsMap.remove("tx-power");
3784  }
3785  if (wiFiConnection->accessPointRestriction.isValid()) {
3786  TDENetworkByteList address = wiFiConnection->accessPointRestriction.address();
3787  TQT_DBusDataValueList valueList;
3788  TDENetworkByteList::iterator it;
3789  for (it = address.begin(); it != address.end(); ++it) {
3790  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3791  valueList.append(innerDataValue);
3792  }
3793  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3794  settingsMap["bssid"] = convertDBUSDataToVariantData(nmHWAddress);
3795  }
3796  else {
3797  settingsMap.remove("bssid");
3798  }
3799  {
3800  TQT_DBusDataValueList valueList;
3801  TDEMACAddressList::iterator it;
3802  for (it = wiFiConnection->blacklistedBSSIDs.begin(); it != wiFiConnection->blacklistedBSSIDs.end(); ++it) {
3803  valueList.append(TQT_DBusData::fromString((*it).toString()));
3804  }
3805  if (valueList.count() > 0) settingsMap["mac-address-blacklist"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3806  }
3807  {
3808  TQT_DBusDataValueList valueList;
3809  TDEMACAddressList::iterator it;
3810  for (it = wiFiConnection->heardBSSIDs.begin(); it != wiFiConnection->heardBSSIDs.end(); ++it) {
3811  valueList.append(TQT_DBusData::fromString((*it).toString()));
3812  }
3813  if (valueList.count() > 0) settingsMap["seen-bssids"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3814  }
3815  {
3816  if (wiFiConnection->securityRequired) {
3817  settingsMap["security"] = convertDBUSDataToVariantData(TQT_DBusData::fromString("802-11-wireless-security"));
3818  }
3819  else {
3820  settingsMap.remove("security");
3821  }
3822  }
3823  {
3824  if (wiFiConnection->isHiddenNetwork) {
3825  settingsMap["hidden"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(true));
3826  }
3827  else {
3828  settingsMap.remove("hidden");
3829  }
3830  }
3831  }
3832  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3833  groupValid = (settingsMap.count() > 0);
3834  }
3835  if (groupValid) outerMap.insert("802-11-wireless", dbusData, TRUE); else outerMap.remove("802-11-wireless");
3836 
3837  groupValid = false;
3838  dbusData = outerMap["802-11-wireless-security"];
3839  if (wiFiConnection) {
3840  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3841  {
3842  if (wiFiConnection->securityRequired) {
3843  if (wiFiConnection->securityRequired) {
3844  settingsMap["key-mgmt"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(tdeWiFiKeyTypeToNMWiFiKeyType(wiFiConnection->securitySettings.keyType)));
3845  }
3846  if (wiFiConnection->securitySettings.wepKeyIndex > 0) {
3847  settingsMap["wep-tx-keyidx"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(wiFiConnection->securitySettings.wepKeyIndex));
3848  }
3849  else {
3850  settingsMap.remove("wep-tx-keyidx");
3851  }
3852  UPDATE_STRING_SETTING_IF_VALID(tdeWiFiAuthTypeToNMWiFiAuthType(wiFiConnection->securitySettings.authType), "auth-alg", settingsMap)
3853  {
3854  TQT_DBusDataValueList valueList;
3855  {
3856  TQStringList strings = tdeWiFiWPAVersionToNMWiFiWPAVersion(wiFiConnection->securitySettings.wpaVersion);
3857  for (TQStringList::Iterator it = strings.begin(); it != strings.end(); ++it) {
3858  valueList.append(TQT_DBusData::fromString(*it));
3859  }
3860  }
3861  if (valueList.count() > 0) settingsMap["proto"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3862  else settingsMap.remove("proto");
3863  }
3864  {
3865  TQT_DBusDataValueList valueList;
3866  {
3867  if (wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
3868  if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
3869  if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
3870  if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
3871  if (!wiFiConnection->securitySettings.allowedPairWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedPairWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
3872  }
3873  for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedPairWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedPairWiseCiphers.end(); ++it) {
3874  valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
3875  }
3876  }
3877  if (valueList.count() > 0) settingsMap["pairwise"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3878  else settingsMap.remove("pairwise");
3879  }
3880  {
3881  TQT_DBusDataValueList valueList;
3882  {
3883  if (wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::Any)) {
3884  if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP40)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP40);
3885  if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherWEP104)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherWEP104);
3886  if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherTKIP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherTKIP);
3887  if (!wiFiConnection->securitySettings.allowedGroupWiseCiphers.contains(TDENetworkWiFiConnectionCipher::CipherCCMP)) wiFiConnection->securitySettings.allowedGroupWiseCiphers.append(TDENetworkWiFiConnectionCipher::CipherCCMP);
3888  }
3889  for (TDENetworkWiFiConnectionCipherList::Iterator it = wiFiConnection->securitySettings.allowedGroupWiseCiphers.begin(); it != wiFiConnection->securitySettings.allowedGroupWiseCiphers.end(); ++it) {
3890  valueList.append(TQT_DBusData::fromString(tdeWiFiCipherToNMWiFiCipher(*it)));
3891  }
3892  }
3893  if (valueList.count() > 0) settingsMap["group"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
3894  else settingsMap.remove("group");
3895  }
3896  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapUsername, "leap-username", settingsMap)
3897  settingsMap["wep-key-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.wepKeyFlags)));
3898  settingsMap["wep-key-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdeWepKeyTypeToNMWepKeyType(wiFiConnection->securitySettings.wepKeyType)));
3899  settingsMap["psk-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.pskFlags)));
3900  settingsMap["leap-password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(wiFiConnection->securitySettings.leapPasswordFlags)));
3901  if (wiFiConnection->securitySettings.secretsValid) {
3902  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey0, "wep-key0", settingsMap)
3903  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey1, "wep-key1", settingsMap)
3904  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey2, "wep-key2", settingsMap)
3905  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.wepKey3, "wep-key3", settingsMap)
3906  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.psk, "psk", settingsMap)
3907  UPDATE_STRING_SETTING_IF_VALID(wiFiConnection->securitySettings.leapPassword, "leap-password", settingsMap)
3908  }
3909  else {
3910  settingsMap.remove("wep-key0");
3911  settingsMap.remove("wep-key1");
3912  settingsMap.remove("wep-key2");
3913  settingsMap.remove("wep-key3");
3914  settingsMap.remove("psk");
3915  settingsMap.remove("leap-password");
3916  }
3917  }
3918  else {
3919  settingsMap.remove("key-mgmt");
3920  settingsMap.remove("wep-tx-keyidx");
3921  settingsMap.remove("auth-alg");
3922  settingsMap.remove("proto");
3923  settingsMap.remove("pairwise");
3924  settingsMap.remove("group");
3925  settingsMap.remove("leap-username");
3926  settingsMap.remove("wep-key-flags");
3927  settingsMap.remove("wep-key-type");
3928  settingsMap.remove("psk-flags");
3929  settingsMap.remove("leap-password-flags");
3930  settingsMap.remove("wep-key0");
3931  settingsMap.remove("wep-key1");
3932  settingsMap.remove("wep-key2");
3933  settingsMap.remove("wep-key3");
3934  settingsMap.remove("psk");
3935  settingsMap.remove("leap-password");
3936  }
3937  }
3938  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3939  groupValid = (settingsMap.count() > 0);
3940  }
3941  if (groupValid) outerMap.insert("802-11-wireless-security", dbusData, TRUE); else outerMap.remove("802-11-wireless-security");
3942 
3943  groupValid = false;
3944  dbusData = outerMap["vpn"];
3945  if (vpnConnection) {
3946  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3947  {
3948  {
3949  TQString pluginService = vpnConnection->vpnPluginID;
3950  if (pluginService != "") {
3951  pluginService = "org.freedesktop.NetworkManager." + pluginService;
3952  }
3953  UPDATE_STRING_SETTING_IF_VALID(pluginService, "service-type", settingsMap)
3954  }
3955  UPDATE_STRING_SETTING_IF_VALID(vpnConnection->lockedUserName, "user-name", settingsMap)
3956  {
3957  TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
3958  TDENetworkSettingsMap::const_iterator it;
3959  for (it = vpnConnection->pluginData.begin(); it != vpnConnection->pluginData.end(); ++it) {
3960  nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
3961  }
3962  if (nestedConnectionSettingsMap.count() > 0) settingsMap["data"] = convertDBUSDataToVariantData(TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap)));
3963  else settingsMap.remove("data");
3964  }
3965  if (vpnConnection->secretsValid) {
3966  TQMap<TQString, TQT_DBusData> nestedConnectionSettingsMap;
3967  TDENetworkSettingsMap::const_iterator it;
3968  for (it = vpnConnection->pluginSecrets.begin(); it != vpnConnection->pluginSecrets.end(); ++it) {
3969  nestedConnectionSettingsMap[it.key()] = TQT_DBusData::fromString(it.data());
3970  }
3971  if (nestedConnectionSettingsMap.count() > 0) settingsMap["secrets"] = convertDBUSDataToVariantData(TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(nestedConnectionSettingsMap)));
3972  else settingsMap.remove("secrets");
3973  }
3974  }
3975  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
3976  groupValid = (settingsMap.count() > 0);
3977  }
3978  if (groupValid) outerMap.insert("vpn", dbusData, TRUE); else outerMap.remove("vpn");
3979 
3980  groupValid = false;
3981  dbusData = outerMap["wimax"];
3982  if (wiMaxConnection) {
3983  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
3984  {
3985  if (connection->lockedHWAddress.isValid()) {
3986  TDENetworkByteList address = connection->lockedHWAddress.address();
3987  TQT_DBusDataValueList valueList;
3988  TDENetworkByteList::iterator it;
3989  for (it = address.begin(); it != address.end(); ++it) {
3990  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
3991  valueList.append(innerDataValue);
3992  }
3993  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
3994  settingsMap["mac-address"] = convertDBUSDataToVariantData(nmHWAddress);
3995  }
3996  else {
3997  settingsMap.remove("mac-address");
3998  }
3999  UPDATE_STRING_SETTING_IF_VALID(wiMaxConnection->networkServiceProvider, "network-name", settingsMap)
4000  }
4001  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4002  groupValid = (settingsMap.count() > 0);
4003  }
4004  if (groupValid) outerMap.insert("wimax", dbusData, TRUE); else outerMap.remove("wimax");
4005 
4006  groupValid = false;
4007  dbusData = outerMap["vlan"];
4008  if (vlanConnection) {
4009  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4010  {
4011  UPDATE_STRING_SETTING_IF_VALID(vlanConnection->kernelName, "interface-name", settingsMap)
4012  UPDATE_STRING_SETTING_IF_VALID(vlanConnection->parentConnectionUUID, "parent", settingsMap)
4013  settingsMap["id"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(vlanConnection->vlanID));
4014  settingsMap["flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdeVLANFlagsToNMVLANFlags(vlanConnection->vlanFlags)));
4015  {
4016  TQT_DBusDataValueList valueList;
4017  TDENetworkPriorityMap::const_iterator it;
4018  for (it = vlanConnection->ingressPriorityMap.begin(); it != vlanConnection->ingressPriorityMap.end(); ++it) {
4019  valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
4020  }
4021  if (valueList.count() > 0) settingsMap["ingress-priority-map"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4022  }
4023  {
4024  TQT_DBusDataValueList valueList;
4025  TDENetworkPriorityMap::const_iterator it;
4026  for (it = vlanConnection->egressPriorityMap.begin(); it != vlanConnection->egressPriorityMap.end(); ++it) {
4027  valueList.append(TQT_DBusData::fromString(TQString("%1:%2").arg(it.key()).arg(it.data())));
4028  }
4029  if (valueList.count() > 0) settingsMap["egress-priority-map"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4030  }
4031  }
4032  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4033  groupValid = (settingsMap.count() > 0);
4034  }
4035  if (groupValid) outerMap.insert("vlan", dbusData, TRUE); else outerMap.remove("vlan");
4036 
4037  groupValid = false;
4038  dbusData = outerMap["serial"];
4039  if (connection->serialConfig.valid) {
4040  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4041  {
4042  settingsMap["baud"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.baudRate));
4043  settingsMap["bits"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.byteWidth));
4044  settingsMap["parity"] = convertDBUSDataToVariantData(TQT_DBusData::fromByte(tdeParityToNMParity(connection->serialConfig.parity)));
4045  settingsMap["stopbits"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->serialConfig.stopBits));
4046  settingsMap["send-delay"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt64(connection->serialConfig.txDelay));
4047  }
4048  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4049  groupValid = (settingsMap.count() > 0);
4050  }
4051  if (groupValid) outerMap.insert("serial", dbusData, TRUE); else outerMap.remove("serial");
4052 
4053  groupValid = false;
4054  dbusData = outerMap["ppp"];
4055  if (connection->pppConfig.valid) {
4056  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4057  {
4058  settingsMap["noauth"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.requireServerAuthentication)));
4059  settingsMap["refuse-eap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableEAP));
4060  settingsMap["refuse-pap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisablePAP));
4061  settingsMap["refuse-chap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableCHAP));
4062  settingsMap["refuse-mschap"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAP));
4063  settingsMap["refuse-mschapv2"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::DisableMSCHAPv2));
4064  settingsMap["nobsdcomp"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowBSDCompression)));
4065  settingsMap["nodeflate"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowDeflateCompression)));
4066  settingsMap["no-vj-comp"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->pppConfig.flags & TDENetworkPPPFlags::AllowVJCompression)));
4067  settingsMap["require-mppe"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE));
4068  settingsMap["require-mppe-128"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::RequireMPPE128));
4069  settingsMap["mppe-stateful"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::StatefulMPPE));
4070  settingsMap["crtscts"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(connection->pppConfig.flags & TDENetworkPPPFlags::UseHardwareFlowControl));
4071  settingsMap["baud"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.baudRate));
4072  if (connection->pppConfig.mru > 0) {
4073  settingsMap["mru"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.mru));
4074  }
4075  else {
4076  settingsMap.remove("mru");
4077  }
4078  if (connection->pppConfig.mtu > 0) {
4079  settingsMap["mtu"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.mtu));
4080  }
4081  else {
4082  settingsMap.remove("mtu");
4083  }
4084  if (connection->pppConfig.mtu > 0) {
4085  settingsMap["lcp-echo-interval"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoPingInterval));
4086  }
4087  else {
4088  settingsMap.remove("lcp-echo-interval");
4089  }
4090  if (connection->pppConfig.mtu > 0) {
4091  settingsMap["lcp-echo-failure"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(connection->pppConfig.lcpEchoFailureThreshold));
4092  }
4093  else {
4094  settingsMap.remove("lcp-echo-failure");
4095  }
4096  }
4097  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4098  groupValid = (settingsMap.count() > 0);
4099  }
4100  if (groupValid) outerMap.insert("ppp", dbusData, TRUE); else outerMap.remove("ppp");
4101 
4102  groupValid = false;
4103  dbusData = outerMap["pppoe"];
4104  if (connection->pppoeConfig.valid) {
4105  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4106  {
4107  UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.networkServiceProvider, "service", settingsMap)
4108  UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.username, "username", settingsMap)
4109  if (connection->pppoeConfig.secretsValid) {
4110  UPDATE_STRING_SETTING_IF_VALID(connection->pppoeConfig.password, "password", settingsMap)
4111  }
4112  settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(connection->pppoeConfig.passwordFlags)));
4113  }
4114  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4115  groupValid = (settingsMap.count() > 0);
4116  }
4117  if (groupValid) outerMap.insert("pppoe", dbusData, TRUE); else outerMap.remove("pppoe");
4118 
4119  groupValid = false;
4120  dbusData = outerMap["802-11-olpc-mesh"];
4121  if (olpcMeshConnection) {
4122  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4123  {
4124  {
4125  unsigned int i;
4126  TQT_DBusDataValueList valueList;
4127  for (i=0; i<olpcMeshConnection->SSID.count(); i++) {
4128  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->SSID[i]);
4129  valueList.append(innerDataValue);
4130  }
4131  settingsMap["ssid"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4132  }
4133  settingsMap["channel"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(olpcMeshConnection->channel));
4134  {
4135  unsigned int i;
4136  TQT_DBusDataValueList valueList;
4137  for (i=0; i<olpcMeshConnection->anycastDHCPHWAddress.count(); i++) {
4138  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(olpcMeshConnection->anycastDHCPHWAddress[i]);
4139  valueList.append(innerDataValue);
4140  }
4141  settingsMap["dhcp-anycast-address"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4142  }
4143  }
4144  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4145  groupValid = (settingsMap.count() > 0);
4146  }
4147  if (groupValid) outerMap.insert("802-11-olpc-mesh", dbusData, TRUE); else outerMap.remove("802-11-olpc-mesh");
4148 
4149  groupValid = false;
4150  dbusData = outerMap["bluetooth"];
4151  if (bluetoothConnection) {
4152  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4153  {
4154  if (connection->lockedHWAddress.isValid()) {
4155  TDENetworkByteList address = connection->lockedHWAddress.address();
4156  TQT_DBusDataValueList valueList;
4157  TDENetworkByteList::iterator it;
4158  for (it = address.begin(); it != address.end(); ++it) {
4159  TQT_DBusData innerDataValue = TQT_DBusData::fromByte(*it);
4160  valueList.append(innerDataValue);
4161  }
4162  TQT_DBusData nmHWAddress = TQT_DBusData::fromTQValueList(valueList);
4163  settingsMap["bdaddr"] = convertDBUSDataToVariantData(nmHWAddress);
4164  }
4165  else {
4166  settingsMap.remove("bdaddr");
4167  }
4168  UPDATE_STRING_SETTING_IF_VALID(tdeBluetoothModeToNMBluetoothMode(bluetoothConnection->type), "type", settingsMap)
4169  }
4170  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4171  groupValid = (settingsMap.count() > 0);
4172  }
4173  if (groupValid) outerMap.insert("bluetooth", dbusData, TRUE); else outerMap.remove("bluetooth");
4174 
4175  groupValid = false;
4176  dbusData = outerMap["cdma"];
4177  if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::CDMA)) {
4178  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4179  {
4180  UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.providerDataNumber, "number", settingsMap)
4181  UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.username, "username", settingsMap)
4182  if (connection->pppoeConfig.secretsValid) {
4183  UPDATE_STRING_SETTING_IF_VALID(modemConnection->cdmaConfig.password, "password", settingsMap)
4184  }
4185  settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->cdmaConfig.passwordFlags)));
4186  }
4187  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4188  groupValid = (settingsMap.count() > 0);
4189  }
4190  if (groupValid) outerMap.insert("cdma", dbusData, TRUE); else outerMap.remove("cdma");
4191 
4192  groupValid = false;
4193  dbusData = outerMap["gsm"];
4194  if ((modemConnection) && (modemConnection->type == TDEModemConnectionType::GSM)) {
4195  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4196  {
4197  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.providerDataNumber, "number", settingsMap)
4198  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.username, "username", settingsMap)
4199  if (connection->pppoeConfig.secretsValid) {
4200  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.password, "password", settingsMap)
4201  }
4202  settingsMap["password-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.passwordFlags)));
4203  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.accessPointName, "apn", settingsMap)
4204  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.networkID, "network-id", settingsMap)
4205  settingsMap["network-type"] = convertDBUSDataToVariantData(TQT_DBusData::fromInt32(tdeGSMModeToNMGSMMode(modemConnection->gsmConfig.networkType)));
4206  if (connection->pppoeConfig.secretsValid) {
4207  UPDATE_STRING_SETTING_IF_VALID(modemConnection->gsmConfig.pin, "pin", settingsMap)
4208  }
4209  settingsMap["pin-flags"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(tdePasswordFlagsToNMPasswordFlags(modemConnection->gsmConfig.pinFlags)));
4210  settingsMap["allowed-bands"] = convertDBUSDataToVariantData(TQT_DBusData::fromUInt32(modemConnection->gsmConfig.allowedFrequencyBands));
4211  settingsMap["home-only"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(modemConnection->gsmConfig.allowRoaming)));
4212  }
4213  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4214  groupValid = (settingsMap.count() > 0);
4215  }
4216  if (groupValid) outerMap.insert("gsm", dbusData, TRUE); else outerMap.remove("gsm");
4217 
4218  groupValid = false;
4219  dbusData = outerMap["ipv4"];
4220  {
4221  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4222  {
4223  {
4224  TQT_DBusDataValueList valueList;
4225  TDENetworkSingleIPConfigurationList::iterator it;
4226  for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
4227  if ((*it).isIPv4()) {
4228  TQT_DBusDataValueList innerValueList;
4229  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4230  // Address
4231  innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
4232  // Netmask
4233  innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
4234  // Gateway
4235  innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
4236  valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
4237  }
4238  }
4239  if (valueList.count() <= 0) {
4240  // Create an empty list with the correct DBUS type structure
4241  TQT_DBusData valueList;
4242  valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
4243  settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
4244  }
4245  else {
4246  settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4247  }
4248  }
4249  {
4250  if (!connection->ipConfig.dhcpClientIdentifier.isNull()) {
4251  settingsMap["dhcp-client-id"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(connection->ipConfig.dhcpClientIdentifier));
4252  }
4253  }
4254  {
4255  TQT_DBusDataValueList valueList;
4256  TDENetworkAddressList::iterator it;
4257  for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
4258  if ((*it).isIPv4Address()) {
4259  valueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).toIPv4Address())));
4260  }
4261  }
4262  if (valueList.count() <= 0) {
4263  // Create an empty list with the correct DBUS type structure
4264  settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32)));
4265  }
4266  else {
4267  settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4268  }
4269  }
4270  {
4271  TQT_DBusDataValueList valueList;
4272  TDENetworkSearchDomainList::iterator it;
4273  for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
4274  if ((*it).isIPv4()) {
4275  valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
4276  }
4277  }
4278  if (valueList.count() > 0) settingsMap["dns-search"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4279  }
4280  {
4281  settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS)));
4282  }
4283  {
4284  settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV4));
4285  }
4286  {
4287  TQString method;
4288  if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP) {
4289  method = "auto";
4290  }
4291  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4LocalOnly) {
4292  method = "link-local";
4293  }
4294  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4StartConnectionSharingServer) {
4295  method = "shared";
4296  }
4297  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4Disabled) {
4298  method = "disabled";
4299  }
4300  else {
4301  method = "manual";
4302  }
4303  if (!method.isNull())
4304  settingsMap["method"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method));
4305  }
4306  {
4307  settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPRoutes)));
4308  }
4309  {
4310  settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute)));
4311  }
4312  {
4313  TQT_DBusDataValueList valueList;
4314  TDENetworkSingleRouteConfigurationList::iterator it;
4315  for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
4316  if ((*it).isIPv4()) {
4317  TQT_DBusDataValueList innerValueList;
4318  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4319  // Address
4320  innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).ipAddress.toIPv4Address())));
4321  // Netmask
4322  innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
4323  // Gateway
4324  innerValueList.append(TQT_DBusData::fromUInt32(reverseIPV4ByteOrder((*it).gateway.toIPv4Address())));
4325  // Metric
4326  innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
4327  valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
4328  }
4329  }
4330  if (valueList.count() <= 0) {
4331  // Create an empty list with the correct DBUS type structure
4332  TQT_DBusData valueList;
4333  valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::UInt32));
4334  settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
4335  }
4336  else {
4337  settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4338  }
4339  }
4340  }
4341  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4342  groupValid = (settingsMap.count() > 0);
4343  }
4344  if (groupValid) outerMap.insert("ipv4", dbusData, TRUE); else outerMap.remove("ipv4");
4345 
4346  groupValid = false;
4347  dbusData = outerMap["ipv6"];
4348  {
4349  TQMap<TQString, TQT_DBusData> settingsMap = dbusData.toStringKeyMap().toTQMap();
4350  {
4351  {
4352  TQT_DBusDataValueList valueList;
4353  TDENetworkSingleIPConfigurationList::iterator it;
4354  for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
4355  if ((*it).isIPv6()) {
4356  int i;
4357  Q_IPV6ADDR v6address;
4358  TQT_DBusDataValueList innerValueList;
4359  TQT_DBusDataValueList innerMostValueList;
4360  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4361  // Address
4362  innerMostValueList.clear();
4363  v6address = (*it).ipAddress.toIPv6Address();
4364  for (i=0; i<16; i++) {
4365  innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4366  }
4367  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4368  // Netmask
4369  innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
4370  // Gateway
4371  innerMostValueList.clear();
4372  v6address = (*it).gateway.toIPv6Address();
4373  for (i=0; i<16; i++) {
4374  innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4375  }
4376  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4377  valueList.append(TQT_DBusData::fromStruct(innerValueList));
4378  }
4379  }
4380  if (valueList.count() <= 0) {
4381  // Create an empty list with the correct DBUS type structure
4382  TQT_DBusDataValueList innerValueList;
4383  TQT_DBusDataValueList innerMostValueList;
4384  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4385  // Address
4386  innerMostValueList.clear();
4387  innerMostValueList.append(TQT_DBusData::fromByte(0));
4388  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4389  // Netmask
4390  innerValueList.append(TQT_DBusData::fromUInt32(0));
4391  // Gateway
4392  innerMostValueList.clear();
4393  innerMostValueList.append(TQT_DBusData::fromByte(0));
4394  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4395  settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList))));
4396  }
4397  else {
4398  settingsMap["addresses"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4399  }
4400  }
4401  {
4402  TQT_DBusDataValueList valueList;
4403  TDENetworkAddressList::iterator it;
4404  for (it = connection->ipConfig.resolvers.begin(); it != connection->ipConfig.resolvers.end(); ++it) {
4405  if ((*it).isIPv6Address()) {
4406  int i;
4407  Q_IPV6ADDR v6address;
4408  TQT_DBusDataValueList innerValueList;
4409  v6address = (*it).toIPv6Address();
4410  for (i=0; i<16; i++) {
4411  innerValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4412  }
4413  valueList.append(TQT_DBusData::fromTQValueList(innerValueList));
4414  }
4415  }
4416  if (valueList.count() <= 0) {
4417  // Create an empty list with the correct DBUS type structure
4418  TQT_DBusData valueList;
4419  valueList = TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::Byte));
4420  settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(valueList)));
4421  }
4422  else {
4423  settingsMap["dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4424  }
4425  }
4426  {
4427  TQT_DBusDataValueList valueList;
4428  TDENetworkSearchDomainList::iterator it;
4429  for (it = connection->ipConfig.searchDomains.begin(); it != connection->ipConfig.searchDomains.end(); ++it) {
4430  if ((*it).isIPv6()) {
4431  valueList.append(TQT_DBusData::fromString((*it).searchDomain()));
4432  }
4433  }
4434  if (valueList.count() > 0) settingsMap["dns-search"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4435  }
4436  {
4437  settingsMap["ignore-auto-dns"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPDNS)));
4438  }
4439  {
4440  settingsMap["may-fail"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!connection->requireIPV6));
4441  }
4442  {
4443  TQString method;
4444  if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP) {
4445  method = "auto";
4446  }
4447  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6LocalOnly) {
4448  method = "link-local";
4449  }
4450  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6StartConnectionSharingServer) {
4451  method = "shared";
4452  }
4453  else if (connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6Disabled) {
4454  method = "ignore";
4455  }
4456  else {
4457  method = "manual";
4458  }
4459  if (!method.isNull())
4460  settingsMap["method"] = convertDBUSDataToVariantData(TQT_DBusData::fromString(method));
4461  }
4462  {
4463  settingsMap["ignore-auto-routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPRoutes)));
4464  }
4465  {
4466  settingsMap["never-default"] = convertDBUSDataToVariantData(TQT_DBusData::fromBool(!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute)));
4467  }
4468  {
4469  TQT_DBusDataValueList valueList;
4470  TDENetworkSingleRouteConfigurationList::iterator it;
4471  for (it = connection->ipConfig.routeConfigurations.begin(); it != connection->ipConfig.routeConfigurations.end(); ++it) {
4472  if ((*it).isIPv6()) {
4473  int i;
4474  Q_IPV6ADDR v6address;
4475  TQT_DBusDataValueList innerValueList;
4476  TQT_DBusDataValueList innerMostValueList;
4477  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4478  // Address
4479  innerMostValueList.clear();
4480  v6address = (*it).ipAddress.toIPv6Address();
4481  for (i=0; i<16; i++) {
4482  innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4483  }
4484  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4485  // Netmask
4486  innerValueList.append(TQT_DBusData::fromUInt32((*it).networkMask.toCIDRMask()));
4487  // Gateway
4488  innerMostValueList.clear();
4489  v6address = (*it).gateway.toIPv6Address();
4490  for (i=0; i<16; i++) {
4491  innerMostValueList.append(TQT_DBusData::fromByte(v6address.c[i]));
4492  }
4493  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4494  // Metric
4495  innerValueList.append(TQT_DBusData::fromUInt32((*it).metric));
4496  valueList.append(TQT_DBusData::fromStruct(innerValueList));
4497  }
4498  }
4499  if (valueList.count() <= 0) {
4500  // Create an empty list with the correct DBUS type structure
4501  TQT_DBusDataValueList innerValueList;
4502  TQT_DBusDataValueList innerMostValueList;
4503  // WARNING: The exact order of the data in the list is critical, therefore extreme caution should be exercised when modifying the code below!
4504  // Address
4505  innerMostValueList.clear();
4506  innerMostValueList.append(TQT_DBusData::fromByte(0));
4507  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4508  // Netmask
4509  innerValueList.append(TQT_DBusData::fromUInt32(0));
4510  // Gateway
4511  innerMostValueList.clear();
4512  innerMostValueList.append(TQT_DBusData::fromByte(0));
4513  innerValueList.append(TQT_DBusData::fromTQValueList(innerMostValueList));
4514  // Metric
4515  innerValueList.append(TQT_DBusData::fromUInt32(0));
4516  settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromList(TQT_DBusDataList(TQT_DBusData::fromStruct(innerValueList))));
4517  }
4518  else {
4519  settingsMap["routes"] = convertDBUSDataToVariantData(TQT_DBusData::fromTQValueList(valueList));
4520  }
4521  }
4522  }
4523  dbusData = TQT_DBusData::fromStringKeyMap(TQT_DBusDataMap<TQString>(settingsMap));
4524  groupValid = (settingsMap.count() > 0);
4525  }
4526  if (groupValid) outerMap.insert("ipv6", dbusData, TRUE); else outerMap.remove("ipv6");
4527  }
4528  connectionSettingsMap = TQT_DBusDataMap<TQString>(outerMap);
4529 
4530  // If existing==true, a connection already existed and simply needs to be updated
4531  // If existing==false, a new connection must be created
4532  // 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);'
4533  // To create new: Use 'd->m_networkManagerSettings' and call 'virtual bool AddConnectionAsync(int& asyncCallId, const TQT_DBusDataMap<TQString>& connection, TQT_DBusError& error);'
4534 
4535 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4536  printf("[network-manager comm debug] uploaded DBUS object structure map follows:\n"); fflush(stdout);
4537  printDBUSObjectStructure(TQT_DBusData::fromStringKeyMap(connectionSettingsMap));
4538 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4539 
4540  if (existing) {
4541 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4542  printf("[network-manager comm debug] Updating existing connection\n"); fflush(stdout);
4543 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4544  // Save connection settings to the path specified
4545  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
4546  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
4547  connect(&connectionSettings, SIGNAL(UpdateAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
4548  int asyncCallID;
4549  ret = connectionSettings.UpdateAsync(asyncCallID, connectionSettingsMap, error);
4550  if (ret && error.isValid()) {
4551  ret = 0;
4552  PRINT_ERROR((error.name() + ": " + error.message()))
4553  }
4554  if (ret) {
4555  // Wait for the asynchronous call to return...
4556  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
4557  TQTimer nmCallTimeoutTimer;
4558  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
4559  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
4560  tqApp->processEvents();
4561  if (!nmCallTimeoutTimer.isActive()) {
4562  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
4563  timed_out = true;
4564  break;
4565  }
4566  }
4567  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
4568  return !timed_out;
4569  }
4570  else {
4571  // Error!
4572  PRINT_ERROR((error.name() + ": " + error.message()))
4573  return FALSE;
4574  }
4575  }
4576  else {
4577 #ifdef DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4578  printf("[network-manager comm debug] Creating new connection\n"); fflush(stdout);
4579 #endif // DEBUG_NETWORK_MANAGER_COMMUNICATIONS
4580  // Create new connection
4581  connect(d->m_networkManagerSettings, SIGNAL(AddConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
4582  connect(d->m_networkManagerSettings, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
4583  int asyncCallID;
4584  ret = d->m_networkManagerSettings->AddConnectionAsync(asyncCallID, connectionSettingsMap, error);
4585  if (ret && error.isValid()) {
4586  ret = 0;
4587  PRINT_ERROR((error.name() + ": " + error.message()))
4588  }
4589  if (ret) {
4590  // Wait for the asynchronous call to return...
4591  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
4592  TQTimer nmCallTimeoutTimer;
4593  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
4594  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
4595  if (!nmCallTimeoutTimer.isActive()) {
4596  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
4597  timed_out = true;
4598  break;
4599  }
4600  tqApp->processEvents();
4601  }
4602  if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
4603  PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
4604  d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
4605  }
4606  if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
4607  PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
4608  command_failed = true;
4609  }
4610  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
4611  if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
4612  d->nmAddConnectionAsyncResponse.remove(asyncCallID);
4613  }
4614  return ((!timed_out) && (!command_failed));
4615  }
4616  else {
4617  // Error!
4618  PRINT_ERROR((error.name() + ": " + error.message()))
4619  return FALSE;
4620  }
4621  }
4622 }
4623 
4624 bool TDENetworkConnectionManager_BackendNM::deleteConnection(TQString uuid) {
4625  TQT_DBusObjectPath existingConnection;
4626  TQT_DBusError error;
4627  bool timed_out = false;
4628  bool ret;
4629  if (d->m_networkManagerSettings) {
4630  ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
4631  if (ret) {
4632  // Obtain connection secrets from the path specified
4633  DBus::ConnectionSettingsInterface connectionSettings(NM_DBUS_SERVICE, existingConnection);
4634  connectionSettings.setConnection(TQT_DBusConnection::systemBus());
4635  connect(&connectionSettings, SIGNAL(DeleteAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
4636  int asyncCallID;
4637  ret = connectionSettings.DeleteAsync(asyncCallID, error);
4638  if (ret && error.isValid()) {
4639  ret = 0;
4640  PRINT_ERROR((error.name() + ": " + error.message()))
4641  }
4642  if (ret) {
4643  // Wait for the asynchronous call to return...
4644  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
4645  TQTimer nmCallTimeoutTimer;
4646  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
4647  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
4648  tqApp->processEvents();
4649  if (!nmCallTimeoutTimer.isActive()) {
4650  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
4651  timed_out = true;
4652  break;
4653  }
4654  }
4655  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
4656  return !timed_out;
4657  }
4658  else {
4659  PRINT_ERROR(TQString("Unable to remove connection with uuid '%1'").arg(uuid))
4660  return FALSE;
4661  }
4662  }
4663  else {
4664  PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
4665  return FALSE;
4666  }
4667  }
4668  else {
4669  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4670  return FALSE;
4671  }
4672 }
4673 
4674 bool TDENetworkConnectionManager_BackendNM::verifyConnectionSettings(TDENetworkConnection* connection, TDENetworkConnectionErrorFlags::TDENetworkConnectionErrorFlags* type, TDENetworkErrorStringMap* reason) {
4675  // FIXME
4676  // This should actually attempt to validate all the settings!
4677 
4678  if (!connection) {
4679  return false;
4680  }
4681 
4682  if (connection->friendlyName == "") {
4683  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidConnectionSetting] = i18n("Connection name is invalid");
4684  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidConnectionSetting;
4685  return false;
4686  }
4687 
4688  if (connection->ipConfig.valid) {
4689  // Iterate over all addresses
4690  TDENetworkSingleIPConfigurationList::iterator it;
4691  for (it = connection->ipConfig.ipConfigurations.begin(); it != connection->ipConfig.ipConfigurations.end(); ++it) {
4692  if ((*it).isIPv4()) {
4693  if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV4DHCPIP)) {
4694  if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
4695  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv4Setting] = i18n("IPv4 address is invalid");
4696  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv4Setting;
4697  return false;
4698  }
4699  }
4700  }
4701  else if ((*it).isIPv6()) {
4702  if (!(connection->ipConfig.connectionFlags & TDENetworkIPConfigurationFlags::IPV6DHCPIP)) {
4703  if (!TDENetworkConnectionManager::validateIPAddress((*it).ipAddress)) {
4704  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidIPv6Setting] = i18n("IPv6 address is invalid");
4705  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidIPv6Setting;
4706  return false;
4707  }
4708  }
4709  }
4710  }
4711  }
4712 
4713  TDEWiFiConnection* wiFiConnection = dynamic_cast<TDEWiFiConnection*>(connection);
4714  if (wiFiConnection) {
4715  if (wiFiConnection->SSID.count() < 1) {
4716  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessSetting] = i18n("No SSID provided");
4717  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessSetting;
4718  return false;
4719  }
4720  if (wiFiConnection->securityRequired) {
4721  if (wiFiConnection->securitySettings.secretsValid) {
4722  if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WEP) || ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && ((wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Open) || (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::Shared)))) {
4723  if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Hexadecimal) {
4724  if (wiFiConnection->securitySettings.wepKey0 != "") {
4725  if ((wiFiConnection->securitySettings.wepKey0.length() != 10) && (wiFiConnection->securitySettings.wepKey0.length() != 26)) {
4726  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
4727  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4728  return false;
4729  }
4730  }
4731  if (wiFiConnection->securitySettings.wepKey1 != "") {
4732  if ((wiFiConnection->securitySettings.wepKey1.length() != 10) && (wiFiConnection->securitySettings.wepKey1.length() != 26)) {
4733  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
4734  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4735  return false;
4736  }
4737  }
4738  if (wiFiConnection->securitySettings.wepKey2 != "") {
4739  if ((wiFiConnection->securitySettings.wepKey2.length() != 10) && (wiFiConnection->securitySettings.wepKey2.length() != 26)) {
4740  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
4741  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4742  return false;
4743  }
4744  }
4745  if (wiFiConnection->securitySettings.wepKey3 != "") {
4746  if ((wiFiConnection->securitySettings.wepKey3.length() != 10) && (wiFiConnection->securitySettings.wepKey3.length() != 26)) {
4747  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
4748  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4749  return false;
4750  }
4751  }
4752  if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
4753  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
4754  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4755  return false;
4756  }
4757  }
4758  else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
4759  if (wiFiConnection->securitySettings.wepKey0 != "") {
4760  if ((wiFiConnection->securitySettings.wepKey0.length() != 5) && (wiFiConnection->securitySettings.wepKey0.length() != 13)) {
4761  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 0 has invalid length");
4762  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4763  return false;
4764  }
4765  }
4766  if (wiFiConnection->securitySettings.wepKey1 != "") {
4767  if ((wiFiConnection->securitySettings.wepKey1.length() != 5) && (wiFiConnection->securitySettings.wepKey1.length() != 13)) {
4768  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 1 has invalid length");
4769  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4770  return false;
4771  }
4772  }
4773  if (wiFiConnection->securitySettings.wepKey2 != "") {
4774  if ((wiFiConnection->securitySettings.wepKey2.length() != 5) && (wiFiConnection->securitySettings.wepKey2.length() != 13)) {
4775  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 2 has invalid length");
4776  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4777  return false;
4778  }
4779  }
4780  if (wiFiConnection->securitySettings.wepKey3 != "") {
4781  if ((wiFiConnection->securitySettings.wepKey3.length() != 5) && (wiFiConnection->securitySettings.wepKey3.length() != 13)) {
4782  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("WEP key 3 has invalid length");
4783  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4784  return false;
4785  }
4786  }
4787  if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
4788  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
4789  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4790  return false;
4791  }
4792  }
4793  else if (wiFiConnection->securitySettings.wepKeyType == TDENetworkWepKeyType::Ascii) {
4794  if ((wiFiConnection->securitySettings.wepKey0 == "") && (wiFiConnection->securitySettings.wepKey1 == "") && (wiFiConnection->securitySettings.wepKey2 == "") && (wiFiConnection->securitySettings.wepKey3 == "")) {
4795  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No WEP key(s) provided");
4796  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4797  return false;
4798  }
4799  }
4800  }
4801  else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::DynamicWEP) && (wiFiConnection->securitySettings.authType == TDENetworkWiFiAuthType::LEAP)) {
4802  if ((wiFiConnection->securitySettings.leapUsername.length() < 1) || (wiFiConnection->securitySettings.leapPassword.length() < 1)) {
4803  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("LEAP username and/or password not provided");
4804  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4805  return false;
4806  }
4807  }
4808  else if ((wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAAdHoc) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAInfrastructure) || (wiFiConnection->securitySettings.keyType == TDENetworkWiFiKeyType::WPAEnterprise)) {
4809  if (wiFiConnection->securitySettings.psk.length() == 64) {
4810  // Verify that only hex characters are present in the string
4811  bool ok;
4812  wiFiConnection->securitySettings.psk.toULongLong(&ok, 16);
4813  if (!ok) {
4814  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("Hexadecimal length PSK contains non-hexadecimal characters");
4815  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4816  return false;
4817  }
4818  }
4819  else if ((wiFiConnection->securitySettings.psk.length() < 8) || (wiFiConnection->securitySettings.psk.length() > 63)) {
4820  if (reason) (*reason)[TDENetworkConnectionErrorFlags::InvalidWirelessKey] = i18n("No PSK provided");
4821  if (type) *type |= TDENetworkConnectionErrorFlags::InvalidWirelessKey;
4822  return false;
4823  }
4824  }
4825  }
4826  }
4827  }
4828 
4829  return TRUE;
4830 }
4831 
4832 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::initiateConnection(TQString uuid) {
4833  TQT_DBusObjectPath existingConnection;
4834  TQT_DBusError error;
4835  bool ret;
4836  if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
4837  ret = d->m_networkManagerSettings->GetConnectionByUuid(uuid, existingConnection, error);
4838  if (ret) {
4839  if (!m_networkDevice) {
4840  d->m_dbusDeviceString = "/";
4841  }
4842  else {
4843  d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
4844  }
4845  if (d->m_dbusDeviceString.isEmpty()) {
4846  PRINT_ERROR(TQString("Invalid empty DBUS device string"))
4847  return TDENetworkConnectionStatus::Invalid;
4848  }
4849 #ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
4850  TQT_DBusObjectPath active_connection;
4851  ret = d->m_networkManagerProxy->ActivateConnection(existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), active_connection, error);
4852  if (ret && error.isValid()) {
4853  ret = 0;
4854  PRINT_ERROR((error.name() + ": " + error.message()))
4855  }
4856  return checkConnectionStatus(uuid);
4857 #else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
4858 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
4859  connect(d->m_networkManagerProxy, SIGNAL(ActivateConnectionAsyncReply(int, const TQT_DBusObjectPath&)), d, SLOT(processAddConnectionAsyncReply(int, const TQT_DBusObjectPath&)));
4860  connect(d->m_networkManagerProxy, SIGNAL(AsyncErrorResponseDetected(int, const TQT_DBusError)), d, SLOT(processAddConnectionAsyncError(int, const TQT_DBusError)));
4861 #endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
4862  int asyncCallID;
4863  ret = d->m_networkManagerProxy->ActivateConnectionAsync(asyncCallID, existingConnection, TQT_DBusObjectPath(d->m_dbusDeviceString.ascii()), TQT_DBusObjectPath("/"), error);
4864  if (ret && error.isValid()) {
4865  ret = 0;
4866  PRINT_ERROR((error.name() + ": " + error.message()))
4867  }
4868 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
4869  if (ret) {
4870  // Wait for the asynchronous call to return...
4871  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
4872  TQTimer nmCallTimeoutTimer;
4873  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
4874  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
4875  if (!nmCallTimeoutTimer.isActive()) {
4876  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
4877  break;
4878  }
4879  tqApp->processEvents();
4880  }
4881  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
4882  if (d->nmAddConnectionAsyncErrorResponse.contains(asyncCallID)) {
4883  PRINT_ERROR((d->nmAddConnectionAsyncErrorResponse[asyncCallID].name() + ": " + d->nmAddConnectionAsyncErrorResponse[asyncCallID].message()));
4884  d->nmAddConnectionAsyncErrorResponse.remove(asyncCallID);
4885  }
4886  if (!d->nmAddConnectionAsyncResponse[asyncCallID].data()) {
4887  PRINT_ERROR(TQString("NetworkManager did not return a new connection object!"))
4888  }
4889  if (d->nmAddConnectionAsyncResponse.contains(asyncCallID)) {
4890  d->nmAddConnectionAsyncResponse.remove(asyncCallID);
4891  }
4892  return checkConnectionStatus(uuid);
4893  }
4894  else {
4895  // Error!
4896  PRINT_ERROR((error.name() + ": " + error.message()))
4897  return checkConnectionStatus(uuid);
4898  }
4899 #else
4900  return checkConnectionStatus(uuid);
4901 #endif
4902 #endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
4903  }
4904  else {
4905  PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
4906  return TDENetworkConnectionStatus::Invalid;
4907  }
4908  }
4909  else {
4910  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4911  return TDENetworkConnectionStatus::Invalid;
4912  }
4913 }
4914 
4915 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::checkConnectionStatus(TQString uuid) {
4916  TQT_DBusObjectPath existingConnection;
4917  TQT_DBusError error;
4918  if (d->m_networkManagerProxy) {
4919  TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
4920  TQT_DBusObjectPathList::iterator it;
4921  for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
4922  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
4923  activeConnection.setConnection(TQT_DBusConnection::systemBus());
4924  if (activeConnection.getUuid(error) == uuid) {
4925  return nmDeviceStateToTDEDeviceState(activeConnection.getState(error));
4926  }
4927  }
4928  PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
4929  return TDENetworkConnectionStatus::Invalid;
4930  }
4931  else {
4932  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4933  return TDENetworkConnectionStatus::Invalid;
4934  }
4935 }
4936 
4937 TQCString TDENetworkConnectionManager_BackendNM::getActiveConnectionPath(TQString uuid) {
4938  TQT_DBusObjectPath existingConnection;
4939  TQT_DBusError error;
4940  if (d->m_networkManagerProxy) {
4941  TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
4942  TQT_DBusObjectPathList::iterator it;
4943  for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
4944  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
4945  activeConnection.setConnection(TQT_DBusConnection::systemBus());
4946  if (activeConnection.getUuid(error) == uuid) {
4947  return (*it);
4948  }
4949  }
4950  PRINT_WARNING(TQString("active connection for provided uuid '%1' was not found").arg(uuid));
4951  return TQT_DBusObjectPath();
4952  }
4953  else {
4954  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4955  return TQT_DBusObjectPath();
4956  }
4957 }
4958 
4959 TQStringList TDENetworkConnectionManager_BackendNM::connectionPhysicalDeviceUUIDs(TQString uuid) {
4960  if (deviceType() == TDENetworkDeviceType::BackendOnly) {
4961  return TQStringList();
4962  }
4963 
4964  TQT_DBusObjectPath existingConnection;
4965  TQT_DBusError error;
4966  if (d->m_networkManagerProxy) {
4967  TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
4968  TQT_DBusObjectPathList::iterator it;
4969  TQStringList ret;
4970  for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
4971  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
4972  activeConnection.setConnection(TQT_DBusConnection::systemBus());
4973  if (activeConnection.getUuid(error) == uuid) {
4974  TQValueList<TQT_DBusObjectPath> deviceList = activeConnection.getDevices(error);
4975  TQT_DBusObjectPathList::iterator it2;
4976  for (it2 = deviceList.begin(); it2 != deviceList.end(); ++it2) {
4977  TQString devUUID = tdeDeviceUUIDForGenericDevice(*it2);
4978  if (devUUID != "") {
4979  ret.append(devUUID);
4980  }
4981  }
4982  }
4983  }
4984  return ret;
4985  }
4986  else {
4987  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
4988  return TQStringList();
4989  }
4990 }
4991 
4992 TDENetworkVPNTypeList TDENetworkConnectionManager_BackendNM::availableVPNTypes() {
4993  TDENetworkVPNTypeList ret;
4994 
4995  // Query NetworkManager to verify plugin availability before claiming support for a VPN type
4996  TQDir serviceDir(NM_PLUGIN_SERVICE_DIR, TQString(), TQDir::Name|TQDir::IgnoreCase, TQDir::Files);
4997  TQStringList services = serviceDir.entryList ().grep (".name", true);
4998 
4999  if (services.count () > 0) {
5000  // read in all available Services
5001  for (TQStringList::Iterator i = services.begin (); i != services.end (); ++i) {
5002  TQString service = NM_PLUGIN_SERVICE_DIR + TQString ("/") + *i;
5003  TDEConfig* tdeconfig = new TDEConfig (service, true, true, "config");
5004  tdeconfig->setGroup ("VPN Connection");
5005 
5006  TQString serviceName = tdeconfig->readEntry("name", TQString());
5007  serviceName = serviceName.lower();
5008 
5009  if (serviceName == "openvpn") {
5010  ret.append(TDENetworkVPNType::OpenVPN);
5011  }
5012  if (serviceName == "pptp") {
5013  ret.append(TDENetworkVPNType::PPTP);
5014  }
5015  if (serviceName == "strongswan") {
5016  ret.append(TDENetworkVPNType::StrongSwan);
5017  }
5018  if (serviceName == "vpnc") {
5019  ret.append(TDENetworkVPNType::VPNC);
5020  }
5021 
5022  delete tdeconfig;
5023  }
5024  }
5025 
5026  return ret;
5027 }
5028 
5029 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDENetworkConnectionManager_BackendNM::deactivateConnection(TQString uuid) {
5030  TQT_DBusObjectPath existingConnection;
5031  TQT_DBusError error;
5032  bool ret;
5033  if ((d->m_networkManagerSettings) && (d->m_networkManagerProxy)) {
5034  existingConnection = getActiveConnectionPath(uuid);
5035  if (existingConnection.isValid()) {
5036  if (!m_networkDevice) {
5037  d->m_dbusDeviceString = "/";
5038  }
5039  else {
5040  d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
5041  }
5042  if (d->m_dbusDeviceString.isEmpty()) {
5043  PRINT_ERROR(TQString("Invalid empty DBUS device string"))
5044  return TDENetworkConnectionStatus::Invalid;
5045  }
5046 #ifndef USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
5047  ret = d->m_networkManagerProxy->DeactivateConnection(existingConnection, error);
5048  if (ret && error.isValid()) {
5049  ret = 0;
5050  PRINT_ERROR((error.name() + ": " + error.message()))
5051  }
5052  return checkConnectionStatus(uuid);
5053 #else // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
5054 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
5055  connect(d->m_networkManagerProxy, SIGNAL(DeactivateConnectionAsyncReply(int)), d, SLOT(processConnectionSettingsUpdateAsyncReply(int)));
5056 #endif // WAIT_FOR_OPERATION_BEFORE_RETURNING
5057  int asyncCallID;
5058  ret = d->m_networkManagerProxy->DeactivateConnectionAsync(asyncCallID, existingConnection, error);
5059  if (ret && error.isValid()) {
5060  ret = 0;
5061  PRINT_ERROR((error.name() + ": " + error.message()))
5062  }
5063 #ifdef WAIT_FOR_OPERATION_BEFORE_RETURNING
5064  if (ret) {
5065  // Wait for the asynchronous call to return...
5066  d->nmConnectionSettingsAsyncCallWaiting[asyncCallID] = true;
5067  TQTimer nmCallTimeoutTimer;
5068  nmCallTimeoutTimer.start(NM_ASYNC_TIMEOUT_MS, TRUE);
5069  while (d->nmConnectionSettingsAsyncCallWaiting[asyncCallID]) {
5070  if (!nmCallTimeoutTimer.isActive()) {
5071  PRINT_ERROR(TQString("DBUS asynchronous call timed out!"))
5072  break;
5073  }
5074  tqApp->processEvents();
5075  }
5076  d->nmConnectionSettingsAsyncCallWaiting.remove(asyncCallID);
5077  return checkConnectionStatus(uuid);
5078  }
5079  else {
5080  // Error!
5081  PRINT_ERROR((error.name() + ": " + error.message()))
5082  return checkConnectionStatus(uuid);
5083  }
5084 #else
5085  return checkConnectionStatus(uuid);
5086 #endif
5087 #endif // USE_ASYNC_DBUS_CONNECTION_COMMAND_CALLS
5088  }
5089  else {
5090  PRINT_WARNING(TQString("connection for provided uuid '%1' was not found").arg(uuid));
5091  return TDENetworkConnectionStatus::Invalid;
5092  }
5093  }
5094  else {
5095  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
5096  return TDENetworkConnectionStatus::Invalid;
5097  }
5098 }
5099 
5100 TQStringList TDENetworkConnectionManager_BackendNM::validSettings() {
5101  TQStringList ret;
5102 
5103  ret.append("TDENetworkSingleIPConfiguration::ipAddress");
5104  ret.append("TDENetworkSingleIPConfiguration::networkMask");
5105  ret.append("TDENetworkSingleIPConfiguration::gateway");
5106 
5107  ret.append("TDENetworkSingleRouteConfiguration::ipAddress");
5108  ret.append("TDENetworkSingleRouteConfiguration::networkMask");
5109  ret.append("TDENetworkSingleRouteConfiguration::gateway");
5110 
5111  ret.append("TDENetworkIEEE8021xConfiguration::valid");
5112  ret.append("TDENetworkIEEE8021xConfiguration::allowedValid");
5113  ret.append("TDENetworkIEEE8021xConfiguration::secretsValid");
5114  ret.append("TDENetworkIEEE8021xConfiguration::type");
5115  ret.append("TDENetworkIEEE8021xConfiguration::userName");
5116  ret.append("TDENetworkIEEE8021xConfiguration::anonymousUserName");
5117  ret.append("TDENetworkIEEE8021xConfiguration::pacFileName");
5118  ret.append("TDENetworkIEEE8021xConfiguration::caCertificate");
5119  ret.append("TDENetworkIEEE8021xConfiguration::additionalCAFilesPath");
5120  ret.append("TDENetworkIEEE8021xConfiguration::authServerCertSubjectMatch");
5121  ret.append("TDENetworkIEEE8021xConfiguration::alternateAuthServerCertSubjectMatch");
5122  ret.append("TDENetworkIEEE8021xConfiguration::clientCertificate");
5123  ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPVersion");
5124  ret.append("TDENetworkIEEE8021xConfiguration::forcePEAPLabel");
5125  ret.append("TDENetworkIEEE8021xConfiguration::fastProvisioningFlags");
5126  ret.append("TDENetworkIEEE8021xConfiguration::phase2NonEAPAuthMethod");
5127  ret.append("TDENetworkIEEE8021xConfiguration::phase2EAPAuthMethod");
5128  ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2NonEAPMethods");
5129  ret.append("TDENetworkIEEE8021xConfiguration::allowedPhase2EAPMethods");
5130  ret.append("TDENetworkIEEE8021xConfiguration::phase2CaCertificate");
5131  ret.append("TDENetworkIEEE8021xConfiguration::phase2CaFilesPath");
5132  ret.append("TDENetworkIEEE8021xConfiguration::phase2AuthServerCertSubjectMatch");
5133  ret.append("TDENetworkIEEE8021xConfiguration::phase2AlternateAuthServerCertSubjectMatch");
5134  ret.append("TDENetworkIEEE8021xConfiguration::phase2ClientCertificate");
5135  ret.append("TDENetworkIEEE8021xConfiguration::password");
5136  ret.append("TDENetworkIEEE8021xConfiguration::passwordFlags");
5137  ret.append("TDENetworkIEEE8021xConfiguration::binaryPassword");
5138  ret.append("TDENetworkIEEE8021xConfiguration::binaryPasswordFlags");
5139  ret.append("TDENetworkIEEE8021xConfiguration::privateKey");
5140  ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPassword");
5141  ret.append("TDENetworkIEEE8021xConfiguration::privateKeyPasswordFlags");
5142  ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKey");
5143  ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPassword");
5144  ret.append("TDENetworkIEEE8021xConfiguration::phase2PrivateKeyPasswordFlags");
5145  ret.append("TDENetworkIEEE8021xConfiguration::forceSystemCaCertificates");
5146 
5147  ret.append("TDENetworkPPPConfiguration::valid");
5148  ret.append("TDENetworkPPPConfiguration::requireServerAuthentication");
5149  ret.append("TDENetworkPPPConfiguration::flags");
5150  ret.append("TDENetworkPPPConfiguration::baudRate");
5151  ret.append("TDENetworkPPPConfiguration::mru");
5152  ret.append("TDENetworkPPPConfiguration::mtu");
5153  ret.append("TDENetworkPPPConfiguration::lcpEchoPingInterval");
5154  ret.append("TDENetworkPPPConfiguration::lcpEchoFailureThreshold");
5155 
5156  ret.append("TDENetworkPPPOEConfiguration::valid");
5157  ret.append("TDENetworkPPPOEConfiguration::secretsValid");
5158  ret.append("TDENetworkPPPOEConfiguration::networkServiceProvider");
5159  ret.append("TDENetworkPPPOEConfiguration::username");
5160  ret.append("TDENetworkPPPOEConfiguration::password");
5161  ret.append("TDENetworkPPPOEConfiguration::passwordFlags");
5162 
5163  ret.append("TDENetworkSerialConfiguration::valid");
5164  ret.append("TDENetworkSerialConfiguration::baudRate");
5165  ret.append("TDENetworkSerialConfiguration::byteWidth");
5166  ret.append("TDENetworkSerialConfiguration::parity");
5167  ret.append("TDENetworkSerialConfiguration::stopBits");
5168  ret.append("TDENetworkSerialConfiguration::txDelay");
5169 
5170  ret.append("TDENetworkCDMAConfiguration::valid");
5171  ret.append("TDENetworkCDMAConfiguration::secretsValid");
5172  ret.append("TDENetworkCDMAConfiguration::providerDataNumber");
5173  ret.append("TDENetworkCDMAConfiguration::username");
5174  ret.append("TDENetworkCDMAConfiguration::password");
5175  ret.append("TDENetworkCDMAConfiguration::passwordFlags");
5176 
5177  ret.append("TDENetworkGSMConfiguration::valid");
5178  ret.append("TDENetworkGSMConfiguration::secretsValid");
5179  ret.append("TDENetworkGSMConfiguration::providerDataNumber");
5180  ret.append("TDENetworkGSMConfiguration::username");
5181  ret.append("TDENetworkGSMConfiguration::password");
5182  ret.append("TDENetworkGSMConfiguration::passwordFlags");
5183  ret.append("TDENetworkGSMConfiguration::accessPointName");
5184  ret.append("TDENetworkGSMConfiguration::networkID");
5185  ret.append("TDENetworkGSMConfiguration::networkType");
5186  ret.append("TDENetworkGSMConfiguration::pin");
5187  ret.append("TDENetworkGSMConfiguration::pinFlags");
5188  ret.append("TDENetworkGSMConfiguration::allowedFrequencyBands");
5189  ret.append("TDENetworkGSMConfiguration::allowRoaming");
5190 
5191  ret.append("TDENetworkWiFiSecurityConfiguration::valid");
5192  ret.append("TDENetworkWiFiSecurityConfiguration::secretsValid");
5193  ret.append("TDENetworkWiFiSecurityConfiguration::keyType");
5194  ret.append("TDENetworkWiFiSecurityConfiguration::authType");
5195  ret.append("TDENetworkWiFiSecurityConfiguration::wpaVersion");
5196  ret.append("TDENetworkWiFiSecurityConfiguration::cipher");
5197  ret.append("TDENetworkWiFiSecurityConfiguration::wepKey0");
5198  ret.append("TDENetworkWiFiSecurityConfiguration::wepKey1");
5199  ret.append("TDENetworkWiFiSecurityConfiguration::wepKey2");
5200  ret.append("TDENetworkWiFiSecurityConfiguration::wepKey3");
5201  ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyFlags");
5202  ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyIndex");
5203  ret.append("TDENetworkWiFiSecurityConfiguration::wepKeyType");
5204  ret.append("TDENetworkWiFiSecurityConfiguration::allowedPairWiseCiphers");
5205  ret.append("TDENetworkWiFiSecurityConfiguration::allowedGroupWiseCiphers");
5206  ret.append("TDENetworkWiFiSecurityConfiguration::psk");
5207  ret.append("TDENetworkWiFiSecurityConfiguration::pskFlags");
5208  ret.append("TDENetworkWiFiSecurityConfiguration::leapUsername");
5209  ret.append("TDENetworkWiFiSecurityConfiguration::leapPassword");
5210  ret.append("TDENetworkWiFiSecurityConfiguration::leapPasswordFlags");
5211 
5212  ret.append("TDENetworkIPConfiguration::valid");
5213  ret.append("TDENetworkIPConfiguration::connectionFlags");
5214  ret.append("TDENetworkIPConfiguration::ipConfigurations");
5215  ret.append("TDENetworkIPConfiguration::routeConfigurations");
5216  ret.append("TDENetworkIPConfiguration::broadcast");
5217  ret.append("TDENetworkIPConfiguration::destination");
5218  ret.append("TDENetworkIPConfiguration::resolvers");
5219  ret.append("TDENetworkIPConfiguration::searchDomains");
5220  ret.append("TDENetworkIPConfiguration::dhcpClientIdentifier");
5221 
5222  ret.append("TDENetworkConnection::UUID");
5223  ret.append("TDENetworkConnection::friendlyName");
5224  ret.append("TDENetworkConnection::ipConfig");
5225  ret.append("TDENetworkConnection::lockedHWAddress");
5226  ret.append("TDENetworkConnection::manualHWAddress");
5227  ret.append("TDENetworkConnection::readOnly");
5228  ret.append("TDENetworkConnection::autoConnect");
5229  ret.append("TDENetworkConnection::fullDuplex");
5230  ret.append("TDENetworkConnection::requireIPV4");
5231  ret.append("TDENetworkConnection::requireIPV6");
5232  ret.append("TDENetworkConnection::mtu");
5233  ret.append("TDENetworkConnection::eapConfig");
5234  ret.append("TDENetworkConnection::pppConfig");
5235  ret.append("TDENetworkConnection::pppoeConfig");
5236  ret.append("TDENetworkConnection::serialConfig");
5237  ret.append("TDENetworkConnection::authorizedUsers");
5238  ret.append("TDENetworkConnection::masterConnectionUUID");
5239  ret.append("TDENetworkConnection::slaveType");
5240  ret.append("TDENetworkConnection::lastKnownConnection");
5241 
5242  ret.append("TDEWiFiConnection::SSID");
5243  ret.append("TDEWiFiConnection::operatingMode");
5244  ret.append("TDEWiFiConnection::bandRestriction");
5245  ret.append("TDEWiFiConnection::channelRestriction");
5246  ret.append("TDEWiFiConnection::bitRateRestriction");
5247  ret.append("TDEWiFiConnection::powerRestriction");
5248  ret.append("TDEWiFiConnection::accessPointRestriction");
5249  ret.append("TDEWiFiConnection::blacklistedBSSIDs");
5250  ret.append("TDEWiFiConnection::heardBSSIDs");
5251  ret.append("TDEWiFiConnection::isHiddenNetwork");
5252  ret.append("TDEWiFiConnection::securityRequired");
5253  ret.append("TDEWiFiConnection::securitySettings");
5254 
5255  ret.append("TDEWiredInfinibandConnection::transportMode");
5256 
5257  ret.append("TDEVPNConnection::vpnPluginID");
5258  ret.append("TDEVPNConnection::lockedUserName");
5259  ret.append("TDEVPNConnection::pluginData");
5260  ret.append("TDEVPNConnection::secretsValid");
5261  ret.append("TDEVPNConnection::pluginSecrets");
5262 
5263  ret.append("TDEWiMaxConnection::networkServiceProvider");
5264 
5265  ret.append("TDEVLANConnection::kernelName");
5266  ret.append("TDEVLANConnection::parentConnectionUUID");
5267  ret.append("TDEVLANConnection::vlanID");
5268  ret.append("TDEVLANConnection::vlanFlags");
5269  ret.append("TDEVLANConnection::ingressPriorityMap");
5270  ret.append("TDEVLANConnection::egressPriorityMap");
5271 
5272  ret.append("TDEOLPCMeshConnection::SSID");
5273  ret.append("TDEOLPCMeshConnection::channel");
5274  ret.append("TDEOLPCMeshConnection::anycastDHCPHWAddress");
5275 
5276  ret.append("TDEBluetoothConnection::type");
5277 
5278  ret.append("TDEModemConnection::type");
5279  ret.append("TDEModemConnection::cdmaConfig");
5280  ret.append("TDEModemConnection::gsmConfig");
5281 
5282  ret.append("TDEWiredInfinibandConnection::transportMode");
5283 
5284  return ret;
5285 }
5286 
5287 TDENetworkWiFiAPInfo* TDENetworkConnectionManager_BackendNM::getAccessPointDetails(TQString dbusPath) {
5288  if (dbusPath == "") {
5289  return NULL;
5290  }
5291 
5292  TDENetworkWiFiAPInfo* apInfo = new TDENetworkWiFiAPInfo;
5293  TQT_DBusError error;
5294  unsigned int index;
5295  DBus::AccessPointProxy accessPoint(NM_DBUS_SERVICE, dbusPath);
5296  accessPoint.setConnection(TQT_DBusConnection::systemBus());
5297 
5298  TQValueList<TQ_UINT8> nmSSID = accessPoint.getSsid(error);
5299  if (error.isValid()) {
5300  delete apInfo;
5301  return NULL;
5302  }
5303  TQValueList<TQ_UINT8>::iterator it;
5304  index = 0;
5305  for (it = nmSSID.begin(); it != nmSSID.end(); ++it) {
5306  apInfo->SSID.resize(index+1);
5307  apInfo->SSID[index] = (*it);
5308  index++;
5309  }
5310 
5311  apInfo->wpaFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getWpaFlags(error));
5312  apInfo->rsnFlags = nmAPSecFlagsToTDEAPSecFlags(accessPoint.getFlags(error), accessPoint.getRsnFlags(error));
5313  apInfo->frequency = accessPoint.getFrequency(error);
5314  apInfo->BSSID.fromString(accessPoint.getHwAddress(error));
5315  apInfo->maxBitrate = accessPoint.getMaxBitrate(error);
5316  apInfo->signalQuality = (accessPoint.getStrength(error)/100.0);
5317 
5318  apInfo->valid = true;
5319 
5320  return apInfo;
5321 }
5322 
5323 TDENetworkHWNeighborList* TDENetworkConnectionManager_BackendNM::siteSurvey() {
5324  TQT_DBusError error;
5325  bool ret;
5326 
5327  TDENetworkDeviceType::TDENetworkDeviceType myDeviceType = deviceType();
5328  d->m_dbusDeviceString = deviceInterfaceString(deviceNode());
5329  clearTDENetworkHWNeighborList();
5330 
5331  if (myDeviceType == TDENetworkDeviceType::WiFi) {
5332  if (!d->m_dbusDeviceString.isEmpty()) {
5333  DBus::WiFiDeviceProxy wiFiDevice(NM_DBUS_SERVICE, d->m_dbusDeviceString);
5334  wiFiDevice.setConnection(TQT_DBusConnection::systemBus());
5335  // FIXME
5336  // Should call wiFiDevice.RequestScanAsync first to rescan all access points
5337  TQT_DBusObjectPathList accessPoints;
5338  ret = wiFiDevice.GetAccessPoints(accessPoints, error);
5339  if (ret) {
5340  TQT_DBusObjectPathList::iterator it;
5341  for (it = accessPoints.begin(); it != accessPoints.end(); ++it) {
5342  TDENetworkWiFiAPInfo* apInfo = getAccessPointDetails(TQString(*it));
5343  if (apInfo) {
5344  m_hwNeighborList->append(apInfo);
5345  // Ensure that this AP is monitored for changes
5346  d->internalProcessWiFiAccessPointAdded(*it);
5347  }
5348  }
5349  }
5350  }
5351  }
5352 
5353  return m_hwNeighborList;
5354 }
5355 
5356 bool TDENetworkConnectionManager_BackendNM::networkingEnabled() {
5357  if (d->m_networkManagerProxy) {
5358  bool ret;
5359  TQT_DBusError error;
5360  ret = d->m_networkManagerProxy->getNetworkingEnabled(error);
5361  if (error.isValid()) {
5362  // Error!
5363  PRINT_ERROR((error.name() + ": " + error.message()))
5364  return FALSE;
5365  }
5366  else {
5367  return ret;
5368  }
5369  }
5370  else {
5371  return FALSE;
5372  }
5373 }
5374 
5375 bool TDENetworkConnectionManager_BackendNM::wiFiHardwareEnabled() {
5376  if (d->m_networkManagerProxy) {
5377  bool ret;
5378  TQT_DBusError error;
5379  ret = d->m_networkManagerProxy->getWirelessHardwareEnabled(error);
5380  if (error.isValid()) {
5381  // Error!
5382  PRINT_ERROR((error.name() + ": " + error.message()))
5383  return FALSE;
5384  }
5385  else {
5386  return ret;
5387  }
5388  }
5389  else {
5390  return FALSE;
5391  }
5392 }
5393 
5394 bool TDENetworkConnectionManager_BackendNM::enableNetworking(bool enable) {
5395  // FIXME
5396  // Yes, this abuses the Sleep command
5397  // Is there a better way to do it?
5398  if (d->m_networkManagerProxy) {
5399  int asynccallid;
5400  TQT_DBusError error;
5401  d->m_networkManagerProxy->SleepAsync(asynccallid, !enable, error);
5402  if (error.isValid()) {
5403  // Error!
5404  PRINT_ERROR((error.name() + ": " + error.message()))
5405  return FALSE;
5406  }
5407  else {
5408  // FIXME
5409  // Wait for async reply before returning...
5410  return TRUE;
5411  }
5412  }
5413  else {
5414  return FALSE;
5415  }
5416 }
5417 
5418 bool TDENetworkConnectionManager_BackendNM::enableWiFi(bool enable) {
5419  if (d->m_networkManagerProxy) {
5420  TQT_DBusError error;
5421  d->m_networkManagerProxy->setWirelessEnabled(enable, error);
5422  if (error.isValid()) {
5423  // Error!
5424  PRINT_ERROR((error.name() + ": " + error.message()))
5425  return FALSE;
5426  }
5427  else {
5428  return TRUE;
5429  }
5430  }
5431  else {
5432  return FALSE;
5433  }
5434 }
5435 
5436 bool TDENetworkConnectionManager_BackendNM::wiFiEnabled() {
5437  if (d->m_networkManagerProxy) {
5438  bool ret;
5439  TQT_DBusError error;
5440  ret = d->m_networkManagerProxy->getWirelessEnabled(error);
5441  if (error.isValid()) {
5442  // Error!
5443  PRINT_ERROR((error.name() + ": " + error.message()))
5444  return FALSE;
5445  }
5446  else {
5447  return ret;
5448  }
5449  }
5450  else {
5451  return FALSE;
5452  }
5453 }
5454 
5455 TQStringList TDENetworkConnectionManager_BackendNM::defaultNetworkDevices() {
5456  // Cycle through all available connections and see which one is default, then find all devices for that connection...
5457  TQStringList ret;
5458 
5459  TQT_DBusObjectPath existingConnection;
5460  TQT_DBusError error;
5461  if (d->m_networkManagerProxy) {
5462  TQT_DBusObjectPathList activeConnections = d->m_networkManagerProxy->getActiveConnections(error);
5463  TQT_DBusObjectPathList::iterator it;
5464  for (it = activeConnections.begin(); it != activeConnections.end(); ++it) {
5465  DBus::ActiveConnectionProxy activeConnection(NM_DBUS_SERVICE, (*it));
5466  activeConnection.setConnection(TQT_DBusConnection::systemBus());
5467  if (activeConnection.getDefault(error)) {
5468  // This is the default ipv4 connection
5469  TQString uuid = activeConnection.getUuid(error);
5470  TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
5471  for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
5472  ret.append(*it);
5473  }
5474  }
5475  else if (activeConnection.getDefault6(error)) {
5476  // This is the default ipv6 connection
5477  TQString uuid = activeConnection.getUuid(error);
5478  TQStringList devices = connectionPhysicalDeviceUUIDs(uuid);
5479  for (TQStringList::Iterator it2 = devices.begin(); it2 != devices.end(); ++it2) {
5480  ret.append(*it);
5481  }
5482  }
5483  }
5484  return ret;
5485  }
5486  else {
5487  PRINT_ERROR(TQString("invalid internal network-manager settings proxy object"));
5488  return TQStringList();
5489  }
5490 }
5491 
5492 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) {
5493  // Set up global signal handler
5494  m_dbusSignalConnection = new TQT_DBusConnection(TQT_DBusConnection::systemBus());
5495  m_dbusSignalReceiver = new TDENetworkConnectionManager_BackendNM_DBusSignalReceiver(this);
5496  m_dbusSignalConnection->connect(m_dbusSignalReceiver, TQT_SLOT(dbusSignal(const TQT_DBusMessage&)));
5497 }
5498 
5499 TDENetworkConnectionManager_BackendNMPrivate::~TDENetworkConnectionManager_BackendNMPrivate() {
5500  // Destroy global signal handler
5501  if (m_dbusSignalConnection) delete m_dbusSignalConnection;
5502  if (m_dbusSignalReceiver) delete m_dbusSignalReceiver;
5503 
5504  // Destroy proxy objects
5505  TQMap<TQString, DBus::AccessPointProxy*>::iterator it;
5506  for (it = m_accessPointProxyList.begin(); it != m_accessPointProxyList.end(); ++it) {
5507  DBus::AccessPointProxy *apProxy = it.data();
5508  if (apProxy) {
5509  delete apProxy;
5510  }
5511  }
5512  m_accessPointProxyList.clear();
5513 }
5514 
5515 #include "network-manager.moc"
5516 #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
TDENetworkConnectionStatus
Definition: tdenetworkconnections.h:451
TDENetworkDeviceType
Definition: tdenetworkconnections.h:66
TDELocale::i18n
TQString i18n(const char *text)
Definition: tdelocale.cpp:1976
TDENetworkIPConfigurationFlags
Definition: tdenetworkconnections.h:476
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

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
  •     tdecore
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  • tdeioslave
  •   http
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdecore by doxygen 1.8.8
This website is maintained by Timothy Pearson.