You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2292 lines
49 KiB
2292 lines
49 KiB
/***************************************************************************
|
|
* 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;
|
|
}
|