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

tdecore

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

tdecore

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