tdenetworkconnections.h

/* This file is part of the TDE libraries
   Copyright (C) 2012 Timothy Pearson <kb9vqf@pearsoncomputing.net>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/
#ifndef _TDENETWORKCONNECTIONS_H
#define _TDENETWORKCONNECTIONS_H
 
// TDE includes
#include <tqobject.h>
#include <tqstring.h>
#include <tqptrlist.h>
#include <tqdatetime.h>
#include <tqstringlist.h>
#include <tqhostaddress.h>
#include "kiconloader.h"
#include "tdelibs_export.h"
 
#define CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(x)                                                       \
    inline x operator|(x a, x b)                                                                \
    {                                                                           \
        return static_cast<x>(static_cast<int>(a) | static_cast<int>(b));                                       \
    }                                                                           \
                                                                                \
    inline x operator&(x a, x b)                                                                \
    {                                                                           \
        return static_cast<x>(static_cast<int>(a) & static_cast<int>(b));                                       \
    }                                                                           \
                                                                                \
    inline x operator~(x a)                                                                 \
    {                                                                           \
        return static_cast<x>(~static_cast<int>(a));                                                    \
    }                                                                           \
                                                                                \
    inline x &operator|=(x& a, const x& b)                                                          \
    {                                                                           \
        a = static_cast<x>(static_cast<int>(a) | static_cast<int>(b));                                          \
        return a;                                                                   \
    }                                                                           \
                                                                                \
    inline x &operator&=(x& a, const x& b)                                                          \
    {                                                                           \
        a = static_cast<x>(static_cast<int>(a) & static_cast<int>(b));                                          \
        return a;                                                                   \
    }
 
class TDENetworkDevice;
 
typedef TQValueList<TQ_UINT8> TDENetworkByteList;
typedef TQValueList<TQHostAddress> TDENetworkAddressList;
typedef TQMap<TQString, TQString> TDENetworkSettingsMap;
typedef TQMap<TQ_UINT32, TQ_UINT32> TDENetworkPriorityMap;
 
namespace TDENetworkDeviceType {
    enum TDENetworkDeviceType {
        BackendOnly,
        WiredEthernet,
        WiFi,
        Bluetooth,
        OLPCMesh,
        WiMax,
        Modem,
        Infiniband,
        Bond,
        VLAN,
        ADSL,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkConnectionType {
    enum TDENetworkConnectionType {
        WiredEthernet,
        WiFi,
        Bluetooth,
        OLPCMesh,
        WiMax,
        Modem,
        Infiniband,
        Bond,
        VLAN,
        ADSL,
        VPN,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkConnectionErrorFlags {
    enum TDENetworkConnectionErrorFlags {
        NoError             = 0x00000000,
        InvalidConnectionSetting    = 0x00000001,
        InvalidIPv4Setting      = 0x00000002,
        InvalidIPv6Setting      = 0x00000004,
        InvalidEAPSetting       = 0x00000008,
        InvalidEAPKey           = 0x00000010,
        InvalidWirelessSetting      = 0x00000020,
        InvalidWirelessKey      = 0x00000040
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkConnectionErrorFlags)
};
 
typedef TQMap<TDENetworkConnectionErrorFlags::TDENetworkConnectionErrorFlags, TQString> TDENetworkErrorStringMap;
 
namespace TDENetworkInfinibandTransportMode {
    enum TDENetworkInfinibandTransportMode {
        Datagram,
        Connected,
        Other,
        Last = Other
    };
};
 
namespace TDEWiFiMode {
    enum TDEWiFiMode {
        AdHoc,
        Infrastructure,
        Other,
        Last = Other
    };
};
 
namespace TDEWiFiFrequencyBand {
    enum TDEWiFiFrequencyBand {
        None,
        Band2_4GHz,
        Band5GHz,
        Other,
        Last = Other
    };
};
 
namespace TDEBluetoothConnectionType {
    enum TDEBluetoothConnectionType {
        DUN,
        PAN,
        Other,
        Last = Other
    };
};
 
namespace TDEModemConnectionType {
    enum TDEModemConnectionType {
        CDMA,
        GSM,
        Other,
        Last = Other
    };
};
 
namespace TDEGSMNetworkType {
    enum TDEGSMNetworkType {
        Any,
        Only3G,
        GPRSEdge,
        Prefer3G,
        Prefer2G,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkParity {
    enum TDENetworkParity {
        None,
        Even,
        Odd,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkSlaveDeviceType {
    enum TDENetworkSlaveDeviceType {
        None,
        Bond,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkGlobalEventType {
    enum TDENetworkGlobalEventType {
        ConnectionListChanged,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkVPNEventType {
    enum TDENetworkVPNEventType {
        LoginBanner,
        Failure,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkDeviceEventType {
    enum TDENetworkDeviceEventType {
        BitRateChanged,
        Failure,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkAPEventType {
    enum TDENetworkAPEventType {
        Discovered,
        Lost,
        SignalStrengthChanged,
        AccessPointChanged,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkGlobalManagerFlags {
    enum TDENetworkGlobalManagerFlags {
        Unknown         = 0x00000000,
        Disconnected        = 0x00000001,
        Connected       = 0x00000002,
        EstablishingLink    = 0x00000004,
        DeactivatingLink    = 0x00000008,
        LinkLocalAccess     = 0x00000010,
        SiteLocalAccess     = 0x00000020,
        GlobalAccess        = 0x00000040,
        Sleeping        = 0x00000080,
        BackendUnavailable  = 0x00000100,
        VPNUnknown      = 0x00000200,
        VPNEstablishingLink = 0x00000400,
        VPNNeedAuthorization    = 0x00000800,
        VPNConfiguringProtocols = 0x00001000,
        VPNVerifyingProtocols   = 0x00002000,
        VPNConnected        = 0x00004000,
        VPNFailed       = 0x00008000,
        VPNDisconnected     = 0x00010000,
        GlobalMask      = 0x000001ff,
        VPNMask         = 0x0001fe00
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkGlobalManagerFlags)
};
 
namespace TDENetworkDeviceCapabilityFlags {
    enum TDENetworkDeviceCapabilityFlags {
        None            = 0x00000000,
        Supported       = 0x00000001,
        CanDetectLink       = 0x00000002
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkDeviceCapabilityFlags)
};
 
namespace TDENetworkPPPFlags {
    enum TDENetworkPPPFlags {
        None            = 0x00000000,
        DisableEAP      = 0x00000001,
        DisablePAP      = 0x00000002,
        DisableCHAP     = 0x00000004,
        DisableMSCHAP       = 0x00000008,
        DisableMSCHAPv2     = 0x00000010,
        AllowBSDCompression = 0x00000020,
        AllowDeflateCompression = 0x00000040,
        AllowVJCompression  = 0x00000080,
        RequireMPPE     = 0x00000100,
        RequireMPPE128      = 0x00000200,
        StatefulMPPE        = 0x00000400,
        UseHardwareFlowControl  = 0x00000800
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkPPPFlags)
};
 
namespace TDENetworkWiFiAPFlags {
    enum TDENetworkWiFiAPFlags {
        None            = 0x00000000,
        PrivacySupport      = 0x00000001,
        PairWEP40       = 0x00000002,
        PairWEP104      = 0x00000004,
        PairTKIP        = 0x00000008,
        PairCCMP        = 0x00000010,
        GroupWEP40      = 0x00000020,
        GroupWEP104     = 0x00000040,
        GroupTKIP       = 0x00000080,
        GroupCCMP       = 0x00000100,
        KeyManagementPSK    = 0x00000200,
        KeyManagement80211  = 0x00000400,
        GeneralFlagsMask    = 0x00000001,
        EncryptionFlagsMask = 0xfffffffe
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkWiFiAPFlags)
};
 
namespace TDENetworkWiFiClientFlags {
    enum TDENetworkWiFiClientFlags {
        None            = 0x00000000,
        CipherWEP40     = 0x00000002,
        CipherWEP104        = 0x00000004,
        CipherTKIP      = 0x00000008,
        CipherCCMP      = 0x00000010,
        CipherWPA       = 0x00000020,
        CipherRSN       = 0x00000040
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkWiFiClientFlags)
};
 
namespace TDENetworkVPNType {
    enum TDENetworkVPNType {
        OpenVPN,
        PPTP,
        StrongSwan,
        VPNC,
        Other,
        Last = Other
    };
};
 
typedef TQValueList<TDENetworkVPNType::TDENetworkVPNType> TDENetworkVPNTypeList;
 
namespace TDENetworkWiFiConnectionCipher {
    enum TDENetworkWiFiConnectionCipher {
        None,
        CipherWEP40,
        CipherWEP104,
        CipherTKIP,
        CipherCCMP,
        CipherWPA,
        CipherRSN,
        Any
    };
};
 
typedef TQValueList<TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher> TDENetworkWiFiConnectionCipherList;
 
namespace TDENetworkWepKeyType {
    enum TDENetworkWepKeyType {
        Hexadecimal,
        Ascii,
        Passphrase
    };
};
 
namespace TDENetworkVLANFlags {
    enum TDENetworkVLANFlags {
        None            = 0x00000000,
        ReorderPacketHeaders    = 0x00000001,
        UseGVRP         = 0x00000002,
        LooseBinding        = 0x00000004
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkVLANFlags)
};
 
namespace TDENetworkWiFiKeyType {
    enum TDENetworkWiFiKeyType {
        WEP,
        DynamicWEP,
        WPAAdHoc,
        WPAInfrastructure,
        WPAEnterprise,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkWiFiAuthType {
    enum TDENetworkWiFiAuthType {
        Open,
        Shared,
        LEAP,
        Other,
        Last = Other
    };
};
 
namespace TDENetworkIEEE8021xType {
    enum TDENetworkIEEE8021xType {
        None,
        LEAP,
        MD5,
        PAP,
        CHAP,
        MSCHAP,
        MSCHAPV2,
        Fast,
        PSK,
        PAX,
        SAKE,
        GPSK,
        TLS,
        PEAP,
        TTLS,
        SIM,
        GTC,
        OTP
    };
};
 
typedef TQValueList<TDENetworkIEEE8021xType::TDENetworkIEEE8021xType> TDENetworkIEEE8021xTypeList;
 
namespace TDENetworkIEEE8021xFastFlags {
    enum TDENetworkIEEE8021xFastFlags {
        None            = 0x00000000,
        AllowUnauthenticated    = 0x00000001,
        AllowAuthenticated  = 0x00000002
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkIEEE8021xFastFlags)
};
 
namespace TDENetworkWiFiWPAVersionFlags {
    enum TDENetworkWiFiWPAVersionFlags {
        None            = 0x00000000,
        WPA         = 0x00000001,
        RSN         = 0x00000002,
        Any         = 0x00000003
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkWiFiWPAVersionFlags)
};
 
namespace TDENetworkPasswordHandlingFlags {
    enum TDENetworkPasswordHandlingFlags {
        None            = 0x00000000,
        NoSave          = 0x00000001,
        NoPrompt        = 0x00000002,
        ExternalStorage     = 0x00000004
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkPasswordHandlingFlags)
};
 
namespace TDENetworkConnectionStatus {
    enum TDENetworkConnectionStatus {
        None            = 0x00000000,
        Invalid         = 0x00000001,
        Disconnected        = 0x00000002,
        Connected       = 0x00000004,
        LinkUnavailable     = 0x00000008,
        EstablishingLink    = 0x00000010,
        DeactivatingLink    = 0x00000020,
        ConfiguringProtocols    = 0x00000040,
        Reconnecting        = 0x00000080,
        LinkLost        = 0x00000100,
        LinkLocalAccess     = 0x00000200,
        SiteLocalAccess     = 0x00000400,
        GlobalAccess        = 0x00000800,
        UnManaged       = 0x00001000,
        NeedAuthorization   = 0x00002000,
        Failed          = 0x00004000,
        VerifyingProtocols  = 0x00008000,
        DependencyWait      = 0x00010000
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkConnectionStatus)
};
 
namespace TDENetworkIPConfigurationFlags {
    enum TDENetworkIPConfigurationFlags {
        None                    = 0x00000000,
        IPV4DHCPIP              = 0x00000001,
        IPV4DHCPDNS             = 0x00000002,
        IPV4DHCPRoutes              = 0x00000004,
        IPV4LocalOnly               = 0x00000008,
        IPV4StartConnectionSharingServer    = 0x00000010,
        IPV4Disabled                = 0x00000020,
        IPV4MayUseAsDefaultRoute        = 0x00000040,
        IPV6DHCPIP              = 0x00000080,
        IPV6DHCPDNS             = 0x00000100,
        IPV6DHCPRoutes              = 0x00000200,
        IPV6LocalOnly               = 0x00000400,
        IPV6StartConnectionSharingServer    = 0x00000800,
        IPV6Disabled                = 0x00001000,
        IPV6MayUseAsDefaultRoute        = 0x00002000
    };
 
    CREATE_FLAG_BITWISE_MANIPULATION_FUNCTIONS(TDENetworkIPConfigurationFlags)
};
 
class TDECORE_EXPORT TDENetworkSearchDomain
{
    public:
        TDENetworkSearchDomain();
        TDENetworkSearchDomain(TQString domain, bool ipv6=false);
        ~TDENetworkSearchDomain();
 
        TQString searchDomain();
        void setSearchDomain(TQString domain, bool ipv6=false);
 
        bool isIPv4();
        bool isIPv6();
 
    private:
        TQString m_domain;
        bool m_isIPV6;
};
 
typedef TQValueList<TDENetworkSearchDomain> TDENetworkSearchDomainList;
 
class TDECORE_EXPORT TDENetMask
{
    public:
        TDENetMask();
        TDENetMask(TQ_UINT32 netmask);
        TDENetMask(TQ_UINT8* netmask);
        ~TDENetMask();
 
        void fromCIDRMask(unsigned char mask, bool ipv6=false);
        unsigned char toCIDRMask();
        void fromString(TQString mask);
        TQString toString();
 
        bool isIPv4();
        bool isIPv6();
 
    private:
        TQ_UINT32 m_ipv4NetMask;
        TQHostAddress m_ipv6NetMask;
        bool m_isIPV6;
};
 
class TDECORE_EXPORT TDEMACAddress
{
    public:
        TDEMACAddress();
        TDEMACAddress(TDENetworkByteList address);
        ~TDEMACAddress();
 
        TDENetworkByteList address();
        void setAddress(TDENetworkByteList address);
        TQString toString();
        void fromString(TQString address);
        bool isValid();
 
    private:
        bool m_isValid;
        TDENetworkByteList m_macAddress;
 
        friend bool operator==(const TDEMACAddress &a1, const TDEMACAddress &a2);
        friend bool operator<(const TDEMACAddress &a1, const TDEMACAddress &a2);
};
 
TDECORE_EXPORT bool operator==(const TDEMACAddress &a1, const TDEMACAddress &a2);
TDECORE_EXPORT bool operator<(const TDEMACAddress &a1, const TDEMACAddress &a2);
 
typedef TQValueList<TDEMACAddress> TDEMACAddressList;
 
class TDECORE_EXPORT TDENetworkSingleIPConfiguration
{
    public:
        TDENetworkSingleIPConfiguration();
        ~TDENetworkSingleIPConfiguration();
 
        bool isIPv4();
        bool isIPv6();
 
    public:
        bool valid;
        TQHostAddress ipAddress;
        TDENetMask networkMask;
        TQHostAddress gateway;
};
 
typedef TQValueList<TDENetworkSingleIPConfiguration> TDENetworkSingleIPConfigurationList;
 
class TDECORE_EXPORT TDENetworkSingleRouteConfiguration
{
    public:
        TDENetworkSingleRouteConfiguration();
        ~TDENetworkSingleRouteConfiguration();
 
        bool isIPv4();
        bool isIPv6();
 
    public:
        bool valid;
        TQHostAddress ipAddress;
        TDENetMask networkMask;
        TQHostAddress gateway;
        TQ_UINT32 metric;
};
 
typedef TQValueList<TDENetworkSingleRouteConfiguration> TDENetworkSingleRouteConfigurationList;
 
class TDECORE_EXPORT TDENetworkIEEE8021xConfiguration
{
    public:
        TDENetworkIEEE8021xConfiguration();
        ~TDENetworkIEEE8021xConfiguration();
 
    public:
        bool valid;
        bool allowedValid;
        bool secretsValid;
        TDENetworkIEEE8021xType::TDENetworkIEEE8021xType type;
        TQString userName;
        TQString anonymousUserName;
        TQString pacFileName;
        TQByteArray caCertificate;
        TQString additionalCAFilesPath;
        TQString authServerCertSubjectMatch;
        TQStringList alternateAuthServerCertSubjectMatch;
        TQByteArray clientCertificate;
        TQString forcePEAPVersion;
        TQString forcePEAPLabel;
        TDENetworkIEEE8021xFastFlags::TDENetworkIEEE8021xFastFlags fastProvisioningFlags;
        TDENetworkIEEE8021xType::TDENetworkIEEE8021xType phase2NonEAPAuthMethod;
        TDENetworkIEEE8021xType::TDENetworkIEEE8021xType phase2EAPAuthMethod;
        TDENetworkIEEE8021xTypeList allowedPhase2NonEAPMethods;
        TDENetworkIEEE8021xTypeList allowedPhase2EAPMethods;
        TQByteArray phase2CaCertificate;
        TQString phase2CaFilesPath;
        TQString phase2AuthServerCertSubjectMatch;
        TQStringList phase2AlternateAuthServerCertSubjectMatch;
        TQByteArray phase2ClientCertificate;
        TQString password;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags passwordFlags;
        TQByteArray binaryPassword;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags binaryPasswordFlags;
        TQByteArray privateKey;
        TQString privateKeyPassword;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags privateKeyPasswordFlags;
        TQByteArray phase2PrivateKey;
        TQString phase2PrivateKeyPassword;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags phase2PrivateKeyPasswordFlags;
        bool forceSystemCaCertificates;
};
 
class TDECORE_EXPORT TDENetworkPPPConfiguration
{
    public:
        TDENetworkPPPConfiguration();
        virtual ~TDENetworkPPPConfiguration();
 
    public:
        bool valid;
        bool requireServerAuthentication;
        TDENetworkPPPFlags::TDENetworkPPPFlags flags;
        TQ_UINT32 baudRate;
        TQ_UINT32 mru;
        TQ_UINT32 mtu;
        TQ_UINT32 lcpEchoPingInterval;
        TQ_UINT32 lcpEchoFailureThreshold;
};
 
class TDECORE_EXPORT TDENetworkPPPOEConfiguration
{
    public:
        TDENetworkPPPOEConfiguration();
        virtual ~TDENetworkPPPOEConfiguration();
 
    public:
        bool valid;
        bool secretsValid;
        TQString networkServiceProvider;
        TQString username;
        TQString password;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags passwordFlags;
};
 
class TDECORE_EXPORT TDENetworkSerialConfiguration
{
    public:
        TDENetworkSerialConfiguration();
        virtual ~TDENetworkSerialConfiguration();
 
    public:
        bool valid;
        TQ_UINT32 baudRate;
        TQ_UINT32 byteWidth;
        TDENetworkParity::TDENetworkParity parity;
        TQ_UINT32 stopBits;
        TQ_UINT64 txDelay;
};
 
class TDECORE_EXPORT TDENetworkCDMAConfiguration
{
    public:
        TDENetworkCDMAConfiguration();
        virtual ~TDENetworkCDMAConfiguration();
 
    public:
        bool valid;
        bool secretsValid;
        TQString providerDataNumber;
        TQString username;
        TQString password;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags passwordFlags;
};
 
class TDECORE_EXPORT TDENetworkGSMConfiguration
{
    public:
        TDENetworkGSMConfiguration();
        virtual ~TDENetworkGSMConfiguration();
 
    public:
        bool valid;
        bool secretsValid;
        TQString providerDataNumber;
        TQString username;
        TQString password;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags passwordFlags;
        TQString accessPointName;
        TQString networkID;
        TDEGSMNetworkType::TDEGSMNetworkType networkType;
        TQString pin;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags pinFlags;
        TQ_UINT32 allowedFrequencyBands;
        bool allowRoaming;
};
        
 
class TDENetworkWiFiSecurityConfiguration
{
    public:
        TDENetworkWiFiSecurityConfiguration();
        ~TDENetworkWiFiSecurityConfiguration();
 
    public:
        bool valid;
        bool secretsValid;
        TDENetworkWiFiKeyType::TDENetworkWiFiKeyType keyType;
        TDENetworkWiFiAuthType::TDENetworkWiFiAuthType authType;
        TDENetworkWiFiWPAVersionFlags::TDENetworkWiFiWPAVersionFlags wpaVersion;
        TDENetworkWiFiConnectionCipher::TDENetworkWiFiConnectionCipher cipher;
        TQString wepKey0;
        TQString wepKey1;
        TQString wepKey2;
        TQString wepKey3;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags wepKeyFlags;
        TQ_UINT32 wepKeyIndex;
        TDENetworkWepKeyType::TDENetworkWepKeyType wepKeyType;
        TDENetworkWiFiConnectionCipherList allowedPairWiseCiphers;
        TDENetworkWiFiConnectionCipherList allowedGroupWiseCiphers;
        TQString psk;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags pskFlags;
        TQString leapUsername;
        TQString leapPassword;
        TDENetworkPasswordHandlingFlags::TDENetworkPasswordHandlingFlags leapPasswordFlags;
};
 
class TDECORE_EXPORT TDENetworkIPConfiguration
{
    public:
        TDENetworkIPConfiguration();
        ~TDENetworkIPConfiguration();
 
    public:
        bool valid;
        TDENetworkIPConfigurationFlags::TDENetworkIPConfigurationFlags connectionFlags;
        TDENetworkSingleIPConfigurationList ipConfigurations;
        TDENetworkSingleRouteConfigurationList routeConfigurations;
        TQHostAddress broadcast;
        TQHostAddress destination;
        TDENetworkAddressList resolvers;
        TDENetworkSearchDomainList searchDomains;
        TQString dhcpClientIdentifier;
};
 
class TDECORE_EXPORT TDENetworkWiFiDeviceInfo
{
    public:
        TDENetworkWiFiDeviceInfo();
        ~TDENetworkWiFiDeviceInfo();
 
    public:
        bool valid;
        TDEMACAddress hwAddress;
        TDEMACAddress permanentHWAddress;
        TDEWiFiMode::TDEWiFiMode operatingMode;
        unsigned int bitrate;
        TDEMACAddress activeAccessPointBSSID;
        TDENetworkWiFiClientFlags::TDENetworkWiFiClientFlags wirelessFlags;
};
 
class TDECORE_EXPORT TDENetworkDeviceInformation
{
    public:
        TDENetworkDeviceInformation();
        ~TDENetworkDeviceInformation();
 
    public:
        bool valid;
        TDENetworkConnectionStatus::TDENetworkConnectionStatus statusFlags;
        TQString UUID;
        TQString backendDriver;
        TQString backendDriverVersion;
        TQString firmwareVersion;
        TDENetworkDeviceCapabilityFlags::TDENetworkDeviceCapabilityFlags capabilityFlags;
        TDENetworkIPConfiguration ipConfiguration;
        bool managed;
        bool autoConnect;
        bool firmwareMissing;
        TDENetworkDeviceType::TDENetworkDeviceType deviceType;
        TQString activeConnectionUUID;
        TDENetworkWiFiDeviceInfo wiFiInfo;
};
 
class TDECORE_EXPORT TDENetworkHWNeighbor
{
    public:
        TDENetworkHWNeighbor();
        virtual ~TDENetworkHWNeighbor();
 
    public:
        bool valid;
};
 
class TDECORE_EXPORT TDENetworkWiFiAPInfo : public TDENetworkHWNeighbor
{
    public:
        TDENetworkWiFiAPInfo();
        virtual ~TDENetworkWiFiAPInfo();
 
    public:
        TQString friendlySSID() const;
 
    public:
        TQByteArray SSID;
        TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags wpaFlags;
        TDENetworkWiFiAPFlags::TDENetworkWiFiAPFlags rsnFlags;
        unsigned int frequency;
        TDEMACAddress BSSID;
        unsigned int maxBitrate;
        double signalQuality;
};
 
typedef TQPtrList< TDENetworkHWNeighbor > TDENetworkHWNeighborList;
 
class TDECORE_EXPORT TDENetworkConnection
{
    public:
        TDENetworkConnection();
        virtual ~TDENetworkConnection();
 
    public:
        TDENetworkConnectionType::TDENetworkConnectionType type();
 
    public:
        TQString UUID;
        TQString friendlyName;
        TDENetworkIPConfiguration ipConfig;
        TDEMACAddress lockedHWAddress;
        TDEMACAddress manualHWAddress;
        bool readOnly;
        bool autoConnect;
        bool fullDuplex;
        bool requireIPV4;
        bool requireIPV6;
        TQ_UINT32 mtu;
        TDENetworkIEEE8021xConfiguration eapConfig;
        TDENetworkPPPConfiguration pppConfig;
        TDENetworkPPPOEConfiguration pppoeConfig;
        TDENetworkSerialConfiguration serialConfig;
        TQStringList authorizedUsers;
        TQString masterConnectionUUID;
        TDENetworkSlaveDeviceType::TDENetworkSlaveDeviceType slaveType;
        TQDateTime lastKnownConnection;
};
 
class TDECORE_EXPORT TDEWiredEthernetConnection : public TDENetworkConnection
{
    public:
        TDEWiredEthernetConnection();
        virtual ~TDEWiredEthernetConnection();
};
 
class TDECORE_EXPORT TDEWiFiConnection : public TDENetworkConnection
{
    public:
        TDEWiFiConnection();
        virtual ~TDEWiFiConnection();
 
    public:
        TQByteArray SSID;
        TDEWiFiMode::TDEWiFiMode operatingMode;
        TDEWiFiFrequencyBand::TDEWiFiFrequencyBand bandRestriction;
        TQ_INT32 channelRestriction;
        TQ_INT32 bitRateRestriction;
        TQ_INT32 powerRestriction;
        TDEMACAddress accessPointRestriction;
        TDEMACAddressList blacklistedBSSIDs;
        TDEMACAddressList heardBSSIDs;
        bool isHiddenNetwork;
        bool securityRequired;
        TDENetworkWiFiSecurityConfiguration securitySettings;
};
 
class TDECORE_EXPORT TDEWiredInfinibandConnection : public TDENetworkConnection
{
    public:
        TDEWiredInfinibandConnection();
        virtual ~TDEWiredInfinibandConnection();
 
    public:
        TDENetworkInfinibandTransportMode::TDENetworkInfinibandTransportMode transportMode;
};
 
class TDECORE_EXPORT TDEVPNConnection : public TDENetworkConnection
{
    public:
        TDEVPNConnection();
        virtual ~TDEVPNConnection();
 
    public:
        TQString vpnPluginID;
        TQString lockedUserName;
        TDENetworkSettingsMap pluginData;
        bool secretsValid;
        TDENetworkSettingsMap pluginSecrets;
};
 
class TDECORE_EXPORT TDEWiMaxConnection : public TDENetworkConnection
{
    public:
        TDEWiMaxConnection();
        virtual ~TDEWiMaxConnection();
 
    public:
        TQString networkServiceProvider;
};
 
class TDECORE_EXPORT TDEVLANConnection : public TDENetworkConnection
{
    public:
        TDEVLANConnection();
        virtual ~TDEVLANConnection();
 
    public:
        TQString kernelName;
        TQString parentConnectionUUID;
        TQ_UINT32 vlanID;
        TDENetworkVLANFlags::TDENetworkVLANFlags vlanFlags;
        TDENetworkPriorityMap ingressPriorityMap;
        TDENetworkPriorityMap egressPriorityMap;
};
 
class TDECORE_EXPORT TDEOLPCMeshConnection : public TDENetworkConnection
{
    public:
        TDEOLPCMeshConnection();
        virtual ~TDEOLPCMeshConnection();
 
    public:
        TQByteArray SSID;
        TQ_INT32 channel;
        TQByteArray anycastDHCPHWAddress;
};
 
class TDECORE_EXPORT TDEBluetoothConnection : public TDENetworkConnection
{
    public:
        TDEBluetoothConnection();
        virtual ~TDEBluetoothConnection();
 
    public:
        TDEBluetoothConnectionType::TDEBluetoothConnectionType type;
};
 
class TDECORE_EXPORT TDEModemConnection : public TDENetworkConnection
{
    public:
        TDEModemConnection();
        virtual ~TDEModemConnection();
 
    public:
        TDEModemConnectionType::TDEModemConnectionType type;
        TDENetworkCDMAConfiguration cdmaConfig;
        TDENetworkGSMConfiguration gsmConfig;
};
 
typedef TQPtrList< TDENetworkConnection > TDENetworkConnectionList;
 
class TDENetworkEventQueueEvent_Private
{
    public:
        int eventType;
        TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags newState;
        TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags previousState;
        TDENetworkConnectionStatus::TDENetworkConnectionStatus newConnStatus;
        TDENetworkConnectionStatus::TDENetworkConnectionStatus previousConnStatus;
        TDEMACAddress BSSID;
        TQString message;
        TQString deviceNode;
        TDENetworkAPEventType::TDENetworkAPEventType apevent;
        TDENetworkDeviceEventType::TDENetworkDeviceEventType ndevent;
        TDENetworkVPNEventType::TDENetworkVPNEventType vpnevent;
        TDENetworkGlobalEventType::TDENetworkGlobalEventType globalevent;
};
typedef TQValueList<TDENetworkEventQueueEvent_Private> TDENetworkEventQueueEvent_PrivateList;
 
class TQTimer;
 
class TDECORE_EXPORT TDENetworkConnectionManager : public TQObject
{
    TQ_OBJECT
 
    public:
        TDENetworkConnectionManager(TDENetworkDevice *networkDevice);
 
        ~TDENetworkConnectionManager();
 
        virtual TQString backendName() = 0;
 
        virtual TDENetworkDeviceType::TDENetworkDeviceType deviceType() = 0;
 
        virtual TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags backendStatus() = 0;
 
        virtual TDENetworkDeviceInformation deviceInformation() = 0;
 
        virtual TDENetworkDeviceInformation deviceStatus() = 0;
 
        virtual void loadConnectionInformation() = 0;
 
        virtual void loadConnectionAllowedValues(TDENetworkConnection* connection) = 0;
 
        virtual bool loadConnectionSecrets(TQString uuid) = 0;
 
        virtual bool saveConnection(TDENetworkConnection* connection) = 0;
 
        virtual bool deleteConnection(TQString uuid) = 0;
 
        virtual bool verifyConnectionSettings(TDENetworkConnection* connection, TDENetworkConnectionErrorFlags::TDENetworkConnectionErrorFlags* type=NULL, TDENetworkErrorStringMap* reason=NULL) = 0;
 
        virtual TDENetworkConnectionStatus::TDENetworkConnectionStatus initiateConnection(TQString uuid) = 0;
 
        virtual TDENetworkConnectionStatus::TDENetworkConnectionStatus checkConnectionStatus(TQString uuid) = 0;
 
        virtual TDENetworkConnectionStatus::TDENetworkConnectionStatus deactivateConnection(TQString uuid) = 0;
 
        virtual TQStringList validSettings() = 0;
 
        virtual TDENetworkHWNeighborList* siteSurvey() = 0;
 
        virtual TQStringList connectionPhysicalDeviceUUIDs(TQString uuid) = 0;
 
        virtual TDENetworkVPNTypeList availableVPNTypes() = 0;
 
        virtual bool networkingEnabled() = 0;
 
        virtual bool enableNetworking(bool enable) = 0;
 
        virtual bool wiFiHardwareEnabled() = 0;
 
        virtual bool enableWiFi(bool enable) = 0;
 
        virtual bool wiFiEnabled() = 0;
 
        virtual TQStringList defaultNetworkDevices() = 0;
 
    signals:
        void networkConnectionStateChanged(TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags newState, TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags previousState);
 
        void networkDeviceStateChanged(TDENetworkConnectionStatus::TDENetworkConnectionStatus newState, TDENetworkConnectionStatus::TDENetworkConnectionStatus previousState, TQString deviceNode);
 
        void accessPointStatusChanged(TDEMACAddress BSSID, TDENetworkAPEventType::TDENetworkAPEventType event);
 
        void networkDeviceEvent(TDENetworkDeviceEventType::TDENetworkDeviceEventType event, TQString message);
 
        void vpnEvent(TDENetworkVPNEventType::TDENetworkVPNEventType event, TQString message);
 
        void networkManagementEvent(TDENetworkGlobalEventType::TDENetworkGlobalEventType event);
 
    public:
        virtual TDENetworkConnectionList* connections();
 
        TQString deviceNode();
 
        TQString deviceMACAddress();
 
        TDENetworkConnection* findConnectionByUUID(TQString uuid);
 
        TDENetworkDevice* findDeviceByUUID(TQString uuid);
 
        TDENetworkWiFiAPInfo* findAccessPointByBSSID(TDEMACAddress bssid);
 
        static TQString friendlyConnectionTypeName(TDENetworkConnectionType::TDENetworkConnectionType type);
 
        static bool validateIPAddress(TQHostAddress address);
 
        static bool validateIPNeworkMask(TQHostAddress netmask);
 
    protected:
        void clearTDENetworkConnectionList();
        
        void clearTDENetworkHWNeighborList();
 
        void internalNetworkConnectionStateChanged(TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags newState);
 
        void internalNetworkDeviceStateChanged(TDENetworkConnectionStatus::TDENetworkConnectionStatus newState, TQString deviceNode=TQString::null);
 
        void internalAccessPointStatusChanged(TDEMACAddress BSSID, TDENetworkAPEventType::TDENetworkAPEventType event);
 
        void internalNetworkDeviceEvent(TDENetworkDeviceEventType::TDENetworkDeviceEventType event, TQString message);
 
        void internalVpnEvent(TDENetworkVPNEventType::TDENetworkVPNEventType event, TQString message);
 
        void internalNetworkManagementEvent(TDENetworkGlobalEventType::TDENetworkGlobalEventType event);
 
    protected slots:
        void emitQueuedSignals();
 
    protected:
        TDENetworkConnectionList* m_connectionList;
        TDENetworkHWNeighborList* m_hwNeighborList;
        TDENetworkDevice* m_networkDevice;
        TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags m_prevConnectionStatus;
        TQMap<TQString, TDENetworkConnectionStatus::TDENetworkConnectionStatus> m_prevDeviceStatus;
        TQTimer* m_emissionTimer;
        TDENetworkEventQueueEvent_PrivateList m_globalEventQueueEventList;
};
 
class TDECORE_EXPORT TDEGlobalNetworkManager : public TQObject
{
    TQ_OBJECT
 
    public:
        TDEGlobalNetworkManager();
        
        ~TDEGlobalNetworkManager();
 
        virtual TQString backendName();
 
        virtual TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags backendStatus();
 
        virtual void loadConnectionInformation();
 
        virtual void loadConnectionAllowedValues(TDENetworkConnection* connection);
 
        virtual bool loadConnectionSecrets(TQString uuid);
 
        virtual bool saveConnection(TDENetworkConnection* connection);
 
        virtual bool deleteConnection(TQString uuid);
 
        virtual bool verifyConnectionSettings(TDENetworkConnection* connection, TDENetworkConnectionErrorFlags::TDENetworkConnectionErrorFlags* type=NULL, TDENetworkErrorStringMap* reason=NULL);
 
        virtual TDENetworkConnectionStatus::TDENetworkConnectionStatus initiateConnection(TQString uuid);
 
        virtual TDENetworkConnectionStatus::TDENetworkConnectionStatus checkConnectionStatus(TQString uuid);
 
        virtual TDENetworkConnectionStatus::TDENetworkConnectionStatus deactivateConnection(TQString uuid);
 
        virtual TQStringList validSettings();
 
        virtual TDENetworkHWNeighborList* siteSurvey();
 
        virtual TQStringList connectionPhysicalDeviceUUIDs(TQString uuid);
 
        virtual TDENetworkVPNTypeList availableVPNTypes();
 
        virtual bool networkingEnabled();
 
        virtual bool enableNetworking(bool enable);
 
        virtual bool wiFiHardwareEnabled();
 
        virtual bool enableWiFi(bool enable);
 
        virtual bool wiFiEnabled();
 
        virtual TQStringList defaultNetworkDevices();
 
    signals:
        void networkConnectionStateChanged(TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags newState, TDENetworkGlobalManagerFlags::TDENetworkGlobalManagerFlags previousState);
 
        void networkDeviceStateChanged(TDENetworkConnectionStatus::TDENetworkConnectionStatus newState, TDENetworkConnectionStatus::TDENetworkConnectionStatus previousState, TQString deviceNode);
 
        void accessPointStatusChanged(TDEMACAddress BSSID, TDENetworkAPEventType::TDENetworkAPEventType event);
 
        void vpnEvent(TDENetworkVPNEventType::TDENetworkVPNEventType event, TQString message);
 
        void networkManagementEvent(TDENetworkGlobalEventType::TDENetworkGlobalEventType event);
 
    public:
        virtual TDENetworkConnectionList* connections();
 
        TDENetworkConnection* findConnectionByUUID(TQString uuid);
 
        TDENetworkDevice* findDeviceByUUID(TQString uuid);
 
        TDENetworkWiFiAPInfo* findAccessPointByBSSID(TDEMACAddress bssid);
 
    private:
        TDENetworkConnectionManager* m_internalConnectionManager;
};
 
#endif // _TDENETWORKCONNECTIONS_H