summaryrefslogtreecommitdiffstats
path: root/src/vpnaccountdata.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/vpnaccountdata.cpp')
-rw-r--r--src/vpnaccountdata.cpp2291
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;
+}