internal System.Data.SqlClient.ApplicationIntent ConvertValueToApplicationIntent()
{
object value = base.Parsetable[KEY.ApplicationIntent];
if (value == null)
{
return(DEFAULT.ApplicationIntent);
}
// when wrong value is used in the connection string provided to SqlConnection.ConnectionString or c-tor,
// wrap Format and Overflow exceptions with Argument one, to be consistent with rest of the keyword types (like int and bool)
try
{
return(DbConnectionStringBuilderUtil.ConvertToApplicationIntent(KEY.ApplicationIntent, value));
}
catch (FormatException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.ApplicationIntent, e);
}
catch (OverflowException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.ApplicationIntent, e);
}
// ArgumentException and other types are raised as is (no wrapping)
}
internal PoolBlockingPeriod ConvertValueToPoolBlockingPeriod()
{
string value;
if (!TryGetParsetableValue(KEY.PoolBlockingPeriod, out value))
{
return(DEFAULT.PoolBlockingPeriod);
}
try
{
return(DbConnectionStringBuilderUtil.ConvertToPoolBlockingPeriod(KEY.PoolBlockingPeriod, value));
}
catch (Exception e) when(e is FormatException || e is OverflowException)
{
throw ADP.InvalidConnectionOptionValue(KEY.PoolBlockingPeriod, e);
}
}
/// <summary>
/// Convert the value to SqlConnectionIPAddressPreference
/// </summary>
/// <returns></returns>
internal SqlConnectionIPAddressPreference ConvertValueToIPAddressPreference()
{
if (!TryGetParsetableValue(KEY.IPAddressPreference, out string value))
{
return(DEFAULT.s_IPAddressPreference);
}
try
{
return(DbConnectionStringBuilderUtil.ConvertToIPAddressPreference(KEY.IPAddressPreference, value));
}
catch (FormatException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.IPAddressPreference, e);
}
catch (OverflowException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.IPAddressPreference, e);
}
}
/// <summary>
/// Convert the value to SqlConnectionAttestationProtocol
/// </summary>
/// <returns></returns>
internal SqlConnectionAttestationProtocol ConvertValueToAttestationProtocol()
{
if (!TryGetParsetableValue(KEY.AttestationProtocol, out string value))
{
return(DEFAULT.AttestationProtocol);
}
try
{
return(DbConnectionStringBuilderUtil.ConvertToAttestationProtocol(KEY.AttestationProtocol, value));
}
catch (FormatException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.AttestationProtocol, e);
}
catch (OverflowException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.AttestationProtocol, e);
}
}
/// <summary>
/// Convert the value to SqlConnectionColumnEncryptionSetting.
/// </summary>
/// <returns></returns>
internal SqlConnectionColumnEncryptionSetting ConvertValueToColumnEncryptionSetting()
{
if (!TryGetParsetableValue(KEY.ColumnEncryptionSetting, out string value))
{
return(DEFAULT.ColumnEncryptionSetting);
}
try
{
return(DbConnectionStringBuilderUtil.ConvertToColumnEncryptionSetting(KEY.ColumnEncryptionSetting, value));
}
catch (FormatException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.ColumnEncryptionSetting, e);
}
catch (OverflowException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.ColumnEncryptionSetting, e);
}
}
internal SqlAuthenticationMethod ConvertValueToAuthenticationType()
{
if (!TryGetParsetableValue(KEY.Authentication, out string value))
{
return(DEFAULT.Authentication);
}
try
{
return(DbConnectionStringBuilderUtil.ConvertToAuthenticationType(KEY.Authentication, value));
}
catch (FormatException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.Authentication, e);
}
catch (OverflowException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.Authentication, e);
}
}
/// <summary>
/// Convert the value to SqlConnectionColumnEncryptionSetting.
/// </summary>
/// <returns></returns>
internal SqlConnectionColumnEncryptionSetting ConvertValueToColumnEncryptionSetting()
{
object value = base.Parsetable[KEY.ColumnEncryptionSetting];
string valStr = value as string;
if (valStr == null)
{
return(DEFAULT.ColumnEncryptionSetting);
}
try {
return(DbConnectionStringBuilderUtil.ConvertToColumnEncryptionSetting(KEY.ColumnEncryptionSetting, valStr));
}
catch (FormatException e) {
throw ADP.InvalidConnectionOptionValue(KEY.ColumnEncryptionSetting, e);
}
catch (OverflowException e) {
throw ADP.InvalidConnectionOptionValue(KEY.ColumnEncryptionSetting, e);
}
}
internal SqlAuthenticationMethod ConvertValueToAuthenticationType()
{
object value = base.Parsetable[KEY.Authentication];
string valStr = value as string;
if (valStr == null)
{
return(DEFAULT.Authentication);
}
try {
return(DbConnectionStringBuilderUtil.ConvertToAuthenticationType(KEY.Authentication, valStr));
}
catch (FormatException e) {
throw ADP.InvalidConnectionOptionValue(KEY.Authentication, e);
}
catch (OverflowException e) {
throw ADP.InvalidConnectionOptionValue(KEY.Authentication, e);
}
}
internal Microsoft.Data.SqlClient.PoolBlockingPeriod ConvertValueToPoolBlockingPeriod()
{
object value = base.Parsetable[KEY.PoolBlockingPeriod];
if (value == null)
{
return(DEFAULT.PoolBlockingPeriod);
}
try
{
return(DbConnectionStringBuilderUtil.ConvertToPoolBlockingPeriod(KEY.PoolBlockingPeriod, value));
}
catch (FormatException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.PoolBlockingPeriod, e);
}
catch (OverflowException e)
{
throw ADP.InvalidConnectionOptionValue(KEY.PoolBlockingPeriod, e);
}
}
internal System.Data.SqlClient.ApplicationIntent ConvertValueToApplicationIntent()
{
System.Data.SqlClient.ApplicationIntent intent;
object obj2 = base.Parsetable["applicationintent"];
if (obj2 == null)
{
return(System.Data.SqlClient.ApplicationIntent.ReadWrite);
}
try
{
intent = DbConnectionStringBuilderUtil.ConvertToApplicationIntent("applicationintent", obj2);
}
catch (FormatException exception2)
{
throw ADP.InvalidConnectionOptionValue("applicationintent", exception2);
}
catch (OverflowException exception)
{
throw ADP.InvalidConnectionOptionValue("applicationintent", exception);
}
return(intent);
}
private static string ConvertToString(object value)
{
return(DbConnectionStringBuilderUtil.ConvertToString(value));
}
private static SqlAuthenticationMethod ConvertToAuthenticationType(string keyword, object value)
{
return(DbConnectionStringBuilderUtil.ConvertToAuthenticationType(keyword, value));
}
private static bool ConvertToBoolean(object value)
{
return(DbConnectionStringBuilderUtil.ConvertToBoolean(value));
}
private static int ConvertToInt32(object value)
{
return(DbConnectionStringBuilderUtil.ConvertToInt32(value));
}
private static ApplicationIntent ConvertToApplicationIntent(string keyword, object value)
{
return(DbConnectionStringBuilderUtil.ConvertToApplicationIntent(keyword, value));
}
private void SetApplicationIntentValue(ApplicationIntent value)
{
Debug.Assert(DbConnectionStringBuilderUtil.IsValidApplicationIntentValue(value), "invalid value");
base[DbConnectionStringKeywords.ApplicationIntent] = DbConnectionStringBuilderUtil.ApplicationIntentToString(value);
}
internal SqlConnectionString(string connectionString) : base(connectionString, GetParseSynonyms(), false)
{
bool runningInProc = InOutOfProcHelper.InProc;
_integratedSecurity = ConvertValueToIntegratedSecurity();
ConvertValueToBoolean(KEY.AsynchronousProcessing, DEFAULT.Asynchronous); // while we don't use it anymore, we still need to verify it is true/false
// SQLPT 41700: Ignore ResetConnection=False (still validate the keyword/value)
_poolBlockingPeriod = ConvertValueToPoolBlockingPeriod();
_connectionReset = ConvertValueToBoolean(KEY.Connection_Reset, DEFAULT.Connection_Reset);
_contextConnection = ConvertValueToBoolean(KEY.Context_Connection, DEFAULT.Context_Connection);
_encrypt = ConvertValueToEncrypt();
_enlist = ConvertValueToBoolean(KEY.Enlist, ADP.IsWindowsNT);
_mars = ConvertValueToBoolean(KEY.MARS, DEFAULT.MARS);
_persistSecurityInfo = ConvertValueToBoolean(KEY.Persist_Security_Info, DEFAULT.Persist_Security_Info);
_pooling = ConvertValueToBoolean(KEY.Pooling, DEFAULT.Pooling);
_replication = ConvertValueToBoolean(KEY.Replication, DEFAULT.Replication);
_userInstance = ConvertValueToBoolean(KEY.User_Instance, DEFAULT.User_Instance);
_multiSubnetFailover = ConvertValueToBoolean(KEY.MultiSubnetFailover, DEFAULT.MultiSubnetFailover);
_transparentNetworkIPResolution = ConvertValueToBoolean(KEY.TransparentNetworkIPResolution, DEFAULT.TransparentNetworkIPResolution);
_connectTimeout = ConvertValueToInt32(KEY.Connect_Timeout, DEFAULT.Connect_Timeout);
_loadBalanceTimeout = ConvertValueToInt32(KEY.Load_Balance_Timeout, DEFAULT.Load_Balance_Timeout);
_maxPoolSize = ConvertValueToInt32(KEY.Max_Pool_Size, DEFAULT.Max_Pool_Size);
_minPoolSize = ConvertValueToInt32(KEY.Min_Pool_Size, DEFAULT.Min_Pool_Size);
_packetSize = ConvertValueToInt32(KEY.Packet_Size, DEFAULT.Packet_Size);
_connectRetryCount = ConvertValueToInt32(KEY.Connect_Retry_Count, DEFAULT.Connect_Retry_Count);
_connectRetryInterval = ConvertValueToInt32(KEY.Connect_Retry_Interval, DEFAULT.Connect_Retry_Interval);
_applicationIntent = ConvertValueToApplicationIntent();
_applicationName = ConvertValueToString(KEY.Application_Name, DEFAULT.Application_Name);
_attachDBFileName = ConvertValueToString(KEY.AttachDBFilename, DEFAULT.AttachDBFilename);
_currentLanguage = ConvertValueToString(KEY.Current_Language, DEFAULT.Current_Language);
_dataSource = ConvertValueToString(KEY.Data_Source, DEFAULT.Data_Source);
_localDBInstance = LocalDBAPI.GetLocalDbInstanceNameFromServerName(_dataSource);
_failoverPartner = ConvertValueToString(KEY.FailoverPartner, DEFAULT.FailoverPartner);
_initialCatalog = ConvertValueToString(KEY.Initial_Catalog, DEFAULT.Initial_Catalog);
_networkLibrary = ConvertValueToString(KEY.Network_Library, null);
_password = ConvertValueToString(KEY.Password, DEFAULT.Password);
_trustServerCertificate = ConvertValueToBoolean(KEY.TrustServerCertificate, DEFAULT.TrustServerCertificate);
_authType = ConvertValueToAuthenticationType();
_columnEncryptionSetting = ConvertValueToColumnEncryptionSetting();
_enclaveAttestationUrl = ConvertValueToString(KEY.EnclaveAttestationUrl, DEFAULT.EnclaveAttestationUrl);
#if ADONET_CERT_AUTH
_certificate = ConvertValueToString(KEY.Certificate, DEFAULT.Certificate);
#endif
// Temporary string - this value is stored internally as an enum.
string typeSystemVersionString = ConvertValueToString(KEY.Type_System_Version, null);
string transactionBindingString = ConvertValueToString(KEY.TransactionBinding, null);
_userID = ConvertValueToString(KEY.User_ID, DEFAULT.User_ID);
_workstationId = ConvertValueToString(KEY.Workstation_Id, null);
if (_contextConnection)
{
// We have to be running in the engine for you to request a
// context connection.
if (!runningInProc)
{
throw SQL.ContextUnavailableOutOfProc();
}
// When using a context connection, we need to ensure that no
// other connection string keywords are specified.
foreach (DictionaryEntry entry in Parsetable)
{
if ((string)entry.Key != KEY.Context_Connection &&
(string)entry.Key != KEY.Type_System_Version)
{
throw SQL.ContextAllowsLimitedKeywords();
}
}
}
if (!_encrypt)
{ // Support legacy registry encryption settings
const string folder = "Software\\Microsoft\\MSSQLServer\\Client\\SuperSocketNetLib";
const string value = "Encrypt";
Object obj = ADP.LocalMachineRegistryValue(folder, value);
if ((obj is Int32) && (1 == (int)obj))
{ // If the registry key exists
_encrypt = true;
}
}
if (_loadBalanceTimeout < 0)
{
throw ADP.InvalidConnectionOptionValue(KEY.Load_Balance_Timeout);
}
if (_connectTimeout < 0)
{
throw ADP.InvalidConnectionOptionValue(KEY.Connect_Timeout);
}
if (_maxPoolSize < 1)
{
throw ADP.InvalidConnectionOptionValue(KEY.Max_Pool_Size);
}
if (_minPoolSize < 0)
{
throw ADP.InvalidConnectionOptionValue(KEY.Min_Pool_Size);
}
if (_maxPoolSize < _minPoolSize)
{
throw ADP.InvalidMinMaxPoolSizeValues();
}
if ((_packetSize < TdsEnums.MIN_PACKET_SIZE) || (TdsEnums.MAX_PACKET_SIZE < _packetSize))
{
throw SQL.InvalidPacketSizeValue();
}
if (null != _networkLibrary)
{ // MDAC 83525
string networkLibrary = _networkLibrary.Trim().ToLower(CultureInfo.InvariantCulture);
Hashtable netlib = NetlibMapping();
if (!netlib.ContainsKey(networkLibrary))
{
throw ADP.InvalidConnectionOptionValue(KEY.Network_Library);
}
_networkLibrary = (string)netlib[networkLibrary];
}
else
{
_networkLibrary = DEFAULT.Network_Library;
}
ValidateValueLength(_applicationName, TdsEnums.MAXLEN_APPNAME, KEY.Application_Name);
ValidateValueLength(_currentLanguage, TdsEnums.MAXLEN_LANGUAGE, KEY.Current_Language);
ValidateValueLength(_dataSource, TdsEnums.MAXLEN_SERVERNAME, KEY.Data_Source);
ValidateValueLength(_failoverPartner, TdsEnums.MAXLEN_SERVERNAME, KEY.FailoverPartner);
ValidateValueLength(_initialCatalog, TdsEnums.MAXLEN_DATABASE, KEY.Initial_Catalog);
ValidateValueLength(_password, TdsEnums.MAXLEN_PASSWORD, KEY.Password);
ValidateValueLength(_userID, TdsEnums.MAXLEN_USERNAME, KEY.User_ID);
if (null != _workstationId)
{
ValidateValueLength(_workstationId, TdsEnums.MAXLEN_HOSTNAME, KEY.Workstation_Id);
}
if (!String.Equals(DEFAULT.FailoverPartner, _failoverPartner, StringComparison.OrdinalIgnoreCase))
{
// fail-over partner is set
if (_multiSubnetFailover)
{
throw SQL.MultiSubnetFailoverWithFailoverPartner(serverProvidedFailoverPartner: false, internalConnection: null);
}
if (String.Equals(DEFAULT.Initial_Catalog, _initialCatalog, StringComparison.OrdinalIgnoreCase))
{
throw ADP.MissingConnectionOptionValue(KEY.FailoverPartner, KEY.Initial_Catalog);
}
}
// expand during construction so that CreatePermissionSet and Expand are consistent
string datadir = null;
_expandedAttachDBFilename = ExpandDataDirectory(KEY.AttachDBFilename, _attachDBFileName, ref datadir);
if (null != _expandedAttachDBFilename)
{
if (0 <= _expandedAttachDBFilename.IndexOf('|'))
{
throw ADP.InvalidConnectionOptionValue(KEY.AttachDBFilename);
}
ValidateValueLength(_expandedAttachDBFilename, TdsEnums.MAXLEN_ATTACHDBFILE, KEY.AttachDBFilename);
if (_localDBInstance == null)
{
// fail fast to verify LocalHost when using |DataDirectory|
// still must check again at connect time
string host = _dataSource;
string protocol = _networkLibrary;
TdsParserStaticMethods.AliasRegistryLookup(ref host, ref protocol);
VerifyLocalHostAndFixup(ref host, true, false /*don't fix-up*/);
}
}
else if (0 <= _attachDBFileName.IndexOf('|'))
{
throw ADP.InvalidConnectionOptionValue(KEY.AttachDBFilename);
}
else
{
ValidateValueLength(_attachDBFileName, TdsEnums.MAXLEN_ATTACHDBFILE, KEY.AttachDBFilename);
}
_typeSystemAssemblyVersion = constTypeSystemAsmVersion10;
if (true == _userInstance && !ADP.IsEmpty(_failoverPartner))
{
throw SQL.UserInstanceFailoverNotCompatible();
}
if (ADP.IsEmpty(typeSystemVersionString))
{
typeSystemVersionString = DbConnectionStringDefaults.TypeSystemVersion;
}
if (typeSystemVersionString.Equals(TYPESYSTEMVERSION.Latest, StringComparison.OrdinalIgnoreCase))
{
_typeSystemVersion = TypeSystem.Latest;
}
else if (typeSystemVersionString.Equals(TYPESYSTEMVERSION.SQL_Server_2000, StringComparison.OrdinalIgnoreCase))
{
if (_contextConnection)
{
throw SQL.ContextAllowsOnlyTypeSystem2005();
}
_typeSystemVersion = TypeSystem.SQLServer2000;
}
else if (typeSystemVersionString.Equals(TYPESYSTEMVERSION.SQL_Server_2005, StringComparison.OrdinalIgnoreCase))
{
_typeSystemVersion = TypeSystem.SQLServer2005;
}
else if (typeSystemVersionString.Equals(TYPESYSTEMVERSION.SQL_Server_2008, StringComparison.OrdinalIgnoreCase))
{
_typeSystemVersion = TypeSystem.SQLServer2008;
}
else if (typeSystemVersionString.Equals(TYPESYSTEMVERSION.SQL_Server_2012, StringComparison.OrdinalIgnoreCase))
{
_typeSystemVersion = TypeSystem.SQLServer2012;
_typeSystemAssemblyVersion = constTypeSystemAsmVersion11;
}
else
{
throw ADP.InvalidConnectionOptionValue(KEY.Type_System_Version);
}
if (ADP.IsEmpty(transactionBindingString))
{
transactionBindingString = DbConnectionStringDefaults.TransactionBinding;
}
if (transactionBindingString.Equals(TRANSACIONBINDING.ImplicitUnbind, StringComparison.OrdinalIgnoreCase))
{
_transactionBinding = TransactionBindingEnum.ImplicitUnbind;
}
else if (transactionBindingString.Equals(TRANSACIONBINDING.ExplicitUnbind, StringComparison.OrdinalIgnoreCase))
{
_transactionBinding = TransactionBindingEnum.ExplicitUnbind;
}
else
{
throw ADP.InvalidConnectionOptionValue(KEY.TransactionBinding);
}
if ((_connectRetryCount < 0) || (_connectRetryCount > 255))
{
throw ADP.InvalidConnectRetryCountValue();
}
if ((_connectRetryInterval < 1) || (_connectRetryInterval > 60))
{
throw ADP.InvalidConnectRetryIntervalValue();
}
if (Authentication != SqlAuthenticationMethod.NotSpecified && _integratedSecurity == true)
{
throw SQL.AuthenticationAndIntegratedSecurity();
}
if (Authentication == SqlAuthenticationMethod.ActiveDirectoryIntegrated && (HasUserIdKeyword || HasPasswordKeyword))
{
throw SQL.IntegratedWithUserIDAndPassword();
}
if (Authentication == SqlAuthenticationMethod.ActiveDirectoryInteractive && (HasUserIdKeyword || HasPasswordKeyword))
{
throw SQL.InteractiveWithUserIDAndPassword();
}
#if ADONET_CERT_AUTH
if (!DbConnectionStringBuilderUtil.IsValidCertificateValue(_certificate))
{
throw ADP.InvalidConnectionOptionValue(KEY.Certificate);
}
if (!string.IsNullOrEmpty(_certificate))
{
if (Authentication == SqlClient.SqlAuthenticationMethod.NotSpecified && !_integratedSecurity)
{
_authType = SqlClient.SqlAuthenticationMethod.SqlCertificate;
}
if (Authentication == SqlClient.SqlAuthenticationMethod.SqlCertificate && (HasUserIdKeyword || HasPasswordKeyword || _integratedSecurity))
{
throw SQL.InvalidCertAuth();
}
}
else if (Authentication == SqlClient.SqlAuthenticationMethod.SqlCertificate)
{
throw ADP.InvalidConnectionOptionValue(KEY.Authentication);
}
#endif
}
private static bool ConvertToIntegratedSecurity(object value)
{
return(DbConnectionStringBuilderUtil.ConvertToIntegratedSecurity(value));
}
private void SetPoolBlockingPeriodValue(PoolBlockingPeriod value)
{
Debug.Assert(DbConnectionStringBuilderUtil.IsValidPoolBlockingPeriodValue(value), "Invalid value for PoolBlockingPeriod");
base[DbConnectionStringKeywords.PoolBlockingPeriod] = DbConnectionStringBuilderUtil.PoolBlockingPeriodToString(value);
}
/// <summary>
/// Convert to SqlConnectionColumnEncryptionSetting.
/// </summary>
/// <param name="keyword"></param>
/// <param name="value"></param>
private static SqlConnectionColumnEncryptionSetting ConvertToColumnEncryptionSetting(string keyword, object value)
{
return(DbConnectionStringBuilderUtil.ConvertToColumnEncryptionSetting(keyword, value));
}
private void SetAuthenticationValue(SqlAuthenticationMethod value)
{
Debug.Assert(DbConnectionStringBuilderUtil.IsValidAuthenticationTypeValue(value), "Invalid value for AuthenticationType");
base[DbConnectionStringKeywords.Authentication] = DbConnectionStringBuilderUtil.AuthenticationTypeToString(value);
}
private void SetColumnEncryptionSettingValue(SqlConnectionColumnEncryptionSetting value)
{
Debug.Assert(DbConnectionStringBuilderUtil.IsValidColumnEncryptionSetting(value), "Invalid value for SqlConnectionColumnEncryptionSetting");
base[DbConnectionStringKeywords.ColumnEncryptionSetting] = DbConnectionStringBuilderUtil.ColumnEncryptionSettingToString(value);
}
private static PoolBlockingPeriod ConvertToPoolBlockingPeriod(string keyword, object value)
{
return(DbConnectionStringBuilderUtil.ConvertToPoolBlockingPeriod(keyword, value));
}
