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

tdecore

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

tdecore

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

tdecore

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