00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include "tdehardwaredevices.h"
00020 #include "tdenetworkconnections.h"
00021
00022 #include <tqtimer.h>
00023
00024 #include <tdelocale.h>
00025
00026 #include "tdenetworkdevice.h"
00027
00028
00029 #include "config.h"
00030
00031 #ifdef WITH_NETWORK_MANAGER_BACKEND
00032 #include "network-manager.h"
00033 #endif // WITH_NETWORK_MANAGER_BACKEND
00034
00035 #define SET_BIT(x, y) (x |= 1 << y)
00036 #define TEST_BIT(x, y) ((x & (1 << y)) >> y)
00037
00038
00039
00040
00041
00042
00043 TDENetworkSearchDomain::TDENetworkSearchDomain() {
00044 m_isIPV6 = false;
00045 }
00046
00047 TDENetworkSearchDomain::TDENetworkSearchDomain(TQString domain, bool ipv6) {
00048 m_isIPV6 = ipv6;
00049 m_domain = domain;
00050 }
00051
00052 TDENetworkSearchDomain::~TDENetworkSearchDomain() {
00053
00054 }
00055
00056 TQString TDENetworkSearchDomain::searchDomain() {
00057 return m_domain;
00058 }
00059
00060 void TDENetworkSearchDomain::setSearchDomain(TQString domain, bool ipv6) {
00061 m_isIPV6 = ipv6;
00062 m_domain = domain;
00063 }
00064
00065 bool TDENetworkSearchDomain::isIPv4() {
00066 return !m_isIPV6;
00067 }
00068
00069 bool TDENetworkSearchDomain::isIPv6() {
00070 return m_isIPV6;
00071 }
00072
00073
00074
00075
00076
00077 TDENetMask::TDENetMask() {
00078 m_ipv4NetMask = 0;
00079 m_isIPV6 = false;
00080 }
00081
00082 TDENetMask::TDENetMask(TQ_UINT32 netmask) {
00083 m_ipv4NetMask = netmask;
00084 m_isIPV6 = false;
00085 }
00086
00087 TDENetMask::TDENetMask(TQ_UINT8* netmask) {
00088 m_ipv6NetMask = TQHostAddress(netmask);
00089 m_isIPV6 = true;
00090 }
00091
00092 TDENetMask::~TDENetMask() {
00093
00094 }
00095
00096 void TDENetMask::fromCIDRMask(unsigned char mask, bool ipv6) {
00097 unsigned int i;
00098 unsigned int j;
00099 unsigned int internalMask = mask;
00100 if (!ipv6) {
00101 m_ipv4NetMask = 0;
00102 for (i=32; i>(32-internalMask); ) {
00103 i--;
00104 SET_BIT(m_ipv4NetMask, i);
00105 }
00106 m_isIPV6 = false;
00107 }
00108 else {
00109 Q_IPV6ADDR maskarray;
00110 j=0;
00111 unsigned int byteno=0;
00112 memset(maskarray.c, 0, 16);
00113 for (i=128; i>(128-internalMask); ) {
00114 i--;
00115 SET_BIT(maskarray.c[byteno], (i-((15-byteno)*8)));
00116 j++;
00117 if (j>7) {
00118 j=0;
00119 byteno++;
00120 }
00121 }
00122 m_ipv6NetMask = TQHostAddress(maskarray);
00123 m_isIPV6 = true;
00124 }
00125 }
00126
00127 unsigned char TDENetMask::toCIDRMask() {
00128 unsigned int i;
00129 unsigned int j;
00130 if (!m_isIPV6) {
00131 for (i=0; i<32; i++) {
00132 if (TEST_BIT(m_ipv4NetMask, i)) {
00133 break;
00134 }
00135 }
00136 return 32-i;
00137 }
00138 else {
00139 Q_IPV6ADDR mask = m_ipv6NetMask.toIPv6Address();
00140 bool found = false;
00141 for (j=0; j<16; ++j) {
00142 for (i=0; i<8; i++) {
00143 if (!TEST_BIT(mask.c[j], i)) {
00144 found = true;
00145 break;
00146 }
00147 }
00148 if (found) break;
00149 }
00150 return ((j*8)+i);
00151 }
00152 }
00153
00154 void TDENetMask::fromString(TQString mask) {
00155 if (mask.contains(".")) {
00156 m_isIPV6 = false;
00157 m_ipv4NetMask = 0;
00158 TQStringList pieces = TQStringList::split(".", mask);
00159 TQ_UINT8 chunk;
00160 chunk = pieces[0].toUShort();
00161 m_ipv4NetMask = m_ipv4NetMask | (chunk << 24);
00162 chunk = pieces[1].toUShort();
00163 m_ipv4NetMask = m_ipv4NetMask | (chunk << 16);
00164 chunk = pieces[2].toUShort();
00165 m_ipv4NetMask = m_ipv4NetMask | (chunk << 8);
00166 chunk = pieces[3].toUShort();
00167 m_ipv4NetMask = m_ipv4NetMask | (chunk << 0);
00168 }
00169 else if (mask.contains(":")) {
00170 m_isIPV6 = true;
00171 m_ipv6NetMask.setAddress(mask);
00172 }
00173 }
00174
00175 TQString TDENetMask::toString() {
00176 if (!m_isIPV6) {
00177 return TQString("%1.%2.%3.%4").arg((m_ipv4NetMask & 0xff000000) >> 24).arg((m_ipv4NetMask & 0x00ff0000) >> 16).arg((m_ipv4NetMask & 0x0000ff00) >> 8).arg((m_ipv4NetMask & 0x000000ff) >> 0);
00178 }
00179 else {
00180 return m_ipv6NetMask.toString();
00181 }
00182 }
00183
00184 bool TDENetMask::isIPv4() {
00185 return !m_isIPV6;
00186 }
00187
00188 bool TDENetMask::isIPv6() {
00189 return m_isIPV6;
00190 }
00191
00192
00193
00194
00195
00196 TDEMACAddress::TDEMACAddress() {
00197 m_macAddress.clear();
00198 m_isValid = false;
00199 }
00200
00201 TDEMACAddress::TDEMACAddress(TDENetworkByteList address) {
00202 m_macAddress = address;
00203 m_isValid = true;
00204 }
00205
00206 TDEMACAddress::~TDEMACAddress() {
00207
00208 }
00209
00210 TDENetworkByteList TDEMACAddress::address() {
00211 return m_macAddress;
00212 }
00213
00214 void TDEMACAddress::setAddress(TDENetworkByteList address) {
00215 m_macAddress = address;
00216 m_isValid = true;
00217 }
00218
00219 bool TDEMACAddress::isValid() {
00220 if (!m_isValid) {
00221 return false;
00222 }
00223
00224 if (m_macAddress.count() > 0) {
00225 return true;
00226 }
00227 else {
00228 return false;
00229 }
00230 }
00231
00232 void TDEMACAddress::fromString(TQString address) {
00233 TQStringList pieces = TQStringList::split(":", address);
00234 m_macAddress.clear();
00235 for (TQStringList::Iterator it = pieces.begin(); it != pieces.end(); ++it) {
00236 m_macAddress.append((*it).toUShort(0, 16));
00237 }
00238 m_isValid = true;
00239 }
00240
00241 TQString TDEMACAddress::toString() {
00242 TQString ret;
00243 TDENetworkByteList::iterator it;
00244 for (it = m_macAddress.begin(); it != m_macAddress.end(); ++it) {
00245 if (ret != "") {
00246 ret.append(":");
00247 }
00248 ret.append(TQString().sprintf("%02x", *it));
00249 }
00250 return ret.lower();
00251 }
00252
00253 bool operator==(const TDEMACAddress &a1, const TDEMACAddress &a2) {
00254 if (a1.m_macAddress.count() != a2.m_macAddress.count()) {
00255 return false;
00256 }
00257 else {
00258 unsigned int i;
00259 for (i=0; i<a1.m_macAddress.count(); i++) {
00260 if (a1.m_macAddress[i] != a2.m_macAddress[i]) {
00261 return false;
00262 }
00263 }
00264 return true;
00265 }
00266 }
00267
00268 bool operator<(const TDEMACAddress &a1, const TDEMACAddress &a2) {
00269 if (a1.m_macAddress.count() < a2.m_macAddress.count()) {
00270 return true;
00271 }
00272 else {
00273 unsigned int i;
00274 for (i=0; i<a1.m_macAddress.count(); i++) {
00275 if (a1.m_macAddress[i] < a2.m_macAddress[i]) {
00276 return true;
00277 }
00278 if (a1.m_macAddress[i] > a2.m_macAddress[i]) {
00279 return false;
00280 }
00281 }
00282 return false;
00283 }
00284 }
00285
00286
00287
00288
00289
00290 TDENetworkSingleIPConfiguration::TDENetworkSingleIPConfiguration() {
00291 valid = false;
00292 }
00293
00294 TDENetworkSingleIPConfiguration::~TDENetworkSingleIPConfiguration() {
00295
00296 }
00297
00298 bool TDENetworkSingleIPConfiguration::isIPv4() {
00299 return ipAddress.isIPv4Address() & valid;
00300 }
00301
00302 bool TDENetworkSingleIPConfiguration::isIPv6() {
00303 return ipAddress.isIPv6Address() & valid;
00304 }
00305
00306
00307
00308
00309
00310 TDENetworkSingleRouteConfiguration::TDENetworkSingleRouteConfiguration() {
00311 valid = false;
00312 }
00313
00314 TDENetworkSingleRouteConfiguration::~TDENetworkSingleRouteConfiguration() {
00315
00316 }
00317
00318 bool TDENetworkSingleRouteConfiguration::isIPv4() {
00319 return ipAddress.isIPv4Address() & valid;
00320 }
00321
00322 bool TDENetworkSingleRouteConfiguration::isIPv6() {
00323 return ipAddress.isIPv6Address() & valid;
00324 }
00325
00326
00327
00328
00329
00330 TDENetworkIEEE8021xConfiguration::TDENetworkIEEE8021xConfiguration() {
00331 valid = false;
00332 allowedValid = false;
00333 secretsValid = false;
00334 type = TDENetworkIEEE8021xType::None;
00335 fastProvisioningFlags = TDENetworkIEEE8021xFastFlags::None;
00336 phase2NonEAPAuthMethod = TDENetworkIEEE8021xType::None;
00337 phase2EAPAuthMethod = TDENetworkIEEE8021xType::None;
00338 passwordFlags = TDENetworkPasswordHandlingFlags::None;
00339 binaryPasswordFlags = TDENetworkPasswordHandlingFlags::None;
00340 privateKeyPasswordFlags = TDENetworkPasswordHandlingFlags::None;
00341 phase2PrivateKeyPasswordFlags = TDENetworkPasswordHandlingFlags::None;
00342 forceSystemCaCertificates = false;
00343 }
00344
00345 TDENetworkIEEE8021xConfiguration::~TDENetworkIEEE8021xConfiguration() {
00346
00347 }
00348
00349
00350
00351
00352
00353 TDENetworkPPPConfiguration::TDENetworkPPPConfiguration() {
00354 valid = false;
00355 requireServerAuthentication = false;
00356 flags = TDENetworkPPPFlags::None;
00357 baudRate = 115200;
00358 mru = 0;
00359 mtu = 0;
00360 lcpEchoPingInterval = 0;
00361 lcpEchoFailureThreshold = 0;
00362 }
00363
00364 TDENetworkPPPConfiguration::~TDENetworkPPPConfiguration() {
00365
00366 }
00367
00368
00369
00370
00371
00372 TDENetworkPPPOEConfiguration::TDENetworkPPPOEConfiguration() {
00373 valid = false;
00374 secretsValid = false;
00375 passwordFlags = TDENetworkPasswordHandlingFlags::None;
00376 }
00377
00378 TDENetworkPPPOEConfiguration::~TDENetworkPPPOEConfiguration() {
00379
00380 }
00381
00382
00383
00384
00385
00386 TDENetworkSerialConfiguration::TDENetworkSerialConfiguration() {
00387 valid = false;
00388 baudRate = 115200;
00389 byteWidth = 8;
00390 parity = TDENetworkParity::None;
00391 stopBits = 1;
00392 txDelay = 0;
00393 }
00394
00395 TDENetworkSerialConfiguration::~TDENetworkSerialConfiguration() {
00396
00397 }
00398
00399
00400
00401
00402
00403 TDENetworkCDMAConfiguration::TDENetworkCDMAConfiguration() {
00404 valid = false;
00405 secretsValid = false;
00406 passwordFlags = TDENetworkPasswordHandlingFlags::None;
00407 }
00408
00409 TDENetworkCDMAConfiguration::~TDENetworkCDMAConfiguration() {
00410
00411 }
00412
00413
00414
00415
00416
00417 TDENetworkGSMConfiguration::TDENetworkGSMConfiguration() {
00418 valid = false;
00419 secretsValid = false;
00420 passwordFlags = TDENetworkPasswordHandlingFlags::None;
00421 networkType = TDEGSMNetworkType::Any;
00422 pinFlags = TDENetworkPasswordHandlingFlags::None;
00423 allowRoaming = false;
00424 }
00425
00426 TDENetworkGSMConfiguration::~TDENetworkGSMConfiguration() {
00427
00428 }
00429
00430
00431
00432
00433
00434 TDENetworkIPConfiguration::TDENetworkIPConfiguration() {
00435 valid = false;
00436 connectionFlags = TDENetworkIPConfigurationFlags::IPV4DHCPIP | \
00437 TDENetworkIPConfigurationFlags::IPV4DHCPDNS | \
00438 TDENetworkIPConfigurationFlags::IPV4DHCPRoutes | \
00439 TDENetworkIPConfigurationFlags::IPV4MayUseAsDefaultRoute | \
00440 TDENetworkIPConfigurationFlags::IPV6DHCPIP | \
00441 TDENetworkIPConfigurationFlags::IPV6DHCPDNS | \
00442 TDENetworkIPConfigurationFlags::IPV6DHCPRoutes | \
00443 TDENetworkIPConfigurationFlags::IPV6MayUseAsDefaultRoute;
00444 }
00445
00446 TDENetworkIPConfiguration::~TDENetworkIPConfiguration() {
00447
00448 }
00449
00450
00451
00452
00453
00454 TDENetworkWiFiSecurityConfiguration::TDENetworkWiFiSecurityConfiguration() {
00455 valid = false;
00456 secretsValid = false;
00457 keyType = TDENetworkWiFiKeyType::Other;
00458 authType = TDENetworkWiFiAuthType::Other;
00459 wpaVersion = TDENetworkWiFiWPAVersionFlags::Any;
00460 cipher = TDENetworkWiFiConnectionCipher::None;
00461 wepKeyFlags = TDENetworkPasswordHandlingFlags::None;
00462 wepKeyIndex = 0;
00463 wepKeyType = TDENetworkWepKeyType::Hexadecimal;
00464 pskFlags = TDENetworkPasswordHandlingFlags::None;
00465 leapPasswordFlags = TDENetworkPasswordHandlingFlags::None;
00466 }
00467
00468 TDENetworkWiFiSecurityConfiguration::~TDENetworkWiFiSecurityConfiguration() {
00469
00470 }
00471
00472
00473
00474
00475
00476 TDENetworkWiFiDeviceInfo::TDENetworkWiFiDeviceInfo() {
00477 valid = false;
00478 }
00479
00480 TDENetworkWiFiDeviceInfo::~TDENetworkWiFiDeviceInfo() {
00481
00482 }
00483
00484
00485
00486
00487
00488 TDENetworkDeviceInformation::TDENetworkDeviceInformation() {
00489 valid = false;
00490 statusFlags = TDENetworkConnectionStatus::Invalid;
00491 capabilityFlags = TDENetworkDeviceCapabilityFlags::None;
00492 }
00493
00494 TDENetworkDeviceInformation::~TDENetworkDeviceInformation() {
00495
00496 }
00497
00498
00499
00500
00501
00502 TDENetworkHWNeighbor::TDENetworkHWNeighbor() {
00503 valid = false;
00504 }
00505
00506 TDENetworkHWNeighbor::~TDENetworkHWNeighbor() {
00507
00508 }
00509
00510
00511
00512
00513
00514 TDENetworkWiFiAPInfo::TDENetworkWiFiAPInfo() : TDENetworkHWNeighbor() {
00515
00516 }
00517
00518 TDENetworkWiFiAPInfo::~TDENetworkWiFiAPInfo() {
00519
00520 }
00521
00522 TQString TDENetworkWiFiAPInfo::friendlySSID() const {
00523 TQString ret;
00524
00525 ret = TQString(SSID);
00526 if (ret == "") {
00527 ret = "<" + i18n("hidden") + ">";
00528 }
00529
00530 return ret;
00531 }
00532
00533
00534
00535
00536
00537 TDENetworkConnection::TDENetworkConnection() {
00538 readOnly = false;
00539 autoConnect = false;
00540 fullDuplex = true;
00541 requireIPV4 = false;
00542 requireIPV6 = false;
00543 mtu = 0;
00544 }
00545
00546 TDENetworkConnection::~TDENetworkConnection() {
00547
00548 }
00549
00550 TDENetworkConnectionType::TDENetworkConnectionType TDENetworkConnection::type() {
00551 if (dynamic_cast<TDEWiredEthernetConnection*>(this)) {
00552 return TDENetworkConnectionType::WiredEthernet;
00553 }
00554 else if (dynamic_cast<TDEWiredInfinibandConnection*>(this)) {
00555 return TDENetworkConnectionType::Infiniband;
00556 }
00557 else if (dynamic_cast<TDEVPNConnection*>(this)) {
00558 return TDENetworkConnectionType::VPN;
00559 }
00560 else if (dynamic_cast<TDEWiMaxConnection*>(this)) {
00561 return TDENetworkConnectionType::WiMax;
00562 }
00563 else if (dynamic_cast<TDEVLANConnection*>(this)) {
00564 return TDENetworkConnectionType::VLAN;
00565 }
00566 else if (dynamic_cast<TDEOLPCMeshConnection*>(this)) {
00567 return TDENetworkConnectionType::OLPCMesh;
00568 }
00569 else if (dynamic_cast<TDEBluetoothConnection*>(this)) {
00570 return TDENetworkConnectionType::Bluetooth;
00571 }
00572 else if (dynamic_cast<TDEModemConnection*>(this)) {
00573 return TDENetworkConnectionType::Modem;
00574 }
00575 else if (dynamic_cast<TDEWiFiConnection*>(this)) {
00576 return TDENetworkConnectionType::WiFi;
00577 }
00578 else {
00579 return TDENetworkConnectionType::Other;
00580 }
00581 }
00582
00583
00584
00585
00586
00587 TDEWiredEthernetConnection::TDEWiredEthernetConnection() : TDENetworkConnection() {
00588
00589 }
00590
00591 TDEWiredEthernetConnection::~TDEWiredEthernetConnection() {
00592
00593 }
00594
00595
00596
00597
00598
00599 TDEWiredInfinibandConnection::TDEWiredInfinibandConnection() : TDENetworkConnection() {
00600
00601 }
00602
00603 TDEWiredInfinibandConnection::~TDEWiredInfinibandConnection() {
00604
00605 }
00606
00607
00608
00609
00610
00611 TDEVPNConnection::TDEVPNConnection() : TDENetworkConnection() {
00612 secretsValid = false;
00613 }
00614
00615 TDEVPNConnection::~TDEVPNConnection() {
00616
00617 }
00618
00619
00620
00621
00622
00623 TDEWiMaxConnection::TDEWiMaxConnection() : TDENetworkConnection() {
00624
00625 }
00626
00627 TDEWiMaxConnection::~TDEWiMaxConnection() {
00628
00629 }
00630
00631
00632
00633
00634
00635 TDEVLANConnection::TDEVLANConnection() : TDENetworkConnection() {
00636
00637 }
00638
00639 TDEVLANConnection::~TDEVLANConnection() {
00640
00641 }
00642
00643
00644
00645
00646
00647 TDEOLPCMeshConnection::TDEOLPCMeshConnection() : TDENetworkConnection() {
00648 channel = 0;
00649 }
00650
00651 TDEOLPCMeshConnection::~TDEOLPCMeshConnection() {
00652
00653 }
00654
00655
00656
00657
00658
00659 TDEBluetoothConnection::TDEBluetoothConnection() : TDENetworkConnection() {
00660 type = TDEBluetoothConnectionType::Other;
00661 }
00662
00663 TDEBluetoothConnection::~TDEBluetoothConnection() {
00664
00665 }
00666
00667
00668
00669
00670
00671 TDEModemConnection::TDEModemConnection() : TDENetworkConnection() {
00672 type = TDEModemConnectionType::Other;
00673 }
00674
00675 TDEModemConnection::~TDEModemConnection() {
00676
00677 }
00678
00679
00680
00681
00682
00683 TDEWiFiConnection::TDEWiFiConnection() : TDENetworkConnection() {
00684 operatingMode = TDEWiFiMode::Other;
00685 bandRestriction = TDEWiFiFrequencyBand::None;
00686 channelRestriction = -1;
00687 bitRateRestriction = -1;
00688 powerRestriction = -1;
00689 isHiddenNetwork = false;
00690 securityRequired = false;
00691 }
00692
00693 TDEWiFiConnection::~TDEWiFiConnection() {
00694
00695 }
00696
00697
00698
00699
00700
00701 TDENetworkConnectionManager::TDENetworkConnectionManager(TDENetworkDevice *networkDevice) : TQObject(), m_connectionList(NULL), m_hwNeighborList(NULL), m_networkDevice(networkDevice), m_prevConnectionStatus(TDENetworkGlobalManagerFlags::Unknown) {
00702 m_emissionTimer = new TQTimer();
00703 connect(m_emissionTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(emitQueuedSignals()));
00704 if (!m_emissionTimer->isActive()) m_emissionTimer->start(0, TRUE);
00705 }
00706
00707 TDENetworkConnectionManager::~TDENetworkConnectionManager() {
00708 m_emissionTimer->stop();
00709 delete m_emissionTimer;
00710 }
00711
00712 TQString TDENetworkConnectionManager::deviceNode() {
00713 return m_networkDevice ? m_networkDevice->deviceNode() : TQString();
00714 }
00715
00716 TQString TDENetworkConnectionManager::deviceMACAddress() {
00717 return m_networkDevice ? m_networkDevice->macAddress() : TQString();
00718 }
00719
00720 TDENetworkConnectionList* TDENetworkConnectionManager::connections() {
00721 return m_connectionList;
00722 }
00723
00724 TDENetworkConnection* TDENetworkConnectionManager::findConnectionByUUID(TQString uuid) {
00725 TDENetworkConnection *connection;
00726 for (connection = m_connectionList->first(); connection; connection = m_connectionList->next()) {
00727 if (connection->UUID == uuid) {
00728 return connection;
00729 }
00730 }
00731 return NULL;
00732 }
00733
00734 TDENetworkDevice* TDENetworkConnectionManager::findDeviceByUUID(TQString uuid) {
00735 TDEHardwareDevices *hwdevices = TDEGlobal::hardwareDevices();
00736 if (!hwdevices) return NULL;
00737
00738 TDEGenericHardwareList devices = hwdevices->listByDeviceClass(TDEGenericDeviceType::Network);
00739 for (TDEGenericHardwareList::iterator it = devices.begin(); it != devices.end(); ++it)
00740 {
00741 TDENetworkDevice* dev = dynamic_cast<TDENetworkDevice*>(*it);
00742 if (dev) {
00743 TDENetworkConnectionManager* deviceConnectionManager = dev->connectionManager();
00744 if (deviceConnectionManager) {
00745 if (deviceConnectionManager->deviceInformation().UUID == uuid) {
00746 return dev;
00747 }
00748 }
00749 }
00750 }
00751
00752 return NULL;
00753 }
00754
00755 TDENetworkWiFiAPInfo* TDENetworkConnectionManager::findAccessPointByBSSID(TDEMACAddress bssid) {
00756 if (!bssid.isValid()) {
00757 return NULL;
00758 }
00759
00760 TDENetworkHWNeighbor *neighbor;
00761 for (neighbor = m_hwNeighborList->first(); neighbor; neighbor = m_hwNeighborList->next()) {
00762 TDENetworkWiFiAPInfo* apInfo = dynamic_cast<TDENetworkWiFiAPInfo*>(neighbor);
00763 if (!apInfo) {
00764 continue;
00765 }
00766 if (apInfo->BSSID == bssid) {
00767 return apInfo;
00768 }
00769 }
00770 return NULL;
00771 }
00772
00773 TQString TDENetworkConnectionManager::friendlyConnectionTypeName(TDENetworkConnectionType::TDENetworkConnectionType type) {
00774 if (type == TDENetworkConnectionType::WiredEthernet) {
00775 return i18n("Wired Ethernet");
00776 }
00777 else if (type == TDENetworkConnectionType::WiFi) {
00778 return i18n("802.11 WiFi");
00779 }
00780 else if (type == TDENetworkConnectionType::Bluetooth) {
00781 return i18n("Bluetooth");
00782 }
00783 else if (type == TDENetworkConnectionType::OLPCMesh) {
00784 return i18n("OLPC Mesh");
00785 }
00786 else if (type == TDENetworkConnectionType::WiMax) {
00787 return i18n("WiMax");
00788 }
00789 else if (type == TDENetworkConnectionType::Modem) {
00790 return i18n("Cellular Modem");
00791 }
00792 else if (type == TDENetworkConnectionType::Infiniband) {
00793 return i18n("Infiniband");
00794 }
00795 else if (type == TDENetworkConnectionType::Bond) {
00796 return i18n("Bond");
00797 }
00798 else if (type == TDENetworkConnectionType::VLAN) {
00799 return i18n("Virtual LAN");
00800 }
00801 else if (type == TDENetworkConnectionType::ADSL) {
00802 return i18n("ADSL");
00803 }
00804 else if (type == TDENetworkConnectionType::VPN) {
00805 return i18n("Virtual Private Network");
00806 }
00807 else if (type == TDENetworkConnectionType::Other) {
00808 return i18n("Other");
00809 }
00810 else {
00811 return TQString::null;
00812 }
00813 }
00814
00815 bool TDENetworkConnectionManager::validateIPAddress(TQHostAddress address) {
00816 if (address.isIPv4Address()) {
00817 TQ_UINT32 rawaddress = address.toIPv4Address();
00818 if ((((rawaddress & 0xff000000) >> 24) == 0) || ((rawaddress & 0x000000ff) == 0) || ((rawaddress & 0x000000ff) == 255)) {
00819 return false;
00820 }
00821 }
00822 else if (address.isIPv6Address()) {
00823 Q_IPV6ADDR rawaddress = address.toIPv6Address();
00824 if (rawaddress.c[0] == 0xff) {
00825 return false;
00826 }
00827 }
00828 return true;
00829 }
00830
00831 bool TDENetworkConnectionManager::validateIPNeworkMask(TQHostAddress netmask) {
00832 Q_UNUSED(netmask);
00833 return TRUE;
00834 }
00835
00836 void TDENetworkConnectionManager::clearTDENetworkConnectionList() {
00837 TDENetworkConnection *connection;
00838 for (connection = m_connectionList->first(); connection; connection = m_connectionList->next()) {
00839 delete connection;
00840 }
00841 m_connectionList->clear();
00842 }
00843
00844 void TDENetworkConnectionManager::clearTDENetworkHWNeighborList() {
00845 TDENetworkHWNeighbor *neighbor;
00846 for (neighbor = m_hwNeighborList->first(); neighbor; neighbor = m_hwNeighborList->next()) {
00847 delete neighbor;
00848 }
00849 m_hwNeighborList->clear();
00850 }
00851
00852 void TDENetworkConnectionManager::internalNetworkConnectionStateChanged(TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags newState) {
00853 TDENetworkEventQueueEvent_Private queuedEvent;
00854 queuedEvent.eventType = 0;
00855 queuedEvent.newState = newState;
00856 queuedEvent.previousState = m_prevConnectionStatus;
00857 m_globalEventQueueEventList.append(queuedEvent);
00858 if (!m_emissionTimer->isActive()) m_emissionTimer->start(0, TRUE);
00859
00860 m_prevConnectionStatus = newState;
00861 }
00862
00863 void TDENetworkConnectionManager::internalNetworkDeviceStateChanged(TDENetworkConnectionStatus::TDENetworkConnectionStatus newState, TQString deviceNodeName) {
00864 if (!m_prevDeviceStatus.contains(deviceNodeName)) {
00865 m_prevDeviceStatus[deviceNodeName] = TDENetworkConnectionStatus::Invalid;
00866 }
00867
00868 TDENetworkEventQueueEvent_Private queuedEvent;
00869 queuedEvent.eventType = 1;
00870 queuedEvent.newConnStatus = newState;
00871 queuedEvent.previousConnStatus = m_prevDeviceStatus[deviceNodeName];
00872 queuedEvent.deviceNode = deviceNodeName;
00873 m_globalEventQueueEventList.append(queuedEvent);
00874 if (!m_emissionTimer->isActive()) m_emissionTimer->start(0, TRUE);
00875
00876 m_prevDeviceStatus[deviceNodeName] = newState;
00877 }
00878
00879 void TDENetworkConnectionManager::internalAccessPointStatusChanged(TDEMACAddress BSSID, TDENetworkAPEventType::TDENetworkAPEventType event) {
00880 TDENetworkEventQueueEvent_Private queuedEvent;
00881 queuedEvent.eventType = 2;
00882 queuedEvent.BSSID = BSSID;
00883 queuedEvent.apevent = event;
00884 m_globalEventQueueEventList.append(queuedEvent);
00885 if (!m_emissionTimer->isActive()) m_emissionTimer->start(0, TRUE);
00886 }
00887
00888 void TDENetworkConnectionManager::internalNetworkDeviceEvent(TDENetworkDeviceEventType::TDENetworkDeviceEventType event, TQString message) {
00889 TDENetworkEventQueueEvent_Private queuedEvent;
00890 queuedEvent.eventType = 3;
00891 queuedEvent.ndevent = event;
00892 queuedEvent.message = message;
00893 m_globalEventQueueEventList.append(queuedEvent);
00894 if (!m_emissionTimer->isActive()) m_emissionTimer->start(0, TRUE);
00895 }
00896
00897 void TDENetworkConnectionManager::internalVpnEvent(TDENetworkVPNEventType::TDENetworkVPNEventType event, TQString message) {
00898 TDENetworkEventQueueEvent_Private queuedEvent;
00899 queuedEvent.eventType = 4;
00900 queuedEvent.vpnevent = event;
00901 queuedEvent.message = message;
00902 m_globalEventQueueEventList.append(queuedEvent);
00903 if (!m_emissionTimer->isActive()) m_emissionTimer->start(0, TRUE);
00904 }
00905
00906 void TDENetworkConnectionManager::internalNetworkManagementEvent(TDENetworkGlobalEventType::TDENetworkGlobalEventType event) {
00907 TDENetworkEventQueueEvent_Private queuedEvent;
00908 queuedEvent.eventType = 5;
00909 queuedEvent.globalevent = event;
00910 m_globalEventQueueEventList.append(queuedEvent);
00911 if (!m_emissionTimer->isActive()) m_emissionTimer->start(0, TRUE);
00912 }
00913
00914 void TDENetworkConnectionManager::emitQueuedSignals() {
00915 if (!m_globalEventQueueEventList.isEmpty()) {
00916 #ifdef DEBUG_SIGNAL_QUEUE
00917 kdDebug() << "TDENetworkConnectionManager::emitQueuedSignals: Going to dequeue " << m_globalEventQueueEventList.count() << " events..." << endl;
00918 #endif // DEBUG_SIGNAL_QUEUE
00919 TDENetworkEventQueueEvent_PrivateList::Iterator it;
00920 it = m_globalEventQueueEventList.begin();
00921 while (it != m_globalEventQueueEventList.end()) {
00922 TDENetworkEventQueueEvent_Private event = (*it);
00923 it = m_globalEventQueueEventList.remove(it);
00924 if (event.eventType == 0) {
00925 emit(networkConnectionStateChanged(event.newState, event.previousState));
00926 }
00927 else if (event.eventType == 1) {
00928 emit(networkDeviceStateChanged(event.newConnStatus, event.previousConnStatus, event.deviceNode));
00929 }
00930 else if (event.eventType == 2) {
00931 emit(accessPointStatusChanged(event.BSSID, event.apevent));
00932 }
00933 else if (event.eventType == 3) {
00934 emit(networkDeviceEvent(event.ndevent, event.message));
00935 }
00936 else if (event.eventType == 4) {
00937 emit(vpnEvent(event.vpnevent, event.message));
00938 }
00939 else if (event.eventType == 5) {
00940 emit(networkManagementEvent(event.globalevent));
00941 }
00942 }
00943 #ifdef DEBUG_SIGNAL_QUEUE
00944 kdDebug() << "TDENetworkConnectionManager::emitQueuedSignals: " << m_globalEventQueueEventList.count() << " events remain in queue" << endl;
00945 #endif // DEBUG_SIGNAL_QUEUE
00946 }
00947 }
00948
00949
00950
00951
00952
00953 TDEGlobalNetworkManager::TDEGlobalNetworkManager() : m_internalConnectionManager(NULL) {
00954 #ifdef WITH_NETWORK_MANAGER_BACKEND
00955 m_internalConnectionManager = new TDENetworkConnectionManager_BackendNM(NULL);
00956 #endif // WITH_NETWORK_MANAGER_BACKEND
00957 if (m_internalConnectionManager) {
00958 connect(m_internalConnectionManager, SIGNAL(networkConnectionStateChanged(TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags, TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags)), this, SIGNAL(networkConnectionStateChanged(TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags, TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags)));
00959 connect(m_internalConnectionManager, SIGNAL(vpnEvent(TDENetworkVPNEventType::TDENetworkVPNEventType, TQString)), this, SIGNAL(vpnEvent(TDENetworkVPNEventType::TDENetworkVPNEventType, TQString)));
00960 connect(m_internalConnectionManager, SIGNAL(networkManagementEvent(TDENetworkGlobalEventType::TDENetworkGlobalEventType)), this, SIGNAL(networkManagementEvent(TDENetworkGlobalEventType::TDENetworkGlobalEventType)));
00961 }
00962 }
00963
00964 TDEGlobalNetworkManager::~TDEGlobalNetworkManager() {
00965 delete m_internalConnectionManager;
00966 }
00967
00968 TQString TDEGlobalNetworkManager::backendName() {
00969 if (!m_internalConnectionManager) return TQString::null;
00970 return m_internalConnectionManager->backendName();
00971 }
00972
00973 TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags TDEGlobalNetworkManager::backendStatus() {
00974 if (!m_internalConnectionManager) return TDENetworkGlobalManagerFlags::BackendUnavailable;
00975 return m_internalConnectionManager->backendStatus();
00976 }
00977
00978 void TDEGlobalNetworkManager::loadConnectionInformation() {
00979 if (!m_internalConnectionManager) return;
00980 return m_internalConnectionManager->loadConnectionInformation();
00981 }
00982
00983 void TDEGlobalNetworkManager::loadConnectionAllowedValues(TDENetworkConnection* connection) {
00984 if (!m_internalConnectionManager) return;
00985 return m_internalConnectionManager->loadConnectionAllowedValues(connection);
00986 }
00987
00988 bool TDEGlobalNetworkManager::loadConnectionSecrets(TQString uuid) {
00989 if (!m_internalConnectionManager) return false;
00990 return m_internalConnectionManager->loadConnectionSecrets(uuid);
00991 }
00992
00993 bool TDEGlobalNetworkManager::saveConnection(TDENetworkConnection* connection) {
00994 if (!m_internalConnectionManager) return false;
00995 return m_internalConnectionManager->saveConnection(connection);
00996 }
00997
00998 bool TDEGlobalNetworkManager::deleteConnection(TQString uuid) {
00999 if (!m_internalConnectionManager) return false;
01000 return m_internalConnectionManager->deleteConnection(uuid);
01001 }
01002
01003 bool TDEGlobalNetworkManager::verifyConnectionSettings(TDENetworkConnection* connection, TDENetworkConnectionErrorFlags::TDENetworkConnectionErrorFlags* type, TDENetworkErrorStringMap* reason) {
01004 if (!m_internalConnectionManager) return false;
01005 return m_internalConnectionManager->verifyConnectionSettings(connection, type, reason);
01006 }
01007
01008 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDEGlobalNetworkManager::initiateConnection(TQString uuid) {
01009 if (!m_internalConnectionManager) return TDENetworkConnectionStatus::Invalid;
01010 return m_internalConnectionManager->initiateConnection(uuid);
01011 }
01012
01013 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDEGlobalNetworkManager::checkConnectionStatus(TQString uuid) {
01014 if (!m_internalConnectionManager) return TDENetworkConnectionStatus::Invalid;
01015 return m_internalConnectionManager->checkConnectionStatus(uuid);
01016 }
01017
01018 TDENetworkConnectionStatus::TDENetworkConnectionStatus TDEGlobalNetworkManager::deactivateConnection(TQString uuid) {
01019 if (!m_internalConnectionManager) return TDENetworkConnectionStatus::Invalid;
01020 return m_internalConnectionManager->deactivateConnection(uuid);
01021 }
01022
01023 TQStringList TDEGlobalNetworkManager::validSettings() {
01024 if (!m_internalConnectionManager) return TQStringList();
01025 return m_internalConnectionManager->validSettings();
01026 }
01027
01028 TDENetworkHWNeighborList* TDEGlobalNetworkManager::siteSurvey() {
01029 if (!m_internalConnectionManager) return NULL;
01030 return m_internalConnectionManager->siteSurvey();
01031 }
01032
01033 TQStringList TDEGlobalNetworkManager::connectionPhysicalDeviceUUIDs(TQString uuid) {
01034 if (!m_internalConnectionManager) return TQStringList();
01035 return m_internalConnectionManager->connectionPhysicalDeviceUUIDs(uuid);
01036 }
01037
01038 TDENetworkVPNTypeList TDEGlobalNetworkManager::availableVPNTypes() {
01039 if (!m_internalConnectionManager) return TDENetworkVPNTypeList();
01040 return m_internalConnectionManager->availableVPNTypes();
01041 }
01042
01043 bool TDEGlobalNetworkManager::networkingEnabled() {
01044 if (!m_internalConnectionManager) return false;
01045 return m_internalConnectionManager->networkingEnabled();
01046 }
01047
01048 bool TDEGlobalNetworkManager::enableNetworking(bool enable) {
01049 if (!m_internalConnectionManager) return false;
01050 return m_internalConnectionManager->enableNetworking(enable);
01051 }
01052
01053 bool TDEGlobalNetworkManager::wiFiHardwareEnabled() {
01054 if (!m_internalConnectionManager) return false;
01055 return m_internalConnectionManager->wiFiHardwareEnabled();
01056 }
01057
01058 bool TDEGlobalNetworkManager::enableWiFi(bool enable) {
01059 if (!m_internalConnectionManager) return false;
01060 return m_internalConnectionManager->enableWiFi(enable);
01061 }
01062
01063 bool TDEGlobalNetworkManager::wiFiEnabled() {
01064 if (!m_internalConnectionManager) return false;
01065 return m_internalConnectionManager->wiFiEnabled();
01066 }
01067
01068 TQStringList TDEGlobalNetworkManager::defaultNetworkDevices() {
01069 if (!m_internalConnectionManager) return TQStringList();
01070 return m_internalConnectionManager->defaultNetworkDevices();
01071 }
01072
01073 TDENetworkConnectionList* TDEGlobalNetworkManager::connections() {
01074 if (!m_internalConnectionManager) return NULL;
01075 return m_internalConnectionManager->connections();
01076 }
01077
01078 TDENetworkConnection* TDEGlobalNetworkManager::findConnectionByUUID(TQString uuid) {
01079 if (!m_internalConnectionManager) return NULL;
01080 return m_internalConnectionManager->findConnectionByUUID(uuid);
01081 }
01082
01083 TDENetworkDevice* TDEGlobalNetworkManager::findDeviceByUUID(TQString uuid) {
01084 if (!m_internalConnectionManager) return NULL;
01085 return m_internalConnectionManager->findDeviceByUUID(uuid);
01086 }
01087
01088 TDENetworkWiFiAPInfo* TDEGlobalNetworkManager::findAccessPointByBSSID(TDEMACAddress bssid) {
01089 TDEHardwareDevices *hwdevices = TDEGlobal::hardwareDevices();
01090 if (!hwdevices) {
01091 return NULL;
01092 }
01093
01094 TDENetworkWiFiAPInfo* ret = NULL;
01095 TDEGenericHardwareList devices = hwdevices->listByDeviceClass(TDEGenericDeviceType::Network);
01096 for (TDEGenericHardwareList::iterator it = devices.begin(); it != devices.end(); ++it) {
01097 TDENetworkDevice* dev = dynamic_cast<TDENetworkDevice*>(*it);
01098 if (dev) {
01099 TDENetworkConnectionManager* deviceConnMan = dev->connectionManager();
01100 TDENetworkWiFiAPInfo* candidate = deviceConnMan->findAccessPointByBSSID(bssid);
01101 if (candidate) {
01102 ret = candidate;
01103 }
01104 }
01105 }
01106
01107 return ret;
01108 }
01109
01110
01111
01112
01113
01114 #include "tdenetworkconnections.moc"