Initial import of year-and-a-half-old upstream version 0.9.6a

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;
+}