diff options
Diffstat (limited to 'src/vpnaccountdata.cpp')
| -rw-r--r-- | src/vpnaccountdata.cpp | 2291 |
1 files changed, 2291 insertions, 0 deletions
diff --git a/src/vpnaccountdata.cpp b/src/vpnaccountdata.cpp new file mode 100644 index 0000000..44db7e8 --- /dev/null +++ b/src/vpnaccountdata.cpp @@ -0,0 +1,2291 @@ +/*************************************************************************** +* Copyright (C) 2004 by Christoph Thielecke * +* crissi99@gmx.de * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program 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 General Public License for more details. * +* * +* You should have received a copy of the GNU General Public License * +* along with this program; if not, write to the * +* Free Software Foundation, Inc., * +* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * +***************************************************************************/ +#include "vpnaccountdata.h" + +VpnAccountData::VpnAccountData( ConnectionType ConnType,const QString& Name) +{ + this->RemoteNetAddr = ""; + this->RemoteNetMask = "24"; + this->CertPath = ""; + this->doPingIP = false; + this->pingHostIP = ""; + this->PrivateKeyPass=""; + this->PrivateKey=""; + this->NetworkDevice=""; + this->connectiontype = ConnType; + this->Name = Name; + + Gateway=""; + ID=""; + Username=""; + UserPassword=""; + IkeGroup="modp2048"; + EncryptionAlgorithm="3des"; + AuthenticationAlgorithm="hmac_md5"; + PerfectForwardSecrecy=""; + NtDomainName=""; + ApplicationVersion=""; + RemoteNetAddr=""; + RemoteNetMask=""; + PreSharedKey=""; + x509Certificate=""; + CaCertificate=""; + NetworkDevice=""; + PrivateKeyPass=""; + PrivateKey=""; + CertPath=""; + AuthType=""; + pingHostIP=""; + SpecialRemoteID=""; + SpecialLocalID=""; + LocalIDType="asn1dn"; + RemoteIDType="none"; + LocalVirtualIP=""; + RemoteVirtualIP=""; + PreSharedKeyFile=""; + HashAlgo="md5"; + Description=""; + HttpProxyAuthType=""; + HttpProxyUser=""; + HttpProxyPass=""; + RightNextHop=""; + LeftNextHop=""; + AuthMethod="mschap-v2"; + TunnelDeviceType="tun"; + SearchDomainInResolvConf=""; + DomainInResolvConf=""; + AuthenticationDirection="none"; + CiscoNatMode="natt"; + IpsecEsp="3des-md5,3des-sha1,aes128-sha1,aes256-sha1"; + IpsecIke="aes256-sha1,aes128-sha1,3des-sha1-modp2048,3des-md5,3des-sha1"; + VtunProfile=""; + IpsecVpnMode="tunnel"; + LeftSourceIp=""; + RightSourceIp=""; + VirtualSubnetworks=""; + SshConfigRemoteScript=""; + saveUserPassword=false; + savePsk=false; + useAdvancedSettings=false; + useIkeGroup=false; + usePerfectForwardSecrety=false; + useNtDomainName=false; + useApplicationVersion=false; + useSingleDes=false; + useGlobalIpsecSecret=false; + doPingIP=false; + useSpecialRemoteID=false; + useSpecialLocalID=false; + useUdp=true; + useUdpPort=false; + useDnsServer=false; + DnsServer=""; + refuse40BitEncryption=true; + refuse128BitEncryption=false; + allowStatefulMode=false; + requireMppe=true; + useNoIpDefault=false; + disableMPPEComp=false; + executeCmdBeforeConnect=false; + executeCmdAfterConnect=false; + executeCmdBeforeDisconnect=false; + executeCmdAfterDisconnect=false; + CommandBeforeConnect=""; + CommandAfterConnect=""; + CommandBeforeDisconnect=""; + CommandAfterDisconnect=""; + useNoBsdComp=true; + useNoDeflate=true; + replaceDefaultRoute=true; + useMtu=false; + useMru=false; + useVirtualIP=false; + VirtualIP=""; + PskIsInFile=false; + useAdditionalNetworkRoutes=false; + useUserdefinedPort = false; + SpecialServerCertificate=""; + useSpecialServerCertificate=false; + TunnelDeviceType="tun"; + allowEmptyGroupPassword=false; + useReconnectDelay=false; + useHttpProxy=false; + PskIsInFile=false; + RemoteNetMask="24"; + RemoteNetAddr=""; + saveUserPassword=true; + savePsk=true; + useIkeGroup=false; + usePerfectForwardSecrety=false; + useNtDomainName=false; + useApplicationVersion=false; + useLocalPort=false; + useRemotePort=false; + useSingleDes=false; + useGlobalIpsecSecret=false; + doPingIP=false; + useSpecialRemoteID=false; + useSpecialLocalID=false; + useUdp=false; + useUdpPort=false; + useDnsServer=false; + refuse40BitEncryption=false; + refuse128BitEncryption=false; + allowStatefulMode=false; + requireMppe=true; + useNoIpDefault=false; + disableMPPEComp=false; + executeCmdBeforeConnect=false; + executeCmdAfterConnect=false; + executeCmdBeforeDisconnect=false; + executeCmdAfterDisconnect=false; + useNoBsdComp=false; + useNoDeflate=false; + useMtu=false; + useMru=false; + useVirtualIP=false; + PskIsInFile=false; + useAdditionalNetworkRoutes=false; + useSpecialServerCertificate=false; + useUserdefinedPort=false; + useNsCertType=false; + useConnectionStatusCheck=true; + doReconnectAfterConnectionLost=true; + disableLzoCompression=true; + authWithUsernameAndPassword=false; + allowEmptyGroupPassword=false; + useUserdefiniedCipher=false; + useRedirectGateway=false; + useTlsAuth=false; + useTlsRemoteHost=false; + dontSaveUsername=false; + disableLzoCompression=false; + disableOpportunisticEncryption=true; + useMssfix=false; + useFragment=false; + disableCcp=false; + useXauthInteractive=false; + savePrivateKeyPassword=false; + useHttpProxyAuth=false; + useOnlyCaCertAndUserAuth=false; + useMailAddressAsIdentifier=false; + useRightNextHop=false; + useLeftNextHop=false; + usePkcs11Providers=false; + allowEmptyPrivateKeyPassword=false; + useSmartcard=false; + allowIpAddressChangeOfPeer=false; + useSearchDomainInResolvConf=false; + useDomainInResolvConf=false; + disableDataEncryption=false; + useAuthenticationAlgorithm=false; + fixPathMtuDiscoveryProblem=true; + useRemoteNetwork=false; + disableHeaderCompression=false; + disableMagicNumberNegotiation=false; + disableIpx=false; + disableProtocolFieldCompression=false; + disableAdressControlCompression=false; + useCustomIke=false; + useCustomEsp=false; + verifyCaCert=true; + useDpdIdleTimeout=false; + hideGroupPasswordInAccountDataDialog=false; + usePerfectForwardSecrety=true; + useLeftSourceIp=false; + useRightSourceIp=false; + useVirtualSubnetworks=false; + disablePushFromServer=false; + disableBind=false; + useRenegSec=false; + useTunnelPing=false; + useTunnelPingRestart=false; + requireEap=false; + useSshConfigRemoteScript=false; + askUserPasswordOnEachConnect = false; + useCiscoCertStore = false; + useNat = true; + + PeerTimeout=60; + ReconnectDelay=5; + connectionStatusInterval=20; + Mtu=1500; + Mru=1500; + LocalPort=500; + RemotePort=500; + UserdefinedPort=10000; + UdpPort=4500; + HttpProxyPort=3128; + HttpProxyTimeout=100; + Mssfix=1300; + Fragment=1300; + CommandAfterConnectDelayTime=3; + DpdIdleTimeout = 300; + MaxConnectTries=3; + int RenegSec=3600; + int TunnelPing=10; + int TunnelPingRestart=120; + + L2tpDaemon=VpnAccountData::l2tpd; + +} + + +VpnAccountData::~VpnAccountData() +{} + +/* +VpnAccountData::VpnAccountData(const VpnAccountData& data) +{ + Name = data.Name; + Gateway = data.Gateway; + ID = data.ID; + Username = data.Username; + UserPassword = data.UserPassword; + IkeGroup = data.IkeGroup; + PerfectForwardSecrecy = data.PerfectForwardSecrecy; + EncryptionAlgorithm = data.EncryptionAlgorithm; + AuthenticationAlgorithm = data.AuthenticationAlgorithm; + NtDomainName = data.NtDomainName; + ApplicationVersion = data.ApplicationVersion; + RemoteNetAddr = data.RemoteNetAddr; + RemoteNetMask = data.RemoteNetMask; + PreSharedKey = data.PreSharedKey; + x509Certificate = data.x509Certificate; + CaCertificate = data.CaCertificate; + NetworkDevice = data.NetworkDevice; + PrivateKeyPass = data.PrivateKeyPass; + PrivateKey = data.PrivateKey; + CertPath = data.CertPath; + AuthType = data.AuthType; + pingHostIP = data.pingHostIP; + SpecialRemoteID = data.SpecialRemoteID; + SpecialLocalID = data.SpecialLocalID; + LocalIDType = data.LocalIDType; + LocalVirtualIP = data.LocalVirtualIP; + RemoteVirtualIP = data.RemoteVirtualIP; + PreSharedKeyFile = data.PreSharedKeyFile; + HashAlgo = data.HashAlgo; + UseUserdefiniedCipher = data.UseUserdefiniedCipher; + DnsServer = data.DnsServer; + CommandBeforeConnect= data.CommandBeforeConnect; + CommandAfterConnect= data.CommandAfterConnect; + CommandBeforeDisconnect= data.CommandBeforeDisconnect; + CommandAfterDisconnect= data.CommandAfterDisconnect; + Description = data.Description; + SpecialServerCertificate= data.SpecialServerCertificate; + VirtualIP = data.VirtualIP; + TunnelDeviceType = data.TunnelDeviceType; + NsCertType = data.NsCertType; + UserdefiniedCipher = data.UserdefiniedCipher; + TlsAuthFile= data.TlsAuthFile; + HttpProxy= data.HttpProxy; + ExchangeMode = data.ExchangeMode; + TlsRemoteHost= data.TlsRemoteHost; + RightNextHop = data.RightNextHop; + LeftNextHop = data.LeftNextHop; + HttpProxyAuthType= data.HttpProxyAuthType; + HttpProxyUser= data.HttpProxyUser; + HttpProxyPass= data.HttpProxyPass; + Pkcs11Providers= data.Pkcs11Providers; + Pkcs11SlotType= data.Pkcs11SlotType; + Pkcs11Slot= data.Pkcs11Slot; + Pkcs11IdType= data.Pkcs11IdType; + Pkcs11Id= data.Pkcs11Id; + Pkcs11SignMode= data.Pkcs11SignMode; + AuthMethod = data.AuthMethod; + SearchDomainInResolvConf= data.SearchDomainInResolvConf; + DomainInResolvConf= data.DomainInResolvConf; + AuthenticationDirection = data.AuthenticationDirection; + CiscoNatMode= data.CiscoNatMode; + IpsecEsp= data.IpsecEsp; + IpsecIke= data.IpsecIke; + AdditionalNetworkRoutes= data.QStringList AdditionalNetworkRoutes; + saveUserPassword = data.saveUserPassword; + savePsk = data.savePsk; + useAdvancedSettings = data.useAdvancedSettings; + useIkeGroup = data.useIkeGroup; + usePerfectForwardSecrety = data.usePerfectForwardSecrety; + useNtDomainName = data.useNtDomainName; + useApplicationVersion = data.useApplicationVersion; + useLocalPort = data.useLocalPort; + useRemotePort = data.useRemotePort; + useSingleDes = data.useSingleDes; + useGlobalIpsecSecret = data.useGlobalIpsecSecret; + doPingIP = data.doPingIP; + useSpecialRemoteID = data.useSpecialRemoteID; + useSpecialLocalID = data.useSpecialLocalID; + useUdp = data.useUdp; + useUdpPort = data.useUdpPort; + useDnsUpdate = data.useDnsUpdate; + useDnsServer = data.useDnsServer; + refuse40BitEncryption = data.refuse40BitEncryption; + refuse128BitEncryption = data.refuse128BitEncryption; + allowStatefulMode= data.allowStatefulMode; + requireMppe = data.requireMppe; + useNoIpDefault= data.useNoIpDefault; + disableMPPEComp= data.disableMPPEComp; + executeCmdBeforeConnect= data.executeCmdBeforeConnect; + executeCmdAfterConnect= data.executeCmdAfterConnect; + executeCmdBeforeDisconnect= data.executeCmdBeforeDisconnect; + executeCmdAfterDisconnect= data.executeCmdAfterDisconnect; + useNoBsdComp= data.useNoBsdComp; + useNoDeflate= data.useNoDeflate; + replaceDefaultRoute = data.replaceDefaultRoute; + useMtu= data.useMtu; + useMru= data.useMru; + useVirtualIP = data.useVirtualIP; + PskIsInFile = data.PskIsInFile; + useAdditionalNetworkRoutes= data.useAdditionalNetworkRoutes; + useSpecialServerCertificate= data.useSpecialServerCertificate; + useUserdefinedPort= data.useUserdefinedPort; + useNsCertType = data.useNsCertType; + useConnectionStatusCheck = data.useConnectionStatusCheck; + doReconnectAfterConnectionLost= data.doReconnectAfterConnectionLost; + disableLzoCompression= data.disableLzoCompression; + authWithUsernameAndPassword = data.authWithUsernameAndPassword; + allowEmptyGroupPassword = data.allowEmptyGroupPassword; + useUserdefiniedCipher= data.useUserdefiniedCipher; + useRedirectGateway= data.useRedirectGateway; + useTlsAuth = data.useTlsAuth; + useHttpProxy= data.useHttpProxy; + dontSaveUsername= data.dontSaveUsername; + useModeConfig= data.useModeConfig; + useReconnectDelay= data.useReconnectDelay; + useTlsRemoteHost= data.useTlsRemoteHost; + disableOpportunisticEncryption= data.disableOpportunisticEncryption; + useMssfix= data.useMssfix; + useFragment= data.useFragment; + disableCcp= data.disableCcp; + useSmartcard= data.useSmartcard; + useXauthInteractive= data.useXauthInteractive; + savePrivateKeyPassword= data.savePrivateKeyPassword; + useHttpProxyAuth= data.useHttpProxyAuth; + useOnlyCaCertAndUserAuth = data.useOnlyCaCertAndUserAuth; + useMailAddressAsIdentifier = data.useMailAddressAsIdentifier; + useRightNextHop= data.useRightNextHop; + useLeftNextHop= data.useLeftNextHop; + usePkcs11Providers= data.usePkcs11Providers; + allowEmptyPrivateKeyPassword= data.allowEmptyPrivateKeyPassword; + allowIpAddressChangeOfPeer= data.allowIpAddressChangeOfPeer; + useSearchDomainInResolvConf= data.useSearchDomainInResolvConf; + useDomainInResolvConf= data.useDomainInResolvConf; + Mtu= data.Mtu; + Mru= data.Mru; + UdpPort = data.UdpPort; + LocalPort = data.LocalPort; + RemotePort = data.RemotePort; + UserdefinedPort= data.UserdefinedPort; + connectionStatusCheckSuccessCount = data.connectionStatusCheckSuccessCount; + connectionStatusInterval = data.connectionStatusInterval; + HttpProxyPort= data.HttpProxyPort; + HttpProxyTimeout= data.HttpProxyTimeout; + ReconnectDelay= data.ReconnectDelay; + Mssfix= data.Mssfix; + Fragment= data.Fragment; + PeerTimeout = data.PeerTimeout; + CommandAfterConnectDelayTime = data.CommandAfterConnectDelayTime; +} +*/ + +QString VpnAccountData::getName() const +{ + return Name; +} + +VpnAccountData::ConnectionType VpnAccountData::getConnectionType() const +{ + return connectiontype; +} + +QString VpnAccountData::getGateway() const +{ + return Gateway; +} + +QString VpnAccountData::getID() const +{ + return ID; +} + +QString VpnAccountData::getTunnelDeviceType() const +{ + return TunnelDeviceType; +} + +QString VpnAccountData::getUserName() const +{ + return Username; +} + +QString VpnAccountData::getUserPassword() const +{ + return UserPassword; +} + +bool VpnAccountData::getSaveUserPassword() const +{ + return saveUserPassword; +} + +bool VpnAccountData::getSavePsk() const +{ + return savePsk; +} + +QString VpnAccountData::getIkeGroup() const +{ + return IkeGroup; +} + +QString VpnAccountData::getEncryptionAlgorithm() const +{ + return EncryptionAlgorithm; +} + +QString VpnAccountData::getAuthenticationAlgorithm() const +{ + return AuthenticationAlgorithm; +} + +QString VpnAccountData::getPerfectForwardSecrety() const +{ + return PerfectForwardSecrecy; +} + +QString VpnAccountData::getNtDomainName() const +{ + return NtDomainName; +} + +QString VpnAccountData::getApplicationVersion() const +{ + return ApplicationVersion; +} + +bool VpnAccountData::getUseSingleDes() const +{ + return useSingleDes; + +} + +bool VpnAccountData::getUseIkeGroup() const +{ + return useIkeGroup; +} + +bool VpnAccountData::getUsePerfectForwardSecrety() const +{ + return usePerfectForwardSecrety; +} + +bool VpnAccountData::getUseNtDomainName() const +{ + return useNtDomainName; +} + +bool VpnAccountData::getUseApplicationVersion() const +{ + return useApplicationVersion; +} + +bool VpnAccountData::getUseLocalPort() const +{ + return useLocalPort; +} + +bool VpnAccountData::getUseRemotePort() const +{ + return useRemotePort; +} + +bool VpnAccountData::getUseAdvancedSettings() const +{ + return useAdvancedSettings; +} + +bool VpnAccountData::getUseGlobalIpsecSecret() const +{ + return useGlobalIpsecSecret; +} + +int VpnAccountData::getLocalPort() const +{ + return LocalPort; +} + +int VpnAccountData::getRemotePort() const +{ + return RemotePort; +} + +QString VpnAccountData::getRemoteNetAddr() const +{ + return RemoteNetAddr; +} + +QString VpnAccountData::getRemoteNetMask() const +{ + return RemoteNetMask; +} + +QString VpnAccountData::getPreSharedKey() const +{ + return PreSharedKey; +} + +QString VpnAccountData::getX509Certificate() const +{ + return x509Certificate; +} + +QString VpnAccountData::getCaCertificate() const +{ + return CaCertificate; +} + +QString VpnAccountData::getNetworkDevice() const +{ + if (NetworkDevice != QString::null) + return NetworkDevice; + else + return ""; +} + +QString VpnAccountData::getCertPath() const +{ + return CertPath; +} + +VpnAccountData::AuthenticationType VpnAccountData::getAuthType() const +{ + return authtype; +} + +bool VpnAccountData::getDoPingIP() const +{ + return doPingIP; +} + +QString VpnAccountData::getPingHostIP() const +{ + return pingHostIP; +} + +QString VpnAccountData::getPrivateKeyPass() const +{ + return PrivateKeyPass; +} + +QString VpnAccountData::getPrivateKey() const +{ + return PrivateKey; +} + +bool VpnAccountData::getUseSpecialRemoteID() const +{ + return useSpecialRemoteID; +} + +bool VpnAccountData::getUseSpecialLocalID() const +{ + return useSpecialLocalID; +} + +QString VpnAccountData::getSpecialRemoteID() const +{ + return SpecialRemoteID; +} + +QString VpnAccountData::getSpecialLocalID() const +{ + return SpecialLocalID; +} + +QString VpnAccountData::getLocalIDType() const +{ + return LocalIDType; +} + +QString VpnAccountData::getRemoteIDType() const +{ + return RemoteIDType; +} + +bool VpnAccountData::getUseUdp() const +{ + return useUdp; +} + +bool VpnAccountData::getUseUdpPort() const +{ + return useUdpPort; +} + +int VpnAccountData::getUdpPort() const +{ + return UdpPort; +} + +bool VpnAccountData::getUseDnsUpdate() const +{ + return useDnsUpdate; +} + +bool VpnAccountData::getUseDnsServer() const +{ + return useDnsServer; +} + +QString VpnAccountData::getDnsServer() const +{ + return DnsServer; +} + +bool VpnAccountData::getRefuse40BitEncryption() const +{ + return refuse40BitEncryption; +} + +bool VpnAccountData::getRefuse128BitEncryption() const +{ + return refuse128BitEncryption; +} + +bool VpnAccountData::getAllowStatefulMode() const +{ + return allowStatefulMode; +} + +bool VpnAccountData::getRequireMppe() const +{ + return requireMppe; +} + +bool VpnAccountData::getUseNoIpDefault() const +{ + return useNoIpDefault; +} + +bool VpnAccountData::getDisableMPPEComp() const +{ + return disableMPPEComp; +} + +bool VpnAccountData::getUseSpecialServerCertificate() const +{ + return useSpecialServerCertificate; +} + +QString VpnAccountData::getSpecialServerCertificate() const +{ + return SpecialServerCertificate; +} + +QString VpnAccountData::getLocalVirtualIP() const +{ + return LocalVirtualIP; +} + +QString VpnAccountData::getRemoteVirtualIP() const +{ + return RemoteVirtualIP; +} + +QString VpnAccountData::getPreSharedKeyFile() const +{ + return PreSharedKeyFile; +} + +bool VpnAccountData::getExecuteCmdBeforeConnect() const +{ + return executeCmdBeforeConnect; +} + +bool VpnAccountData::getExecuteCmdAfterConnect() const +{ + return executeCmdAfterConnect; +} + +bool VpnAccountData::getExecuteCmdBeforeDisconnect() const +{ + return executeCmdBeforeDisconnect; +} + +bool VpnAccountData::getExecuteCmdAfterDisconnect() const +{ + return executeCmdAfterDisconnect; +} + +QString VpnAccountData::getCommandBeforeConnect() const +{ + return CommandBeforeConnect; +} + +QString VpnAccountData::getCommandAfterConnect() const +{ + return CommandAfterConnect; +} + +QString VpnAccountData::getCommandBeforeDisconnect() const +{ + return CommandBeforeDisconnect; +} + +QString VpnAccountData::getCommandAfterDisconnect() const +{ + return CommandAfterDisconnect; +} + +bool VpnAccountData::getUseNoBsdComp() const +{ + return useNoBsdComp; +} + +bool VpnAccountData::getUseNoDeflate() const +{ + return useNoDeflate; +} + +bool VpnAccountData::getReplaceDefaultRoute() const +{ + return replaceDefaultRoute; +} + +bool VpnAccountData::getUseMtu() const +{ + return useMtu; +} + +int VpnAccountData::getMtu() const +{ + return Mtu; +} + +bool VpnAccountData::getUseMru() const +{ + return useMru; +} + +int VpnAccountData::getMru() const +{ + return Mru; +} + +bool VpnAccountData::getUseVirtualIP() const +{ + return useVirtualIP; +} + +QString VpnAccountData::getVirtualIP() const +{ + return VirtualIP; +} + +bool VpnAccountData::getPskIsInFile() const +{ + return PskIsInFile; +} + +bool VpnAccountData::getUseAdditionalNetworkRoutes() const +{ + return useAdditionalNetworkRoutes; +} + +QStringList VpnAccountData::getAdditionalNetworkRoutes() const +{ + return AdditionalNetworkRoutes; +} + +QString VpnAccountData::getHashAlgo() const +{ + return HashAlgo; +} + +bool VpnAccountData::getUseUserdefinedPort() const +{ + return useUserdefinedPort; +} + +int VpnAccountData::getUserdefinedPort() const +{ + return UserdefinedPort; +} + +QString VpnAccountData::getDescription() const +{ + return Description; +} + +QString VpnAccountData::getNsCertType() const +{ + return NsCertType; +} + +bool VpnAccountData::getUseNsCertType() const +{ + return useNsCertType; +} + +bool VpnAccountData::getUseConnectionStatusCheck() const +{ + return useConnectionStatusCheck; +} + +int VpnAccountData::getConnectionStatusCheckSuccessCount() const +{ + return connectionStatusCheckSuccessCount; +} + +int VpnAccountData::getConnectionStatusInterval() const +{ + return connectionStatusInterval; +} + +bool VpnAccountData::getDoReconnectAfterConnectionLost() const +{ + return doReconnectAfterConnectionLost; +} + +bool VpnAccountData::getDisableLzoCompression() const +{ + return disableLzoCompression; +} + +bool VpnAccountData::getAuthWithUsernameAndPassword() const +{ + return authWithUsernameAndPassword; +} + +bool VpnAccountData::getAllowEmptyGroupPassword() const +{ + return allowEmptyGroupPassword; +} + +bool VpnAccountData::getUseUserdefiniedCipher() const +{ + return useUserdefiniedCipher; +} + +QString VpnAccountData::getUserdefiniedCipher() const +{ + return UserdefiniedCipher; +} + +bool VpnAccountData::getUseRedirectGateway() const +{ + return useRedirectGateway; +} + +bool VpnAccountData::getUseTlsAuth() const +{ + return useTlsAuth; +} + +QString VpnAccountData::getTlsAuthFile() const +{ + return TlsAuthFile; +} + +QString VpnAccountData::getHttpProxy() const +{ + return HttpProxy; +} + +bool VpnAccountData::getUseHttpProxy() const +{ + return useHttpProxy; +} + +int VpnAccountData::getHttpProxyPort() const +{ + return HttpProxyPort; +} + +int VpnAccountData::getHttpProxyTimeout() const +{ + return HttpProxyTimeout; +} + +bool VpnAccountData::getDontSaveUsername() const +{ + return dontSaveUsername; +} + +bool VpnAccountData::getUseModeConfig() const +{ + return useModeConfig; +} + +QString VpnAccountData::getExchangeMode() const +{ + return ExchangeMode; +} + +bool VpnAccountData::getUseReconnectDelay() const +{ + return useReconnectDelay; +} + +int VpnAccountData::getReconnectDelay() const +{ + return ReconnectDelay; +} + +bool VpnAccountData::getUseTlsRemoteHost() const +{ + return useTlsRemoteHost; +} + +QString VpnAccountData::getTlsRemoteHost() const +{ + return TlsRemoteHost; +} + +QString VpnAccountData::getRightNextHop() const +{ + return RightNextHop; +} + +QString VpnAccountData::getLeftNextHop() const +{ + return LeftNextHop; +} + +bool VpnAccountData::getDisableOpportunisticEncryption() const +{ + return disableOpportunisticEncryption; +} + +bool VpnAccountData::getUseMssfix() const +{ + return useMssfix; +} + +bool VpnAccountData::getUseFragment() const +{ + return useFragment; +} + +int VpnAccountData::getMssfix() const +{ + return Mssfix; +} + +int VpnAccountData::getFragment() const +{ + return Fragment; +} + +int VpnAccountData::getPeerTimeout() const +{ + return PeerTimeout; +} + +bool VpnAccountData::getDisableCcp() const +{ + return disableCcp; +} + +bool VpnAccountData::getUseSmartcard() const +{ + return useSmartcard; +} + +bool VpnAccountData::getUseXauthInteractive() const +{ + return useXauthInteractive; +} + +bool VpnAccountData::getSavePrivateKeyPassword() const +{ + return savePrivateKeyPassword; +} + +bool VpnAccountData::getUseHttpProxyAuth() const +{ + return useHttpProxyAuth; +} + +QString VpnAccountData::getHttpProxyAuthType() const +{ + return HttpProxyAuthType; +} + +QString VpnAccountData::getHttpProxyUser() const +{ + return HttpProxyUser; +} + +QString VpnAccountData::getHttpProxyPass() const +{ + return HttpProxyPass; +} + +bool VpnAccountData::getUseOnlyCaCertAndUserAuth() const +{ + return useOnlyCaCertAndUserAuth; +} + +bool VpnAccountData::getUseMailAddressAsIdentifier() const +{ + return useMailAddressAsIdentifier; +} + +bool VpnAccountData::getUseRightNextHop() const +{ + return useRightNextHop; +} + +bool VpnAccountData::getUseLeftNextHop() const +{ + return useLeftNextHop; +} + +QString VpnAccountData::getPkcs11Providers() const +{ + return Pkcs11Providers; +} + +QString VpnAccountData::getPkcs11SlotType() const +{ + return Pkcs11SlotType; +} + +QString VpnAccountData::getPkcs11Slot() const +{ + return Pkcs11Slot; +} + +QString VpnAccountData::getPkcs11IdType() const +{ + return Pkcs11IdType; +} + +QString VpnAccountData::getPkcs11Id() const +{ + return Pkcs11Id; +} + +QString VpnAccountData::getPkcs11SignMode() const +{ + return Pkcs11SignMode; +} + +bool VpnAccountData::getUsePkcs11Providers() const +{ + return usePkcs11Providers; +} + +bool VpnAccountData::getAllowEmptyPrivateKeyPassword() const +{ + return allowEmptyPrivateKeyPassword; +} + +bool VpnAccountData::getAllowIpAddressChangeOfPeer() const +{ + return allowIpAddressChangeOfPeer; +} + +QString VpnAccountData::getAuthMethod() const +{ + return AuthMethod; +} + +int VpnAccountData::getCommandAfterConnectDelayTime() const +{ + return CommandAfterConnectDelayTime; +} + +bool VpnAccountData::getUseSearchDomainInResolvConf() const +{ + return useSearchDomainInResolvConf; +} + +bool VpnAccountData::getUseDomainInResolvConf() const +{ + return useDomainInResolvConf; +} + +QString VpnAccountData::getSearchDomainInResolvConf() const +{ + return SearchDomainInResolvConf; +} + +QString VpnAccountData::getDomainInResolvConf() const +{ + return DomainInResolvConf; +} + +QString VpnAccountData::getAuthenticationDirection() const +{ + return AuthenticationDirection; +} + +QString VpnAccountData::getCiscoNatMode() const +{ + return CiscoNatMode; +} + +QString VpnAccountData::getIpsecEsp() const +{ + return IpsecEsp; +} + +QString VpnAccountData::getIpsecIke() const +{ + return IpsecIke; +} + +QString VpnAccountData::getVtunProfile() const +{ + return VtunProfile; +} + +bool VpnAccountData::getDisableDataEncryption() const +{ + return disableDataEncryption; +} + +bool VpnAccountData::getUseAuthenticationAlgorithm() const +{ + return useAuthenticationAlgorithm; +} + +bool VpnAccountData::getFixPathMtuDiscoveryProblem() const +{ + return fixPathMtuDiscoveryProblem; +} + +bool VpnAccountData::getUseRemoteNetwork() const +{ + return useRemoteNetwork; +} + +QString VpnAccountData::getIpsecVpnMode() const +{ + return IpsecVpnMode; +} + +bool VpnAccountData::getDisableHeaderCompression() const +{ + return disableHeaderCompression; +} + +bool VpnAccountData::getDisableMagicNumberNegotiation() const +{ + return disableMagicNumberNegotiation; +} + +bool VpnAccountData::getDisableIpx() const +{ + return disableIpx; +} + +bool VpnAccountData::getDisableProtocolFieldCompression() const +{ + return disableProtocolFieldCompression; +} + +bool VpnAccountData::getDisableAdressControlCompression() const +{ + return disableAdressControlCompression; +} + +bool VpnAccountData::getUseCustomIke() const +{ + return useCustomIke; +} + +bool VpnAccountData::getUseCustomEsp() const +{ + return useCustomEsp; +} + +bool VpnAccountData::getVerifyCaCert() const +{ + return verifyCaCert; +} + +bool VpnAccountData::getUseDpdIdleTimeout() const +{ + return useDpdIdleTimeout; +} + +int VpnAccountData::getDpdIdleTimeout() const +{ + return DpdIdleTimeout; +} + +bool VpnAccountData::getHideGroupPasswordInAccountDataDialog() const +{ + return hideGroupPasswordInAccountDataDialog; +} + +int VpnAccountData::getMaxConnectTries() const +{ + return MaxConnectTries; +} + +VpnAccountData::L2tpDaemonType VpnAccountData::getL2tpDaemon() const +{ + return L2tpDaemon; +} + +bool VpnAccountData::getUseLeftSourceIp() const +{ + return useLeftSourceIp; +} + +bool VpnAccountData::getUseRightSourceIp() const +{ + return useRightSourceIp; +} + +QString VpnAccountData::getLeftSourceIp() const +{ + return LeftSourceIp; +} + +QString VpnAccountData::getRightSourceIp() const +{ + return RightSourceIp; +} + +bool VpnAccountData::getUseVirtualSubnetworks() const +{ + return useVirtualSubnetworks; +} + +QString VpnAccountData::getVirtualSubnetworks() const +{ + return VirtualSubnetworks; +} + +bool VpnAccountData::getDisablePushFromServer() const +{ + return disablePushFromServer; +} + +bool VpnAccountData::getDisableBind() const +{ + return disableBind; +} + +bool VpnAccountData::getUseRenegSec() const +{ + return useRenegSec; +} + +int VpnAccountData::getRenegSec() const +{ + return RenegSec; +} + +bool VpnAccountData::getUseTunnelPing() const +{ + return useTunnelPing; +} + +int VpnAccountData::getTunnelPing() const +{ + return TunnelPing; +} + +bool VpnAccountData::getUseTunnelPingRestart() const +{ + return useTunnelPingRestart; +} + +int VpnAccountData::getTunnelPingRestart() const +{ + return TunnelPingRestart; +} + +bool VpnAccountData::getRequireEap() const +{ + return requireEap; +} + +bool VpnAccountData::getUseSshConfigRemoteScript() const +{ + return useSshConfigRemoteScript; +} + +QString VpnAccountData::getSshConfigRemoteScript() const +{ + return SshConfigRemoteScript; +} + +bool VpnAccountData::getAskUserPasswordOnEachConnect() const +{ + return askUserPasswordOnEachConnect; +} + +bool VpnAccountData::getUseCiscoCertStore() const +{ + return useCiscoCertStore; +} + +bool VpnAccountData::getUseNat() const +{ + return useNat; +} + +/* set methods */ +void VpnAccountData::setConnectionType( ConnectionType type ) +{ + this->connectiontype = type; +} + +void VpnAccountData::setName( const QString &Name ) +{ + this->Name = Name; +} + +void VpnAccountData::setGateway( const QString &Gateway ) +{ + this->Gateway = Gateway; +} + +void VpnAccountData::setID( const QString &ID ) +{ + this->ID = ID; +} + +void VpnAccountData::setUserName( const QString &Username ) +{ + this->Username = Username; +} + +void VpnAccountData::setUserPassword( const QString& UserPassword ) +{ + this->UserPassword = UserPassword; +} + +void VpnAccountData::setSaveUserPassword( bool saveUserPassword ) +{ + this->saveUserPassword = saveUserPassword; +} + +void VpnAccountData::setSavePsk( bool savePsk ) +{ + this->savePsk = savePsk; +} + +void VpnAccountData::setIkeGroup( const QString &IkeGroup ) +{ + this->IkeGroup = IkeGroup; +} + +void VpnAccountData::setEncryptionAlgorithm( const QString &EncryptionAlgorithm ) +{ + this->EncryptionAlgorithm = EncryptionAlgorithm; +} + +void VpnAccountData::setAuthenticationAlgorithm( const QString &AuthenticationAlgorithm) +{ + this->AuthenticationAlgorithm= AuthenticationAlgorithm; +} + +void VpnAccountData::setPerfectForwardSecrety( const QString &PerfectForwardSecrecy ) +{ + this->PerfectForwardSecrecy = PerfectForwardSecrecy; +} + +void VpnAccountData::setNtDomainName( const QString& Name ) +{ + this->NtDomainName = Name; +} + +void VpnAccountData::setApplicationVersion( const QString& version ) +{ + this->ApplicationVersion = version; +} + +void VpnAccountData::setUseSingleDes( bool useSingleDes ) +{ + this->useSingleDes = useSingleDes; +} + +void VpnAccountData::setUseIkeGroup( bool useIkeGroup ) +{ + this->useIkeGroup = useIkeGroup; +} + +void VpnAccountData::setUsePerfectForwardSecrety( bool usePerfectForwardSecrety ) +{ + this->usePerfectForwardSecrety = usePerfectForwardSecrety; +} + +void VpnAccountData::setUseNtDomainName( bool useNtDomainName ) +{ + this->useNtDomainName = useNtDomainName; +} + +void VpnAccountData::setUseApplicationVersion( bool useApplicationVersion ) +{ + this->useApplicationVersion = useApplicationVersion; +} + +void VpnAccountData::setUseLocalPort( bool useLocalPort ) +{ + this->useLocalPort = useLocalPort; +} + +void VpnAccountData::setUseRemotePort( bool useRemotePort ) +{ + this->useRemotePort = useRemotePort; +} + +void VpnAccountData::setUseAdvancedSettings( bool useAdvancedSettings ) +{ + this->useAdvancedSettings = useAdvancedSettings; +} + +void VpnAccountData::setUseGlobalIpsecSecret( bool useGlobalIpsecSecret ) +{ + this->useGlobalIpsecSecret = useGlobalIpsecSecret; +} + +void VpnAccountData::setLocalPort( int port ) +{ + this->LocalPort = port; +} + +void VpnAccountData::setRemotePort( int port ) +{ + this->RemotePort = port; +} + +void VpnAccountData::setRemoteNetAddr( const QString& RemoteNetAddr ) +{ + this->RemoteNetAddr = RemoteNetAddr; +} + +void VpnAccountData::setRemoteNetMask( const QString& RemoteNetMask ) +{ + this->RemoteNetMask = RemoteNetMask; +} + +void VpnAccountData::setPreSharedKey( const QString& PreSharedKey ) +{ + this->PreSharedKey = PreSharedKey; +} + +void VpnAccountData::setX509Certificate( const QString& x509Certificate ) +{ + this->x509Certificate = x509Certificate; +} + +void VpnAccountData::setCaCertificate( const QString& CaCertificate ) +{ + this->CaCertificate = CaCertificate; +} + +void VpnAccountData::setNetworkDevice( const QString& NetworkDevice ) +{ + this->NetworkDevice = NetworkDevice; +} + +void VpnAccountData::setCertPath( const QString& CertPath ) +{ + this->CertPath = CertPath; +} + +void VpnAccountData::setAuthType( VpnAccountData::AuthenticationType authtype ) +{ + this->authtype = authtype; +} + +void VpnAccountData::setDoPingIP(bool doPingIP) +{ + this->doPingIP=doPingIP; +} + +void VpnAccountData::setPingHostIP(const QString& pingHostIP) +{ + this->pingHostIP = pingHostIP; +} + +void VpnAccountData::setPrivateKeyPass(const QString& PrivateKeyPass) +{ + this->PrivateKeyPass = PrivateKeyPass; +} + +void VpnAccountData::setPrivateKey(const QString& PrivateKey) +{ + this->PrivateKey = PrivateKey; +} + +void VpnAccountData::setUseSpecialRemoteID(bool useSpecialRemoteID) +{ + this->useSpecialRemoteID = useSpecialRemoteID; +} + +void VpnAccountData::setUseSpecialLocalID(bool useSpecialLocalID) +{ + this->useSpecialLocalID = useSpecialLocalID; +} + +void VpnAccountData::setSpecialRemoteID(const QString& SpecialRemoteID) +{ + this->SpecialRemoteID = SpecialRemoteID; +} + +void VpnAccountData::setSpecialLocalID(const QString& SpecialLocalID) +{ + this->SpecialLocalID = SpecialLocalID; +} + +void VpnAccountData::setLocalIDType(const QString& LocalIDType) +{ + this->LocalIDType = LocalIDType; +} + +void VpnAccountData::setRemoteIDType(const QString& RemoteIDType) +{ + this->RemoteIDType = RemoteIDType; +} + +void VpnAccountData::setUseUdp(bool useUdp) +{ + this->useUdp = useUdp; +} + +void VpnAccountData::setUseUdpPort(bool useUdpPort) +{ + this->useUdpPort = useUdpPort; +} + +void VpnAccountData::setUdpPort(int UdpPort) +{ + this->UdpPort = UdpPort; +} + +void VpnAccountData::setUseDnsUpdate(bool useDnsUpdate ) +{ + this->useDnsUpdate = useDnsUpdate; +} + +void VpnAccountData::setUseDnsServer(bool useDnsServer ) +{ + this->useDnsServer = useDnsServer; +} + +void VpnAccountData::setDnsServer(const QString& DnsServer ) +{ + this->DnsServer = DnsServer; +} + +void VpnAccountData::setRefuse40BitEncryption(bool refuse40BitEncryption ) +{ + this->refuse40BitEncryption = refuse40BitEncryption; +} + +void VpnAccountData::setRefuse128BitEncryption(bool refuse128BitEncryption ) +{ + this->refuse128BitEncryption = refuse128BitEncryption; +} + +void VpnAccountData::setAllowStatefulMode(bool allowStatefulMode ) +{ + this->allowStatefulMode = allowStatefulMode; +} + +void VpnAccountData::setRequireMppe(bool requireMppe ) +{ + this->requireMppe = requireMppe; +} + +void VpnAccountData::setUseNoIpDefault(bool useNoIpDefault ) +{ + this->useNoIpDefault = useNoIpDefault; +} + +void VpnAccountData::setDisableMPPEComp(bool disableMPPEComp ) +{ + this->disableMPPEComp = disableMPPEComp; +} + +void VpnAccountData::setLocalVirtualIP( const QString& LocalVirtualIP ) +{ + this->LocalVirtualIP = LocalVirtualIP; +} + +void VpnAccountData::setRemoteVirtualIP( const QString& RemoteVirtualIP ) +{ + this->RemoteVirtualIP = RemoteVirtualIP; +} + +void VpnAccountData::setPreSharedKeyFile( const QString& PreSharedKeyFile) +{ + this->PreSharedKeyFile = PreSharedKeyFile; +} + +void VpnAccountData::setExecuteCmdBeforeConnect(bool executeCmdBeforeConnect) +{ + this->executeCmdBeforeConnect = executeCmdBeforeConnect; +} + +void VpnAccountData::setExecuteCmdAfterConnect(bool executeCmdAfterConnect) +{ + this->executeCmdAfterConnect = executeCmdAfterConnect; +} + +void VpnAccountData::setExecuteCmdBeforeDisconnect( bool executeCmdBeforeDisconnect) +{ + this->executeCmdBeforeDisconnect = executeCmdBeforeDisconnect; +} + +void VpnAccountData::setExecuteCmdAfterDisconnect( bool executeCmdAfterDisconnect) +{ + this->executeCmdAfterDisconnect = executeCmdAfterDisconnect; +} + +void VpnAccountData::setCommandBeforeConnect(const QString& CommandBeforeConnect) +{ + this->CommandBeforeConnect = CommandBeforeConnect; +} + +void VpnAccountData::setCommandAfterConnect(const QString& CommandAfterConnect) +{ + this->CommandAfterConnect = CommandAfterConnect; +} + +void VpnAccountData::setCommandBeforeDisconnect(const QString& CommandBeforeDisconnect) +{ + this->CommandBeforeDisconnect = CommandBeforeDisconnect; +} + +void VpnAccountData::setCommandAfterDisconnect(const QString& CommandAfterDisconnect) +{ + this->CommandAfterDisconnect = CommandAfterDisconnect; +} + +void VpnAccountData::setUseNoBsdComp(bool useNoBsdComp) +{ + this->useNoBsdComp = useNoBsdComp; +} + +void VpnAccountData::setUseNoDeflate(bool useNoDeflate) +{ + this->useNoDeflate = useNoDeflate; +} + +void VpnAccountData::setReplaceDefaultRoute(bool replaceDefaultRoute) +{ + this->replaceDefaultRoute = replaceDefaultRoute; +} + +void VpnAccountData::setUseMtu(bool useMtu) +{ + this->useMtu = useMtu; +} + +void VpnAccountData::setMtu(int Mtu) +{ + this->Mtu = Mtu; +} + +void VpnAccountData::setUseMru(bool useMru) +{ + this->useMru = useMru; +} + +void VpnAccountData::setMru(int Mru) +{ + this->Mru = Mru; +} + +void VpnAccountData::setUseVirtualIP(bool useVirtualIP ) +{ + this->useVirtualIP = useVirtualIP; +} + +void VpnAccountData::setVirtualIP(const QString& VirtualIP ) +{ + this->VirtualIP = VirtualIP; +} + +void VpnAccountData::setPskIsInFile(bool PskIsInFile) +{ + this->PskIsInFile = PskIsInFile; +} + +void VpnAccountData::setUseAdditionalNetworkRoutes( bool useAdditionalNetworkRoutes ) +{ + this->useAdditionalNetworkRoutes = useAdditionalNetworkRoutes; +} + +void VpnAccountData::setAdditionalNetworkRoutes( QStringList AdditionalNetworkRoutes ) +{ + this->AdditionalNetworkRoutes = AdditionalNetworkRoutes; +} + +void VpnAccountData::setUseSpecialServerCertificate(bool useSpecialServerCertificate) +{ + this->useSpecialServerCertificate = useSpecialServerCertificate; +} + +void VpnAccountData::setSpecialServerCertificate(const QString& SpecialServerCertificate) +{ + this->SpecialServerCertificate = SpecialServerCertificate; +} + +void VpnAccountData::setHashAlgo(const QString& HashAlgo) +{ + this->HashAlgo = HashAlgo; +} + +void VpnAccountData::setTunnelDeviceType(const QString& TunnelDeviceType) +{ + this->TunnelDeviceType = TunnelDeviceType; +} + +void VpnAccountData::setUseUserdefinedPort(bool useUserdefinedPort) +{ + this->useUserdefinedPort = useUserdefinedPort; +} + +void VpnAccountData::setUserdefinedPort(int UserdefinedPort) +{ + this->UserdefinedPort = UserdefinedPort; +} + +void VpnAccountData::setDescription(const QString& Description) +{ + this->Description = Description; +} + +void VpnAccountData::setNsCertType(const QString& NsCertType) +{ + this->NsCertType = NsCertType; +} + +void VpnAccountData::setUseNsCertType(bool useNsCertType) +{ + this->useNsCertType = useNsCertType; +} + +void VpnAccountData::setUseConnectionStatusCheck(bool useConnectionStatusCheck) +{ + this->useConnectionStatusCheck=useConnectionStatusCheck; +} + +void VpnAccountData::setConnectionStatusCheckSuccessCount(int connectionStatusCheckSuccessCount) +{ + this->connectionStatusCheckSuccessCount=connectionStatusCheckSuccessCount; +} + +void VpnAccountData::setConnectionStatusInterval(int connectionStatusInterval) +{ + this->connectionStatusInterval=connectionStatusInterval; +} + +void VpnAccountData::setDoReconnectAfterConnectionLost( bool doReconnectAfterConnectionLost ) +{ + this->doReconnectAfterConnectionLost = doReconnectAfterConnectionLost; +} + +void VpnAccountData::setDisableLzoCompression(bool disableLzoCompression ) +{ + this->disableLzoCompression = disableLzoCompression; +} + +void VpnAccountData::setAuthWithUsernameAndPassword(bool authWithUsernameAndPassword ) +{ + this->authWithUsernameAndPassword = authWithUsernameAndPassword; +} + +void VpnAccountData::setAllowEmptyGroupPassword( bool allowEmptyGroupPassword ) +{ + this->allowEmptyGroupPassword = allowEmptyGroupPassword; +} + +void VpnAccountData::setUseUserdefiniedCipher( bool useUserdefiniedCipher ) +{ + this->useUserdefiniedCipher = useUserdefiniedCipher; +} + +void VpnAccountData::setUserdefiniedCipher( QString UserdefiniedCipher ) +{ + this->UserdefiniedCipher = UserdefiniedCipher; +} + +void VpnAccountData::setUseRedirectGateway( bool useRedirectGateway ) +{ + this->useRedirectGateway = useRedirectGateway; +} + +void VpnAccountData::setUseTlsAuth( bool useTlsAuth ) +{ + this->useTlsAuth = useTlsAuth; +} + +void VpnAccountData::setTlsAuthFile( QString TlsAuthFile ) +{ + this->TlsAuthFile = TlsAuthFile; +} + +void VpnAccountData::setHttpProxy( QString HttpProxy ) +{ + this->HttpProxy = HttpProxy; +} + +void VpnAccountData::setUseHttpProxy( bool useHttpProxy ) +{ + this->useHttpProxy = useHttpProxy; +} + +void VpnAccountData::setHttpProxyPort( int HttpProxyPort ) +{ + this->HttpProxyPort = HttpProxyPort; +} + +void VpnAccountData::setHttpProxyTimeout( int HttpProxyTimeout ) +{ + this->HttpProxyTimeout = HttpProxyTimeout; +} + +void VpnAccountData::setDontSaveUsername( bool dontSaveUsername) +{ + this->dontSaveUsername = dontSaveUsername; +} + +void VpnAccountData::setUseModeConfig( bool useModeConfig) +{ + this->useModeConfig = useModeConfig; +} + +void VpnAccountData::setExchangeMode( QString ExchangeMode ) +{ + this->ExchangeMode = ExchangeMode; +} + +void VpnAccountData::setUseReconnectDelay( bool useReconnectDelay ) +{ + this->useReconnectDelay = useReconnectDelay; +} + +void VpnAccountData::setReconnectDelay( int ReconnectDelay ) +{ + this->ReconnectDelay = ReconnectDelay; +} + +void VpnAccountData::setUseTlsRemoteHost( bool useTlsRemoteHost ) +{ + this->useTlsRemoteHost = useTlsRemoteHost; +} + +void VpnAccountData::setTlsRemoteHost( QString TlsRemoteHost ) +{ + this->TlsRemoteHost = TlsRemoteHost; +} + +void VpnAccountData::setRightNextHop( QString RightNextHop ) +{ + this->RightNextHop = RightNextHop; +} + +void VpnAccountData::setLeftNextHop( QString LeftNextHop ) +{ + this->LeftNextHop = LeftNextHop; +} + + void VpnAccountData::setDisableOpportunisticEncryption( bool disableOpportunisticEncryption ) +{ + this->disableOpportunisticEncryption = disableOpportunisticEncryption; +} + + void VpnAccountData::setUseMssfix( bool useMssfix ) +{ + this->useMssfix = useMssfix; +} + + void VpnAccountData::setUseFragment( bool useFragment) +{ + this->useFragment = useFragment; +} + + void VpnAccountData::setMssfix( int Mssfix) +{ + this->Mssfix = Mssfix; +} + + void VpnAccountData::setFragment( int Fragment) +{ + this->Fragment = Fragment; +} + +void VpnAccountData::setPeerTimeout( int PeerTimeout ) +{ + this->PeerTimeout = PeerTimeout; +} + +void VpnAccountData::setDisableCcp( bool disableCcp ) +{ + this->disableCcp = disableCcp; +} + +void VpnAccountData::setUseSmartcard( bool useSmartcard) +{ + this->useSmartcard = useSmartcard; +} + +void VpnAccountData::setUseXauthInteractive( bool useXauthInteractive) +{ + this->useXauthInteractive = useXauthInteractive; +} + +void VpnAccountData::setSavePrivateKeyPassword( bool savePrivateKeyPassword) +{ + this->savePrivateKeyPassword = savePrivateKeyPassword; +} + +void VpnAccountData::setUseHttpProxyAuth( bool useHttpProxyAuth ) +{ + this->useHttpProxyAuth = useHttpProxyAuth; +} + +void VpnAccountData::setHttpProxyAuthType(QString HttpProxyAuthType) +{ + this->HttpProxyAuthType = HttpProxyAuthType; +} + +void VpnAccountData::setHttpProxyUser(QString HttpProxyUser) +{ + this->HttpProxyUser = HttpProxyUser; +} + +void VpnAccountData::setHttpProxyPass( QString HttpProxyPass ) +{ + this->HttpProxyPass = HttpProxyPass; +} + +void VpnAccountData::setUseOnlyCaCertAndUserAuth(bool useOnlyCaCertAndUserAuth) +{ + this->useOnlyCaCertAndUserAuth = useOnlyCaCertAndUserAuth; +} + +void VpnAccountData::setUseMailAddressAsIdentifier(bool useMailAddressAsIdentifier ) +{ + this->useMailAddressAsIdentifier = useMailAddressAsIdentifier; +} + +void VpnAccountData::setUseRightNextHop( bool useRightNextHop ) +{ + this->useRightNextHop = useRightNextHop; +} + +void VpnAccountData::setUseLeftNextHop( bool useLeftNextHop ) +{ + this->useLeftNextHop = useLeftNextHop; +} + +void VpnAccountData::setPkcs11Providers( QString Pkcs11Providers) +{ + this->Pkcs11Providers = Pkcs11Providers; +} + +void VpnAccountData::setPkcs11SlotType(QString Pkcs11SlotType) +{ + this->Pkcs11SlotType = Pkcs11SlotType; +} + +void VpnAccountData::setPkcs11Slot(QString Pkcs11Slot) +{ + this->Pkcs11Slot = Pkcs11Slot; +} + +void VpnAccountData::setPkcs11IdType(QString Pkcs11IdType) +{ + this->Pkcs11IdType = Pkcs11IdType; +} + +void VpnAccountData::setPkcs11Id(QString Pkcs11Id) +{ + this->Pkcs11Id = Pkcs11Id; +} + +void VpnAccountData::setPkcs11SignMode(QString Pkcs11SignMode) +{ + this->Pkcs11SignMode = Pkcs11SignMode; +} + +void VpnAccountData::setUsePkcs11Providers(bool usePkcs11Providers) +{ + this->usePkcs11Providers = usePkcs11Providers; +} + +void VpnAccountData::setAllowEmptyPrivateKeyPassword( bool allowEmptyPrivateKeyPassword) +{ + this->allowEmptyPrivateKeyPassword = allowEmptyPrivateKeyPassword; +} + +void VpnAccountData::setAllowIpAddressChangeOfPeer( bool allowIpAddressChangeOfPeer ) +{ + this->allowIpAddressChangeOfPeer = allowIpAddressChangeOfPeer; +} + +void VpnAccountData::setAuthMethod( QString AuthMethod ) +{ + this->AuthMethod = AuthMethod; +} + +void VpnAccountData::setCommandAfterConnectDelayTime( int CommandAfterConnectDelayTime) +{ + this->CommandAfterConnectDelayTime = CommandAfterConnectDelayTime; +} + +void VpnAccountData::setUseSearchDomainInResolvConf( bool useSearchDomainInResolvConf) +{ + this->useSearchDomainInResolvConf = useSearchDomainInResolvConf; +} + +void VpnAccountData::setUseDomainInResolvConf( bool useDomainInResolvConf) +{ + this->useDomainInResolvConf = useDomainInResolvConf; +} + +void VpnAccountData::setSearchDomainInResolvConf(QString SearchDomainInResolvConf) +{ + this->SearchDomainInResolvConf = SearchDomainInResolvConf; +} + +void VpnAccountData::setDomainInResolvConf(QString DomainInResolvConf) +{ + this->DomainInResolvConf = DomainInResolvConf; +} + +void VpnAccountData::setAuthenticationDirection(QString AuthenticationDirection) +{ + this->AuthenticationDirection = AuthenticationDirection; +} + +void VpnAccountData::setCiscoNatMode(QString CiscoNatMode) +{ + this->CiscoNatMode = CiscoNatMode; +} + +void VpnAccountData::setIpsecEsp(QString IpsecEsp) +{ + this->IpsecEsp = IpsecEsp; +} + +void VpnAccountData::setIpsecIke(QString IpsecIke) +{ + this->IpsecIke = IpsecIke; +} + +void VpnAccountData::setVtunProfile(QString VtunProfile) +{ + this->VtunProfile = VtunProfile; +} + +void VpnAccountData::setDisableDataEncryption(bool disableDataEncryption) +{ + this->disableDataEncryption = disableDataEncryption; +} + +void VpnAccountData::setUseAuthenticationAlgorithm(bool useAuthenticationAlgorithm) +{ + this->useAuthenticationAlgorithm = useAuthenticationAlgorithm; +} + +void VpnAccountData::setFixPathMtuDiscoveryProblem(bool fixPathMtuDiscoveryProblem) +{ + this->fixPathMtuDiscoveryProblem = fixPathMtuDiscoveryProblem; +} + +void VpnAccountData::setUseRemoteNetwork(bool useRemoteNetwork) +{ + this->useRemoteNetwork=useRemoteNetwork; +} + +void VpnAccountData::setIpsecVpnMode(QString IpsecVpnMode) +{ + this->IpsecVpnMode = IpsecVpnMode; +} + +void VpnAccountData::setDisableHeaderCompression(bool disableHeaderCompression) +{ + this->disableHeaderCompression = disableHeaderCompression; +} + +void VpnAccountData::setDisableMagicNumberNegotiation(bool disableMagicNumberNegotiation) +{ + this->disableMagicNumberNegotiation = disableMagicNumberNegotiation; +} + +void VpnAccountData::setDisableIpx(bool disableIpx) +{ + this->disableIpx = disableIpx; +} + +void VpnAccountData::setDisableProtocolFieldCompression(bool disableProtocolFieldCompression) +{ + this->disableProtocolFieldCompression=disableProtocolFieldCompression; +} + +void VpnAccountData::setDisableAdressControlCompression(bool disableAdressControlCompression) +{ + this->disableAdressControlCompression=disableAdressControlCompression; +} + +void VpnAccountData::setUseCustomEsp(bool useCustomEsp) +{ + this->useCustomEsp=useCustomEsp; +} + +void VpnAccountData::setUseCustomIke(bool useCustomIke) +{ + this->useCustomIke=useCustomIke; +} + +void VpnAccountData::setVerifyCaCert(bool verifyCaCert) +{ + this->verifyCaCert=verifyCaCert; +} + +void VpnAccountData::setUseDpdIdleTimeout(bool useDpdIdleTimeout) +{ + this->useDpdIdleTimeout = useDpdIdleTimeout; +} + +void VpnAccountData::setDpdIdleTimeout(int DpdIdleTimeout) +{ + this->DpdIdleTimeout = DpdIdleTimeout; +} + +void VpnAccountData::setHideGroupPasswordInAccountDataDialog(bool hideGroupPasswordInAccountDataDialog) +{ + this->hideGroupPasswordInAccountDataDialog = hideGroupPasswordInAccountDataDialog; +} + +void VpnAccountData::setMaxConnectTries(int MaxConnectTries) +{ + this->MaxConnectTries = MaxConnectTries; +} + +void VpnAccountData::setL2tpDaemon(L2tpDaemonType L2tpDaemon) +{ + this->L2tpDaemon = L2tpDaemon; +} + +void VpnAccountData::setUseLeftSourceIp(bool useLeftSourceIp) +{ + this->useLeftSourceIp = useLeftSourceIp; +} + +void VpnAccountData::setUseRightSourceIp(bool useRightSourceIp) +{ + this->useRightSourceIp = useRightSourceIp; +} + +void VpnAccountData::setLeftSourceIp(QString LeftSourceIp) +{ + this->LeftSourceIp = LeftSourceIp; +} + +void VpnAccountData::setRightSourceIp(QString RightSourceIp) +{ + this->RightSourceIp = RightSourceIp; +} + +void VpnAccountData::setUseVirtualSubnetworks(bool useVirtualSubnetworks) +{ + this->useVirtualSubnetworks = useVirtualSubnetworks; +} + +void VpnAccountData::setVirtualSubnetworks(QString VirtualSubnetworks) +{ + this->VirtualSubnetworks = VirtualSubnetworks; +} + +void VpnAccountData::setDisablePushFromServer(bool disablePushFromServer) +{ + this->disablePushFromServer = disablePushFromServer; +} + +void VpnAccountData::setDisableBind(bool disableBind) +{ + this->disableBind = disableBind; +} + +void VpnAccountData::setUseRenegSec(bool useRenegSec) +{ + this->useRenegSec = useRenegSec; +} + +void VpnAccountData::setRenegSec(int RenegSec) +{ + this->RenegSec = RenegSec; +} + +void VpnAccountData::setUseTunnelPing(bool useTunnelPing) +{ + this->useTunnelPing = useTunnelPing; +} + +void VpnAccountData::setTunnelPing(int TunnelPing) +{ + this->TunnelPing = TunnelPing; +} + +void VpnAccountData::setUseTunnelPingRestart(bool useTunnelPingRestart) +{ + this->useTunnelPing = useTunnelPing; +} + +void VpnAccountData::setTunnelPingRestart(int TunnelPingRestart) +{ + this->TunnelPingRestart = TunnelPingRestart; +} + +void VpnAccountData::setRequireEap(bool requireEap) +{ + this->requireEap = requireEap; +} + +void VpnAccountData::setUseSshConfigRemoteScript(bool useSshConfigRemoteScript) +{ + this->useSshConfigRemoteScript = useSshConfigRemoteScript; +} + +void VpnAccountData::setSshConfigRemoteScript(QString SshConfigRemoteScript) +{ + this->SshConfigRemoteScript = SshConfigRemoteScript; +} + +void VpnAccountData::setAskUserPasswordOnEachConnect( bool askUserPasswordOnEachConnect ) +{ + this->askUserPasswordOnEachConnect = askUserPasswordOnEachConnect; +} + +void VpnAccountData::setUseCiscoCertStore( bool useCiscoCertStore) +{ + this->useCiscoCertStore = useCiscoCertStore; +} + +void VpnAccountData::setUseNat( bool useNat ) +{ + this->useNat = useNat; +} |