public static string GetConnectionStringFromUrl(string url, SslMode sslMode = SslMode.Require, bool trustServerCertificate = true)
{
if (url == null)
{
throw new ApiException("Url was null when trying to convert url to connection string", System.Net.HttpStatusCode.InternalServerError);
}
try
{
Uri databaseUri = new Uri(url);
string[] userInfo = databaseUri.UserInfo.Split(':');
ConnectionStringBuilder builder = new ConnectionStringBuilder
{
Host = databaseUri.Host,
Port = databaseUri.Port,
Username = userInfo[0],
Password = userInfo[1],
Database = databaseUri.LocalPath.TrimStart('/'),
SslMode = sslMode,
TrustServerCertificate = trustServerCertificate
};
return(builder.ToString());
}
catch
{
throw new ApiException(new { message = "Unknown error when url was being converted to connection string", urlLength = url.Length }, System.Net.HttpStatusCode.InternalServerError);
}
}
/// <summary>
/// Open connection to host on port.
/// </summary>
/// <param name="host">Host name to connect to.</param>
/// <param name="port">Port to connect to.</param>
/// <param name="isSsl">Enable SSL if it's an ssl</param>
/// <param name="timeout">Determins the time that you allow your application to do transaction, default is 100000</param>
/// <exception cref="ArgumentException"></exception>
internal void Open(string host, int port = 465, SslMode isSsl = SslMode.None, int timeout = 100000)
{
if (string.IsNullOrWhiteSpace(host) || port <= 0)
{
throw new ArgumentException("Invalid Argument found.");
}
_host = host;
_socket.Connect(host, port);
_socket.SendTimeout = timeout;
_socket.ReceiveTimeout = timeout;
if (isSsl == SslMode.Ssl)
{
var sslStream = new SslStream(_socket.GetStream(), true, _validationCallback, ClientCertificateSelectionCallback, EncryptionPolicy);
if (clientcerts == null)
{
sslStream.AuthenticateAsClient(host, null, _sslProtocol, CheckRevokation);
}
else
{
sslStream.AuthenticateAsClient(host, clientcerts, _sslProtocol, CheckRevokation);
}
_writer = new StreamWriter(sslStream, Encoding.ASCII);
_reader = new StreamReader(sslStream, Encoding.ASCII);
_connected = true;
}
else
{
_reader = new StreamReader(_socket.GetStream(), Encoding.ASCII);
_writer = new StreamWriter(_socket.GetStream(), Encoding.ASCII);
_connected = true;
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="target">Target host IP end point.</param>
/// <param name="sslMode">SSL mode.</param>
/// <param name="userName">Target host user name.</param>
/// <param name="password">Target host password.</param>
public Relay_Target(IPEndPoint target, SslMode sslMode, string userName, string password)
{
m_pTarget = target;
m_SslMode = sslMode;
m_UserName = userName;
m_Password = password;
}
public static string StringValue(this SslMode mode)
{
string strValue;
switch (mode)
{
case SslMode.Preferred:
strValue = "1";
break;
case SslMode.Required:
strValue = "2";
break;
case SslMode.VerifyCA:
strValue = "3";
break;
case SslMode.VerifyFull:
strValue = "4";
break;
default:
strValue = "0";
break;
}
return(strValue);
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="hostName">Target host name.</param>
/// <param name="target">Target host IP end point.</param>
/// <param name="sslMode">SSL mode.</param>
/// <param name="userName">Target host user name.</param>
/// <param name="password">Target host password.</param>
public Relay_Target(string hostName,IPEndPoint target,SslMode sslMode,string userName,string password)
{
m_HostName = hostName;
m_pTarget = target;
m_SslMode = sslMode;
m_UserName = userName;
m_Password = password;
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="hostName">Host name.</param>
/// <param name="ip">IP address to listen.</param>
/// <param name="port">Port to listen.</param>
/// <param name="sslMode">Specifies SSL mode.</param>
/// <param name="sslCertificate">Certificate to use for SSL connections.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>ip</b> is null.</exception>
public IPBindInfo(string hostName,
IPAddress ip,
int port,
SslMode sslMode,
X509Certificate2 sslCertificate)
: this(hostName, BindInfoProtocol.TCP, ip, port, sslMode, sslCertificate)
{
}
///<summary>
///</summary>
public SslMode ToSslMode(String Key, SslMode Default)
{
if (!connection_string_values.Contains(Key))
{
return(Default);
}
return((SslMode)Enum.Parse(typeof(SslMode), ToString(Key), true));
}
public DbSettings(
string dbServer, string dbName, string dbUser,
string dbPassword, SslMode dbUseSsl, int dbPort = 3306)
{
DbServer = dbServer;
DbName = dbName;
DbUser = dbUser;
DbPassword = dbPassword;
DbPort = dbPort;
}
public MySqlDb(string dbServer, string dbName, string dbUser,
string dbPassword, SslMode sslMode, int dbPort = DB_DEFAULT_PORT
)
{
var settings = new DbSettings(
dbServer, dbName, dbUser, dbPassword, sslMode, dbPort
);
Initialize(settings);
}
public PostgreSqlConnectionStringBuilder(string db, string host, string password, string user, int port, bool pooling, bool trust, SslMode mode)
{
Database = db;
Host = host;
Password = password;
Username = user;
Port = port;
Pooling = pooling;
TrustServerCertificate = trust;
SslMode = mode;
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="hostName">Host name.</param>
/// <param name="protocol">Bind protocol.</param>
/// <param name="ip">IP address to listen.</param>
/// <param name="port">Port to listen.</param>
/// <param name="sslMode">Specifies SSL mode.</param>
/// <param name="sslCertificate">Certificate to use for SSL connections.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>ip</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public IPBindInfo(string hostName,BindInfoProtocol protocol,IPAddress ip,int port,SslMode sslMode,X509Certificate2 sslCertificate)
{
if(ip == null){
throw new ArgumentNullException("ip");
}
m_HostName = hostName;
m_Protocol = protocol;
m_pEndPoint = new IPEndPoint(ip,port);
m_SslMode = sslMode;
m_pCertificate = sslCertificate;
if((sslMode == SslMode.SSL || sslMode == SslMode.TLS) && sslCertificate == null){
throw new ArgumentException("SSL requested, but argument 'sslCertificate' is not provided.");
}
}
public void Connect_with_Verify_and_callback_throws([Values(SslMode.VerifyCA, SslMode.VerifyFull)] SslMode sslMode)
{
var csb = new NpgsqlConnectionStringBuilder(ConnectionString)
{
SslMode = sslMode
};
var connection = CreateConnection(csb.ToString());
connection.UserCertificateValidationCallback = (_, _, _, _) => true;
var ex = Assert.ThrowsAsync <ArgumentException>(async() => await connection.OpenAsync()) !;
Assert.That(ex.Message, Is.EqualTo(string.Format(NpgsqlStrings.CannotUseSslVerifyWithUserCallback, sslMode)));
}
public void Reject_self_signed_certificate([Values(SslMode.VerifyCA, SslMode.VerifyFull)] SslMode sslMode)
{
var csb = new NpgsqlConnectionStringBuilder(ConnectionString)
{
SslMode = sslMode,
CheckCertificateRevocation = false,
};
using var _ = CreateTempPool(csb, out var connString);
using var conn = new NpgsqlConnection(connString);
var ex = Assert.Throws <NpgsqlException>(conn.Open) !;
Assert.That(ex.InnerException, Is.TypeOf <AuthenticationException>());
}
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
if (Host != null)
{
stringBuilder.Append("Host=");
stringBuilder.Append(Host);
stringBuilder.Append(";");
}
if (Port != 0)
{
stringBuilder.Append("Port=");
stringBuilder.Append(Port);
stringBuilder.Append(";");
}
if (Username != null)
{
stringBuilder.Append("Username="******";");
}
if (Password != null)
{
stringBuilder.Append("Password="******";");
}
if (Database != null)
{
stringBuilder.Append("Database=");
stringBuilder.Append(Database);
stringBuilder.Append(";");
}
stringBuilder.Append("SSL Mode=");
stringBuilder.Append(SslMode.ToString());
stringBuilder.Append(";");
stringBuilder.Append("Trust Server Certificate=");
stringBuilder.Append(TrustServerCertificate);
return(stringBuilder.ToString());
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="hostName">Host name.</param>
/// <param name="protocol">Bind protocol.</param>
/// <param name="ip">IP address to listen.</param>
/// <param name="port">Port to listen.</param>
/// <param name="sslMode">Specifies SSL mode.</param>
/// <param name="sslCertificate">Certificate to use for SSL connections.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>ip</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public IPBindInfo(string hostName, BindInfoProtocol protocol, IPAddress ip, int port, SslMode sslMode, X509Certificate2 sslCertificate)
{
if (ip == null)
{
throw new ArgumentNullException("ip");
}
m_HostName = hostName;
m_Protocol = protocol;
m_pEndPoint = new IPEndPoint(ip, port);
m_SslMode = sslMode;
m_pCertificate = sslCertificate;
if ((sslMode == SslMode.SSL || sslMode == SslMode.TLS) && sslCertificate == null)
{
throw new ArgumentException("SSL requested, but argument 'sslCertificate' is not provided.");
}
}
public MailBuilder(string host, int port, string userName, string passWord, string senderEmailAddresss, string senderDisplayName, SslMode ssl = SslMode.None, bool useHtml = true, bool smime = false, MailPriority messagePriority = MailPriority.Normal, SendCompletedEventHandler onSendCallBack = null, bool encrypt = false, bool sign = false, AuthenticationType authenticationType = AuthenticationType.PlainText)
{
_passWord = passWord;
_ssl = ssl;
_port = port;
_userName = userName;
_host = host;
_useHtml = useHtml;
_senderDisplayName = senderDisplayName;
_senderEmailAddresss = senderEmailAddresss;
_implictSsl = ssl;
_smime = smime;
_onSendCallBack = onSendCallBack;
_encrypt = encrypt;
_sign = sign;
_messagePriority = messagePriority;
_authenticationType = authenticationType;
}
/// <summary>
/// Edit constructor.
/// </summary>
/// <param name="host">Smart host name or IP address.</param>
/// <param name="port">Smart host port.</param>
/// <param name="sslMode">SSL mode.</param>
/// <param name="userName">Smart host user name.</param>
/// <param name="password">Smart host password.</param>
public wfrm_System_SmartHost(string host,int port,SslMode sslMode,string userName,string password)
{
InitUI();
m_pServer.Text = host;
m_pPort.Value = port;
if(sslMode == SslMode.None){
m_pSslMode.SelectedIndex = 0;
}
else if(sslMode == SslMode.SSL){
m_pSslMode.SelectedIndex = 1;
}
else if(sslMode == SslMode.TLS){
m_pSslMode.SelectedIndex = 2;
}
m_pUserName.Text = userName;
m_pPassword.Text = password;
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="host">Smart host name or IP address.</param>
/// <param name="port">Smart host port.</param>
/// <param name="sslMode">Smart host SSL mode.</param>
/// <param name="userName">Smart host user name.</param>
/// <param name="password">Smart host password.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>host</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public Relay_SmartHost(string host,int port,SslMode sslMode,string userName,string password)
{
if(host == null){
throw new ArgumentNullException("host");
}
if(host == ""){
throw new ArgumentException("Argument 'host' value must be specified.");
}
if(port < 1){
throw new ArgumentException("Argument 'port' value is invalid.");
}
m_Host = host;
m_Port = port;
m_SslMode = sslMode;
m_UserName = userName;
m_Password = password;
}
/// <summary>
/// Initiate and construct a smime mailer object
/// </summary>
/// <param name="host">URL address of mail server</param>
/// <param name="port">Port address of mail server</param>
/// <param name="userName">User name of user</param>
/// <param name="passWord">User's password to login to server</param>
/// <param name="senderEmailAddresss">Email address of sender</param>
/// <param name="senderDisplayName">Name of sender</param>
/// <param name="signingCertificate2">Certificate that is user for signing, Note: You can set this with the same cert you use for encryption</param>
/// <param name="encryptionCertificate2">Certificate that is used for Encryption of mail</param>
/// <param name="sslType">Defines type of Ssl that your server uses, if you want to send Implicit Ssl mail use ssl, if explicit it should be TLS</param>
/// <param name="implictSsl">Use implicit ssl</param>
/// <param name="sign">Do you need to sign mail?</param>
/// <param name="toSigningCerts"></param>
/// <param name="toEncryptionCerts"></param>
/// <param name="authenticationType"></param>
/// <param name="encrypt"></param>
public SmimeMailer(string host, int port, string userName, string passWord, string senderEmailAddresss,
string senderDisplayName, X509Certificate2 signingCertificate2 = null,
X509Certificate2 encryptionCertificate2 = null, SslMode sslType = SslMode.None,
bool sign = false,
List <X509Certificate2> toSigningCerts = null, List <X509Certificate2> toEncryptionCerts = null,
AuthenticationType authenticationType = AuthenticationType.Base64, bool encrypt = true) : base(host, port, userName, passWord, sslType, authenticationType)
{
if (encryptionCertificate2 == null || toEncryptionCerts == null)
{
throw new ArgumentNullException("encryptionCertificate2");
}
if (sign && (signingCertificate2 == null || toSigningCerts == null))
{
throw new ArgumentNullException("signingCertificate2");
}
_encrypt = encrypt;
_sign = sign;
From = new SmimeMailAddress(senderEmailAddresss, senderDisplayName, encryptionCertificate2, signingCertificate2);
}
public AddEditSmartHostForm(string host, int port, SslMode sslMode, string userName, string password)
{
this.InitializeComponent();
this.m_pServer.Text = host;
this.m_pPort.Value = port;
if (sslMode == SslMode.None)
{
this.m_pSslMode.SelectedIndex = 0;
}
else if (sslMode == SslMode.SSL)
{
this.m_pSslMode.SelectedIndex = 1;
}
else if (sslMode == SslMode.TLS)
{
this.m_pSslMode.SelectedIndex = 2;
}
this.m_pUserName.Text = userName;
this.m_pPassword.Text = password;
}
/// <summary>
/// Edit constructor.
/// </summary>
/// <param name="host">Smart host name or IP address.</param>
/// <param name="port">Smart host port.</param>
/// <param name="sslMode">SSL mode.</param>
/// <param name="userName">Smart host user name.</param>
/// <param name="password">Smart host password.</param>
public wfrm_System_SmartHost(string host, int port, SslMode sslMode, string userName, string password)
{
InitUI();
m_pServer.Text = host;
m_pPort.Value = port;
if (sslMode == SslMode.None)
{
m_pSslMode.SelectedIndex = 0;
}
else if (sslMode == SslMode.SSL)
{
m_pSslMode.SelectedIndex = 1;
}
else if (sslMode == SslMode.TLS)
{
m_pSslMode.SelectedIndex = 2;
}
m_pUserName.Text = userName;
m_pPassword.Text = password;
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="host">Smart host name or IP address.</param>
/// <param name="port">Smart host port.</param>
/// <param name="sslMode">Smart host SSL mode.</param>
/// <param name="userName">Smart host user name.</param>
/// <param name="password">Smart host password.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>host</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public Relay_SmartHost(string host, int port, SslMode sslMode, string userName, string password)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
if (host == "")
{
throw new ArgumentException("Argument 'host' value must be specified.");
}
if (port < 1)
{
throw new ArgumentException("Argument 'port' value is invalid.");
}
m_Host = host;
m_Port = port;
m_SslMode = sslMode;
m_UserName = userName;
m_Password = password;
}
/// <summary>
/// Construct an emailer object to send mime mail
/// </summary>
/// <param name="host">Host address of server</param>
/// <param name="port">Port number of server</param>
/// <param name="userName">User name</param>
/// <param name="passWord">Password</param>
/// <param name="sslType">Defines the type of encryption that your mail server uses</param>
/// <param name="implictSsl">Indicate if the ssl is an implict ssl</param>
/// <param name="authenticationType">Defines type of authentication that your smtp server uses</param>
public MimeMailer(string host, int port = 465, string userName = null, string passWord = "", SslMode sslType = SslMode.None, AuthenticationType authenticationType = AuthenticationType.PlainText) : base(host, port)
{
Host = host;
Port = port;
User = userName;
Password = passWord;
base.SslType = sslType;
if (sslType == SslMode.Auto)
{
SslType = DetectSslMode();
}
AuthenticationMode = authenticationType;
}
/// <summary>
/// The function will modify private member only, not base[key].
/// </summary>
/// <param name="keyword"></param>
/// <param name="value"></param>
/// <returns>value, coerced as needed to the stored type.</returns>
private object SetValue(Keywords keyword, object value)
{
try
{
switch (keyword)
{
case Keywords.Host:
return(this._host = Convert.ToString(value));
case Keywords.Port:
return(this._port = Convert.ToInt32(value));
case Keywords.Database:
return(this._database = Convert.ToString(value));
case Keywords.UserName:
return(this._username = Convert.ToString(value));
case Keywords.Password:
return(this._password = value as string);
case Keywords.SSL:
return(this._ssl = ToBoolean(value));
case Keywords.SslMode:
return(this._sslmode = ToSslMode(value));
case Keywords.Timeout:
return(this._timeout = ToInt32(value, 0, TIMEOUT_LIMIT, keyword));
case Keywords.SearchPath:
return(this._searchpath = Convert.ToString(value));
case Keywords.BufferSize:
return(this._bufferSize = Convert.ToInt32(value));
case Keywords.Pooling:
return(this._pooling = ToBoolean(value));
case Keywords.ConnectionLifeTime:
return(this._connection_life_time = Convert.ToInt32(value));
case Keywords.MinPoolSize:
return(this._min_pool_size = ToInt32(value, 0, POOL_SIZE_LIMIT, keyword));
case Keywords.MaxPoolSize:
return(this._max_pool_size = ToInt32(value, 0, POOL_SIZE_LIMIT, keyword));
case Keywords.SyncNotification:
return(this._sync_notification = ToBoolean(value));
case Keywords.CommandTimeout:
return(this._command_timeout = Convert.ToInt32(value));
case Keywords.Enlist:
return(this._enlist = ToBoolean(value));
case Keywords.PreloadReader:
if (ToBoolean(value))
{
throw new NotSupportedException("The PreloadReader parameter is no longer supported. Please see https://github.com/npgsql/Npgsql/wiki/PreloadReader-Removal");
}
return(false);
case Keywords.UseExtendedTypes:
if (ToBoolean(value))
{
throw new NotSupportedException("The UseExtendedTypes parameter is no longer supported. Please see https://github.com/npgsql/Npgsql/wiki/UseExtendedTypes-Removal");
}
return(false);
case Keywords.IntegratedSecurity:
bool iS = ToIntegratedSecurity(value);
if (iS == true)
{
CheckIntegratedSecuritySupport();
}
return(this._integrated_security = ToIntegratedSecurity(iS));
case Keywords.IncludeRealm:
return(this._includeRealm = ToBoolean(value));
case Keywords.Compatible:
Version ver = new Version(value.ToString());
if (ver > THIS_VERSION)
{
throw new ArgumentException("Attempt to set compatibility with version " + value +
" when using version " + THIS_VERSION);
}
return(_compatible = ver);
case Keywords.ApplicationName:
return(this._application_name = Convert.ToString(value));
}
}
catch (InvalidCastException exception)
{
string exception_template = string.Empty;
switch (keyword)
{
case Keywords.Port:
case Keywords.Timeout:
case Keywords.ConnectionLifeTime:
case Keywords.MinPoolSize:
case Keywords.MaxPoolSize:
case Keywords.CommandTimeout:
exception_template = "expecting {0}=[Numeric] value in ConnectionString";
break;
case Keywords.SSL:
case Keywords.Pooling:
case Keywords.SyncNotification:
exception_template = "expecting {0}=[True/False] value in ConnectionString";
break;
}
if (!string.IsNullOrEmpty(exception_template))
{
string key_name = GetKeyName(keyword);
throw new ArgumentException(string.Format(exception_template, key_name), key_name, exception);
}
throw;
}
return(null);
}
private void Initialize(string dbServer, string dbName, string dbUser, string dbPassword, SslMode sslMode, string id)
{
if (this.db == null)
{
this.db = new MySqlDb(dbServer, dbName, dbUser, dbPassword, sslMode);
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="hostName">Host name.</param>
/// <param name="protocol">Bind protocol.</param>
/// <param name="ip">IP address to listen.</param>
/// <param name="port">Port to listen.</param>
/// <param name="sslMode">Specifies SSL mode.</param>
/// <param name="certificate">Certificate to use for SSL connections.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>ip</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public IPBindInfo(string hostName, BindProtocol protocol, IPAddress ip, int port, SslMode sslMode, X509Certificate2 certificate)
{
AssertUtil.ArgumentNotNull(ip, nameof(ip));
AssertUtil.AssertNetworkPort(port, nameof(port));
this.HostName = hostName;
this.Protocol = protocol;
this.EndPoint = new IPEndPoint(ip, port);
this.SslMode = sslMode;
this.Certificate = certificate;
if ((sslMode == SslMode.SSL || sslMode == SslMode.TLS) && certificate == null)
{
throw new ArgumentException($"SSL requested, but argument '{nameof(certificate)}' is not provided.");
}
}
/// <summary>
/// The function will modify private member only, not base[key].
/// </summary>
/// <param name="keyword"></param>
/// <param name="value"></param>
/// <returns>value, coerced as needed to the stored type.</returns>
private object SetValue(Keywords keyword, object value)
{
try
{
switch (keyword)
{
case Keywords.Host:
return this._host = Convert.ToString(value);
case Keywords.Port:
return this._port = Convert.ToInt32(value);
case Keywords.Protocol:
return this._protocol = ToProtocolVersion(value);
case Keywords.Database:
return this._database = Convert.ToString(value);
case Keywords.UserName:
return this._username = Convert.ToString(value);
case Keywords.Password:
this._password.Password = value as string;
return value as string;
case Keywords.SSL:
return this._ssl = ToBoolean(value);
case Keywords.SslMode:
return this._sslmode = ToSslMode(value);
#pragma warning disable 618
case Keywords.Encoding:
return Encoding;
#pragma warning restore 618
case Keywords.Timeout:
return this._timeout = ToInt32(value, 0, TIMEOUT_LIMIT, keyword);
case Keywords.SearchPath:
return this._searchpath = Convert.ToString(value);
case Keywords.Pooling:
return this._pooling = ToBoolean(value);
case Keywords.ConnectionLifeTime:
return this._connection_life_time = Convert.ToInt32(value);
case Keywords.MinPoolSize:
return this._min_pool_size = ToInt32(value, 0, POOL_SIZE_LIMIT, keyword);
case Keywords.MaxPoolSize:
return this._max_pool_size = ToInt32(value, 0, POOL_SIZE_LIMIT, keyword);
case Keywords.SyncNotification:
return this._sync_notification = ToBoolean(value);
case Keywords.CommandTimeout:
return this._command_timeout = Convert.ToInt32(value);
case Keywords.Enlist:
return this._enlist = ToBoolean(value);
case Keywords.PreloadReader:
return this._preloadReader = ToBoolean(value);
case Keywords.UseExtendedTypes:
return this._useExtendedTypes = ToBoolean(value);
case Keywords.IntegratedSecurity:
return this._integrated_security = ToIntegratedSecurity(value);
case Keywords.Compatible:
Version ver = new Version(value.ToString());
if (ver > THIS_VERSION)
throw new ArgumentException("Attempt to set compatibility with version " + value +
" when using version " + THIS_VERSION);
return _compatible = ver;
case Keywords.ApplicationName:
return this._application_name = Convert.ToString(value);
case Keywords.AlwaysPrepare:
return this._always_prepare = Convert.ToBoolean(value);
}
}
catch (InvalidCastException exception)
{
string exception_template = string.Empty;
switch (keyword)
{
case Keywords.Port:
case Keywords.Timeout:
case Keywords.ConnectionLifeTime:
case Keywords.MinPoolSize:
case Keywords.MaxPoolSize:
case Keywords.CommandTimeout:
exception_template = resman.GetString("Exception_InvalidIntegerKeyVal");
break;
case Keywords.SSL:
case Keywords.Pooling:
case Keywords.SyncNotification:
exception_template = resman.GetString("Exception_InvalidBooleanKeyVal");
break;
case Keywords.Protocol:
exception_template = resman.GetString("Exception_InvalidProtocolVersionKeyVal");
break;
}
if (!string.IsNullOrEmpty(exception_template))
{
string key_name = GetKeyName(keyword);
throw new ArgumentException(string.Format(exception_template, key_name), key_name, exception);
}
throw;
}
return null;
}
public ImapServer(int port, SslMode mode, X509Certificate certificate)
: this(port)
{
SslMode = mode;
Certificate = certificate;
}
/// <summary>
/// The function will modify private member only, not base[key].
/// </summary>
/// <param name="keyword"></param>
/// <param name="value"></param>
private void SetValue(Keywords keyword, object value)
{
string key_name = GetKeyName(keyword);
try
{
switch (keyword)
{
case Keywords.Host:
this._host = Convert.ToString(value);
break;
case Keywords.Port:
this._port = Convert.ToInt32(value);
break;
case Keywords.Protocol:
this._protocol = ToProtocolVersion(value);
break;
case Keywords.Database:
this._database = Convert.ToString(value);
break;
case Keywords.UserName:
this._username = Convert.ToString(value);
break;
case Keywords.Password:
this._password = Convert.ToString(value);
break;
case Keywords.SSL:
this._ssl = ToBoolean(value);
break;
case Keywords.SslMode:
this._sslmode = ToSslMode(value);
break;
#pragma warning disable 618
case Keywords.Encoding:
break;
#pragma warning restore 618
case Keywords.Timeout:
this._timeout = ToInt32(value, 0, TIMEOUT_LIMIT, key_name);
break;
case Keywords.SearchPath:
this._searchpath = Convert.ToString(value);
break;
case Keywords.Pooling:
this._pooling = ToBoolean(value);
break;
case Keywords.ConnectionLifeTime:
this._connection_life_time = Convert.ToInt32(value);
break;
case Keywords.MinPoolSize:
this._min_pool_size = (MaxPoolSize > 0) ? ToInt32(value, 0, MaxPoolSize, key_name) : Convert.ToInt32(value);
break;
case Keywords.MaxPoolSize:
this._max_pool_size = ToInt32(value, 0, POOL_SIZE_LIMIT, key_name);
break;
case Keywords.SyncNotification:
this._sync_notification = ToBoolean(value);
break;
case Keywords.CommandTimeout:
this._command_timeout = Convert.ToInt32(value);
break;
case Keywords.Enlist:
this._enlist = ToBoolean(value);
break;
case Keywords.PreloadReader:
this._preloadReader = ToBoolean(value);
break;
case Keywords.UseExtendedTypes:
this._useExtendedTypes = ToBoolean(value);
break;
case Keywords.IntegratedSecurity:
this._integrated_security = ToIntegratedSecurity(value);
break;
case Keywords.Compatible:
Version ver = new Version(value.ToString());
if (ver > THIS_VERSION)
{
throw new ArgumentException("Attempt to set compatibility with version " + value + " when using version " + THIS_VERSION);
}
_compatible = ver;
break;
}
}
catch (InvalidCastException exception)
{
string exception_template = string.Empty;
switch (keyword)
{
case Keywords.Port:
case Keywords.Timeout:
case Keywords.ConnectionLifeTime:
case Keywords.MinPoolSize:
case Keywords.MaxPoolSize:
case Keywords.CommandTimeout:
exception_template = resman.GetString("Exception_InvalidIntegerKeyVal");
break;
case Keywords.SSL:
case Keywords.Pooling:
case Keywords.SyncNotification:
exception_template = resman.GetString("Exception_InvalidBooleanKeyVal");
break;
case Keywords.Protocol:
exception_template = resman.GetString("Exception_InvalidProtocolVersionKeyVal");
break;
}
if (!string.IsNullOrEmpty(exception_template))
{
throw new ArgumentException(string.Format(exception_template, key_name), key_name, exception);
}
throw;
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="hostName">Host name.</param>
/// <param name="ip">IP address to listen.</param>
/// <param name="port">Port to listen.</param>
/// <param name="sslMode">Specifies SSL mode.</param>
/// <param name="sslCertificate">Certificate to use for SSL connections.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>ip</b> is null.</exception>
public IPBindInfo(string hostName,IPAddress ip,int port,SslMode sslMode,X509Certificate2 sslCertificate)
: this(hostName,BindInfoProtocol.TCP,ip,port,sslMode,sslCertificate)
{
}
///<summary>
///</summary>
public SslMode ToSslMode(String Key, SslMode Default)
{
if (! connection_string_values.Contains(Key))
{
return Default;
}
return (SslMode)Enum.Parse(typeof(SslMode), ToString(Key), true);
}
/// <summary>
/// The function will modify private member only, not base[key].
/// </summary>
/// <param name="keyword"></param>
/// <param name="value"></param>
private void SetValue(Keywords keyword, object value)
{
string key_name = GetKeyName(keyword);
try
{
switch (keyword)
{
case Keywords.Host:
this._host = Convert.ToString(value);
break;
case Keywords.Port:
this._port = Convert.ToInt32(value);
break;
case Keywords.Protocol:
this._protocol = ToProtocolVersion(value);
break;
case Keywords.Database:
this._database = Convert.ToString(value);
break;
case Keywords.UserName:
this._username = Convert.ToString(value);
break;
case Keywords.Password:
this._password = Convert.ToString(value);
break;
case Keywords.SSL:
this._ssl = ToBoolean(value);
break;
case Keywords.SslMode:
this._sslmode = ToSslMode(value);
break;
#pragma warning disable 618
case Keywords.Encoding:
break;
#pragma warning restore 618
case Keywords.Timeout:
this._timeout = ToInt32(value, 0, TIMEOUT_LIMIT, key_name);
break;
case Keywords.SearchPath:
this._searchpath = Convert.ToString(value);
break;
case Keywords.Pooling:
this._pooling = ToBoolean(value);
break;
case Keywords.ConnectionLifeTime:
this._connection_life_time = Convert.ToInt32(value);
break;
case Keywords.MinPoolSize:
this._min_pool_size = (MaxPoolSize > 0) ? ToInt32(value, 0, MaxPoolSize, key_name) : Convert.ToInt32(value);
break;
case Keywords.MaxPoolSize:
this._max_pool_size = ToInt32(value, 0, POOL_SIZE_LIMIT, key_name);
break;
case Keywords.SyncNotification:
this._sync_notification = ToBoolean(value);
break;
case Keywords.CommandTimeout:
this._command_timeout = Convert.ToInt32(value);
break;
case Keywords.Enlist:
this._enlist = ToBoolean(value);
break;
case Keywords.PreloadReader:
this._preloadReader = ToBoolean(value);
break;
case Keywords.UseExtendedTypes:
this._useExtendedTypes = ToBoolean(value);
break;
case Keywords.IntegratedSecurity:
this._integrated_security = ToIntegratedSecurity(value);
break;
}
}
catch (InvalidCastException exception)
{
string exception_template = string.Empty;
switch (keyword)
{
case Keywords.Port:
case Keywords.Timeout:
case Keywords.ConnectionLifeTime:
case Keywords.MinPoolSize:
case Keywords.MaxPoolSize:
case Keywords.CommandTimeout:
exception_template = resman.GetString("Exception_InvalidIntegerKeyVal");
break;
case Keywords.SSL:
case Keywords.Pooling:
case Keywords.SyncNotification:
exception_template = resman.GetString("Exception_InvalidBooleanKeyVal");
break;
case Keywords.Protocol:
exception_template = resman.GetString("Exception_InvalidProtocolVersionKeyVal");
break;
}
if (!string.IsNullOrEmpty(exception_template))
{
throw new ArgumentException(string.Format(exception_template, key_name), key_name, exception);
}
throw;
}
}
