/***************************************************************************
*   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 TQString& 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.TQStringList 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;
}
*/

TQString VpnAccountData::getName() const
{
	return Name;
}

VpnAccountData::ConnectionType VpnAccountData::getConnectionType() const
{
	return connectiontype;
}

TQString VpnAccountData::getGateway() const
{
	return Gateway;
}

TQString VpnAccountData::getID() const
{
	return ID;
}

TQString VpnAccountData::getTunnelDeviceType() const
{
	return TunnelDeviceType;
}

TQString VpnAccountData::getUserName() const
{
	return Username;
}

TQString VpnAccountData::getUserPassword() const
{
	return UserPassword;
}

bool VpnAccountData::getSaveUserPassword() const
{
	return saveUserPassword;
}

bool VpnAccountData::getSavePsk() const
{
	return savePsk;
}

TQString VpnAccountData::getIkeGroup() const
{
	return IkeGroup;
}

TQString VpnAccountData::getEncryptionAlgorithm() const
{
	return EncryptionAlgorithm;
}

TQString VpnAccountData::getAuthenticationAlgorithm() const
{
	return AuthenticationAlgorithm;
}

TQString VpnAccountData::getPerfectForwardSecrety() const
{
	return PerfectForwardSecrecy;
}

TQString VpnAccountData::getNtDomainName() const
{
	return NtDomainName;
}

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

TQString VpnAccountData::getRemoteNetAddr() const
{
	return RemoteNetAddr;
}

TQString VpnAccountData::getRemoteNetMask() const
{
	return RemoteNetMask;
}

TQString VpnAccountData::getPreSharedKey() const
{
	return PreSharedKey;
}

TQString VpnAccountData::getX509Certificate() const
{
	return x509Certificate;
}

TQString VpnAccountData::getCaCertificate() const
{
	return CaCertificate;
}

TQString VpnAccountData::getNetworkDevice() const
{
	if (NetworkDevice != TQString())
		return NetworkDevice;
	else
		return "";
}

TQString VpnAccountData::getCertPath() const
{
	return CertPath;
}

VpnAccountData::AuthenticationType VpnAccountData::getAuthType() const
{
	return authtype;
}

bool VpnAccountData::getDoPingIP() const
{
	return doPingIP;
}

TQString VpnAccountData::getPingHostIP() const
{
	return pingHostIP;
}

TQString VpnAccountData::getPrivateKeyPass() const
{
	return PrivateKeyPass;
}

TQString VpnAccountData::getPrivateKey() const
{
	return PrivateKey;
}

bool VpnAccountData::getUseSpecialRemoteID() const
{
	return useSpecialRemoteID;
}

bool VpnAccountData::getUseSpecialLocalID() const
{
	return useSpecialLocalID;
}

TQString VpnAccountData::getSpecialRemoteID() const
{
	return SpecialRemoteID;
}

TQString VpnAccountData::getSpecialLocalID() const
{
	return SpecialLocalID;
}

TQString VpnAccountData::getLocalIDType() const
{
	return LocalIDType;
}

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

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

TQString VpnAccountData::getSpecialServerCertificate() const
{
	return SpecialServerCertificate;
}

TQString VpnAccountData::getLocalVirtualIP() const
{
	return LocalVirtualIP;
}

TQString VpnAccountData::getRemoteVirtualIP() const
{
	return RemoteVirtualIP;
}

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

TQString VpnAccountData::getCommandBeforeConnect() const
{
	return CommandBeforeConnect;
}

TQString VpnAccountData::getCommandAfterConnect() const
{
	return CommandAfterConnect;
}

TQString VpnAccountData::getCommandBeforeDisconnect() const
{
	return CommandBeforeDisconnect;
}

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

TQString VpnAccountData::getVirtualIP() const
{
	return VirtualIP;
}

bool VpnAccountData::getPskIsInFile() const
{
	return PskIsInFile;
}

bool VpnAccountData::getUseAdditionalNetworkRoutes() const
{
	return useAdditionalNetworkRoutes;
}

TQStringList VpnAccountData::getAdditionalNetworkRoutes() const
{
	return AdditionalNetworkRoutes;
}

TQString VpnAccountData::getHashAlgo() const
{
	return HashAlgo;
}

bool VpnAccountData::getUseUserdefinedPort() const
{
	return useUserdefinedPort;
}

int VpnAccountData::getUserdefinedPort() const
{
	return UserdefinedPort;
}

TQString VpnAccountData::getDescription() const
{
	return Description;
}

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

TQString VpnAccountData::getUserdefiniedCipher() const
{
	return UserdefiniedCipher;
}

bool VpnAccountData::getUseRedirectGateway() const
{
	return useRedirectGateway;
}

bool VpnAccountData::getUseTlsAuth() const
{
	return useTlsAuth;
}

TQString VpnAccountData::getTlsAuthFile() const
{
	return TlsAuthFile;
}

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

TQString VpnAccountData::getExchangeMode() const
{
	return ExchangeMode;
}

bool VpnAccountData::getUseReconnectDelay() const
{
	return useReconnectDelay;
}

int VpnAccountData::getReconnectDelay() const
{
	return ReconnectDelay;
}

bool VpnAccountData::getUseTlsRemoteHost() const
{
	return useTlsRemoteHost;
}

TQString VpnAccountData::getTlsRemoteHost() const
{
	return TlsRemoteHost;
}

TQString VpnAccountData::getRightNextHop() const
{
	return RightNextHop;
}

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

TQString VpnAccountData::getHttpProxyAuthType() const
{
	return HttpProxyAuthType;
}

TQString VpnAccountData::getHttpProxyUser() const
{
	return HttpProxyUser;
}

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

TQString VpnAccountData::getPkcs11Providers() const
{
	return Pkcs11Providers;
}

TQString VpnAccountData::getPkcs11SlotType() const
{
	return Pkcs11SlotType;
}

TQString VpnAccountData::getPkcs11Slot() const
{
	return Pkcs11Slot;
}

TQString VpnAccountData::getPkcs11IdType() const
{
	return Pkcs11IdType;
}

TQString VpnAccountData::getPkcs11Id() const
{
	return Pkcs11Id;
}

TQString VpnAccountData::getPkcs11SignMode() const
{
	return Pkcs11SignMode;
}

bool VpnAccountData::getUsePkcs11Providers() const
{
	return usePkcs11Providers;
}

bool VpnAccountData::getAllowEmptyPrivateKeyPassword() const
{
	return allowEmptyPrivateKeyPassword;
}

bool VpnAccountData::getAllowIpAddressChangeOfPeer() const
{
	return allowIpAddressChangeOfPeer;
}

TQString VpnAccountData::getAuthMethod() const
{
	return AuthMethod;
}

int VpnAccountData::getCommandAfterConnectDelayTime() const
{
	return CommandAfterConnectDelayTime;
}

bool VpnAccountData::getUseSearchDomainInResolvConf() const
{
	return useSearchDomainInResolvConf;
}

bool VpnAccountData::getUseDomainInResolvConf() const
{
	return useDomainInResolvConf;
}

TQString VpnAccountData::getSearchDomainInResolvConf() const
{
	return SearchDomainInResolvConf;
}

TQString VpnAccountData::getDomainInResolvConf() const
{
	return DomainInResolvConf;
}

TQString VpnAccountData::getAuthenticationDirection() const
{
	return AuthenticationDirection;
}

TQString VpnAccountData::getCiscoNatMode() const
{
	return CiscoNatMode;
}

TQString VpnAccountData::getIpsecEsp() const
{
	return IpsecEsp;
}

TQString VpnAccountData::getIpsecIke() const
{
	return IpsecIke;
}

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

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

TQString VpnAccountData::getLeftSourceIp() const
{
	return LeftSourceIp;
}

TQString VpnAccountData::getRightSourceIp() const
{
	return RightSourceIp;
}

bool VpnAccountData::getUseVirtualSubnetworks() const
{
	return useVirtualSubnetworks;
}

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

TQString 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 TQString &Name )
{
	this->Name = Name;
}

void VpnAccountData::setGateway( const TQString &Gateway )
{
	this->Gateway = Gateway;
}

void VpnAccountData::setID( const TQString &ID )
{
	this->ID = ID;
}

void VpnAccountData::setUserName( const TQString &Username )
{
	this->Username = Username;
}

void VpnAccountData::setUserPassword( const TQString& UserPassword )
{
	this->UserPassword = UserPassword;
}

void VpnAccountData::setSaveUserPassword( bool saveUserPassword )
{
	this->saveUserPassword = saveUserPassword;
}

void VpnAccountData::setSavePsk( bool savePsk )
{
	this->savePsk = savePsk;
}

void VpnAccountData::setIkeGroup( const TQString &IkeGroup )
{
	this->IkeGroup = IkeGroup;
}

void VpnAccountData::setEncryptionAlgorithm( const TQString &EncryptionAlgorithm )
{
	this->EncryptionAlgorithm = EncryptionAlgorithm;
}

void VpnAccountData::setAuthenticationAlgorithm( const TQString &AuthenticationAlgorithm)
{
	this->AuthenticationAlgorithm= AuthenticationAlgorithm;
}

void VpnAccountData::setPerfectForwardSecrety( const TQString &PerfectForwardSecrecy )
{
	this->PerfectForwardSecrecy = PerfectForwardSecrecy;
}

void VpnAccountData::setNtDomainName( const TQString& Name )
{
	this->NtDomainName = Name;
}

void VpnAccountData::setApplicationVersion( const TQString& 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 TQString& RemoteNetAddr )
{
	this->RemoteNetAddr = RemoteNetAddr;
}

void VpnAccountData::setRemoteNetMask( const TQString& RemoteNetMask )
{
	this->RemoteNetMask = RemoteNetMask;
}

void VpnAccountData::setPreSharedKey( const TQString& PreSharedKey )
{
	this->PreSharedKey = PreSharedKey;
}

void VpnAccountData::setX509Certificate( const TQString& x509Certificate )
{
	this->x509Certificate = x509Certificate;
}

void VpnAccountData::setCaCertificate( const TQString& CaCertificate )
{
	this->CaCertificate = CaCertificate;
}

void VpnAccountData::setNetworkDevice( const TQString& NetworkDevice )
{
	this->NetworkDevice = NetworkDevice;
}

void VpnAccountData::setCertPath( const TQString& 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 TQString& pingHostIP)
{
	this->pingHostIP = pingHostIP;
}

void VpnAccountData::setPrivateKeyPass(const TQString& PrivateKeyPass)
{
	this->PrivateKeyPass = PrivateKeyPass;
}

void VpnAccountData::setPrivateKey(const TQString& PrivateKey)
{
	this->PrivateKey = PrivateKey;
}

void VpnAccountData::setUseSpecialRemoteID(bool useSpecialRemoteID)
{
	this->useSpecialRemoteID = useSpecialRemoteID;
}

void VpnAccountData::setUseSpecialLocalID(bool useSpecialLocalID)
{
	this->useSpecialLocalID = useSpecialLocalID;
}

void VpnAccountData::setSpecialRemoteID(const TQString& SpecialRemoteID)
{
	this->SpecialRemoteID = SpecialRemoteID;
}

void VpnAccountData::setSpecialLocalID(const TQString& SpecialLocalID)
{
	this->SpecialLocalID = SpecialLocalID;
}

void VpnAccountData::setLocalIDType(const TQString& LocalIDType)
{
	this->LocalIDType = LocalIDType;
}

void VpnAccountData::setRemoteIDType(const TQString& 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 TQString& 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 TQString& LocalVirtualIP )
{
	this->LocalVirtualIP = LocalVirtualIP;
}

void VpnAccountData::setRemoteVirtualIP( const TQString& RemoteVirtualIP )
{
	this->RemoteVirtualIP = RemoteVirtualIP;
}

void VpnAccountData::setPreSharedKeyFile( const TQString& 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 TQString& CommandBeforeConnect)
{
	this->CommandBeforeConnect = CommandBeforeConnect;
}

void VpnAccountData::setCommandAfterConnect(const TQString& CommandAfterConnect)
{
	this->CommandAfterConnect = CommandAfterConnect;
}

void VpnAccountData::setCommandBeforeDisconnect(const TQString& CommandBeforeDisconnect)
{
	this->CommandBeforeDisconnect = CommandBeforeDisconnect;
}

void VpnAccountData::setCommandAfterDisconnect(const TQString& 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 TQString& VirtualIP )
{
	this->VirtualIP = VirtualIP;
}

void VpnAccountData::setPskIsInFile(bool PskIsInFile)
{
	this->PskIsInFile = PskIsInFile;
}

void VpnAccountData::setUseAdditionalNetworkRoutes( bool useAdditionalNetworkRoutes )
{
	this->useAdditionalNetworkRoutes  = useAdditionalNetworkRoutes;
}

void VpnAccountData::setAdditionalNetworkRoutes( TQStringList AdditionalNetworkRoutes )
{
	this->AdditionalNetworkRoutes = AdditionalNetworkRoutes;
}

void VpnAccountData::setUseSpecialServerCertificate(bool useSpecialServerCertificate)
{
	this->useSpecialServerCertificate = useSpecialServerCertificate;
}

void VpnAccountData::setSpecialServerCertificate(const TQString& SpecialServerCertificate)
{
	this->SpecialServerCertificate = SpecialServerCertificate;
}

void VpnAccountData::setHashAlgo(const TQString& HashAlgo)
{
	this->HashAlgo = HashAlgo;
}

void VpnAccountData::setTunnelDeviceType(const TQString& TunnelDeviceType)
{
	this->TunnelDeviceType = TunnelDeviceType;
}

void VpnAccountData::setUseUserdefinedPort(bool useUserdefinedPort)
{
	this->useUserdefinedPort = useUserdefinedPort;
}

void VpnAccountData::setUserdefinedPort(int UserdefinedPort)
{
	this->UserdefinedPort = UserdefinedPort;
}

void VpnAccountData::setDescription(const TQString& Description)
{
	this->Description = Description;
}

void VpnAccountData::setNsCertType(const TQString& 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( TQString UserdefiniedCipher )
{
	this->UserdefiniedCipher = UserdefiniedCipher;
}

void VpnAccountData::setUseRedirectGateway( bool useRedirectGateway )
{
	this->useRedirectGateway = useRedirectGateway;
}

void VpnAccountData::setUseTlsAuth( bool useTlsAuth )
{
	this->useTlsAuth = useTlsAuth;
}

void VpnAccountData::setTlsAuthFile( TQString TlsAuthFile )
{
	this->TlsAuthFile = TlsAuthFile;
}

void VpnAccountData::setHttpProxy( TQString 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( TQString 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( TQString TlsRemoteHost )
{
	this->TlsRemoteHost = TlsRemoteHost;
}

void VpnAccountData::setRightNextHop( TQString RightNextHop )
{
	this->RightNextHop = RightNextHop;
}

void VpnAccountData::setLeftNextHop( TQString 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(TQString HttpProxyAuthType)
{
	this->HttpProxyAuthType = HttpProxyAuthType;
}

void VpnAccountData::setHttpProxyUser(TQString HttpProxyUser)
{
	this->HttpProxyUser = HttpProxyUser;
}

void VpnAccountData::setHttpProxyPass( TQString 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( TQString Pkcs11Providers)
{
	this->Pkcs11Providers = Pkcs11Providers;
}

void VpnAccountData::setPkcs11SlotType(TQString Pkcs11SlotType)
{
	this->Pkcs11SlotType = Pkcs11SlotType;
}

void VpnAccountData::setPkcs11Slot(TQString Pkcs11Slot)
{
	this->Pkcs11Slot = Pkcs11Slot;
}

void VpnAccountData::setPkcs11IdType(TQString Pkcs11IdType)
{
	this->Pkcs11IdType = Pkcs11IdType;
}

void VpnAccountData::setPkcs11Id(TQString Pkcs11Id)
{
	this->Pkcs11Id = Pkcs11Id;
}

void VpnAccountData::setPkcs11SignMode(TQString 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( TQString 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(TQString SearchDomainInResolvConf)
{
	this->SearchDomainInResolvConf = SearchDomainInResolvConf;
}

void VpnAccountData::setDomainInResolvConf(TQString DomainInResolvConf)
{
	this->DomainInResolvConf = DomainInResolvConf;
}

void VpnAccountData::setAuthenticationDirection(TQString AuthenticationDirection)
{
	this->AuthenticationDirection = AuthenticationDirection;
}

void VpnAccountData::setCiscoNatMode(TQString CiscoNatMode)
{
	this->CiscoNatMode = CiscoNatMode;
}

void VpnAccountData::setIpsecEsp(TQString IpsecEsp)
{
	this->IpsecEsp = IpsecEsp;
}

void VpnAccountData::setIpsecIke(TQString IpsecIke)
{
	this->IpsecIke = IpsecIke;
}

void VpnAccountData::setVtunProfile(TQString 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(TQString 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(TQString LeftSourceIp)
{
	this->LeftSourceIp = LeftSourceIp;
}

void VpnAccountData::setRightSourceIp(TQString RightSourceIp)
{
	this->RightSourceIp = RightSourceIp;
}

void VpnAccountData::setUseVirtualSubnetworks(bool useVirtualSubnetworks)
{
	this->useVirtualSubnetworks = useVirtualSubnetworks;
}

void VpnAccountData::setVirtualSubnetworks(TQString 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(TQString 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;
}
