Fix missing error messages in Managed SNI

cheenamalhotra · cheenamalhotra · commit 88dd85aa5991 · 2021-01-15T12:58:01.000-08:00
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/LocalDB.Windows.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/LocalDB.Windows.cs
@@ -88,6 +88,25 @@ internal static uint MapLocalDBErrorStateToCode(LocalDBErrorState errorState)
             }
         }
 
+        internal static string MapLocalDBErrorStateToErrorMessage(LocalDBErrorState errorState)
+        {
+            switch (errorState)
+            {
+                case LocalDBErrorState.NO_INSTALLATION:
+                    return Strings.SNI_ERROR_52;
+                case LocalDBErrorState.INVALID_CONFIG:
+                    return Strings.SNI_ERROR_53;
+                case LocalDBErrorState.NO_SQLUSERINSTANCEDLL_PATH:
+                    return Strings.SNI_ERROR_54;
+                case LocalDBErrorState.INVALID_SQLUSERINSTANCEDLL_PATH:
+                    return Strings.SNI_ERROR_55;
+                case LocalDBErrorState.NONE:
+                    return Strings.SNI_ERROR_50;
+                default:
+                    return Strings.SNI_ERROR_53;
+            }
+        }
+
         /// <summary>
         /// Loads the User Instance dll.
         /// </summary>
@@ -117,15 +136,15 @@ private bool LoadUserInstanceDll()
                     // If there was no DLL path found, then there is an error.
                     if (dllPath == null)
                     {
-                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, MapLocalDBErrorStateToCode(registryQueryErrorState), string.Empty);
+                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, MapLocalDBErrorStateToCode(registryQueryErrorState), MapLocalDBErrorStateToErrorMessage(registryQueryErrorState));
                         SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.LocalDB.Windows.LoadUserInstanceDll |SNI|ERR >User instance DLL path is null.");
                         return false;
                     }
 
                     // In case the registry had an empty path for dll
                     if (string.IsNullOrWhiteSpace(dllPath))
                     {
-                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBInvalidSqlUserInstanceDllPath, string.Empty);
+                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBInvalidSqlUserInstanceDllPath, Strings.SNI_ERROR_55);
                         SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.LocalDB.Windows.LoadUserInstanceDll |SNI|ERR > User instance DLL path is invalid. DLL path ={0}", dllPath);
                         return false;
                     }
@@ -135,7 +154,7 @@ private bool LoadUserInstanceDll()
 
                     if (libraryHandle.IsInvalid)
                     {
-                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBFailedToLoadDll, string.Empty);
+                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBFailedToLoadDll, Strings.SNI_ERROR_56);
                         SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.LocalDB.Windows.LoadUserInstanceDll |SNI|ERR > Library Handle is invalid. Could not load the dll.");
                         libraryHandle.Dispose();
                         return false;
@@ -146,7 +165,7 @@ private bool LoadUserInstanceDll()
 
                     if (_startInstanceHandle == IntPtr.Zero)
                     {
-                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBBadRuntime, string.Empty);
+                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBBadRuntime, Strings.SNI_ERROR_57);
                         SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.LocalDB.Windows.LoadUserInstanceDll |SNI|ERR > Was not able to load the PROC from DLL. Bad Runtime.");
                         libraryHandle.Dispose();
                         return false;
@@ -157,7 +176,7 @@ private bool LoadUserInstanceDll()
 
                     if (localDBStartInstanceFunc == null)
                     {
-                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBBadRuntime, string.Empty);
+                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBBadRuntime, Strings.SNI_ERROR_57);
                         libraryHandle.Dispose();
                         _startInstanceHandle = IntPtr.Zero;
                         return false;
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNIMarsConnection.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNIMarsConnection.cs
@@ -75,7 +75,7 @@ public uint StartReceive()
                     return TdsEnums.SNI_SUCCESS_IO_PENDING;
                 }
                 SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.SNIMarsConnection.StartReceive |SNI|ERR> Connection not useable.");
-                return SNICommon.ReportSNIError(SNIProviders.SMUX_PROV, 0, SNICommon.ConnNotUsableError, string.Empty);
+                return SNICommon.ReportSNIError(SNIProviders.SMUX_PROV, 0, SNICommon.ConnNotUsableError, Strings.SNI_ERROR_19);
             }
             finally
             {
@@ -293,7 +293,7 @@ public void HandleReceiveComplete(SNIPacket packet, uint sniErrorCode)
 
                         if (!_sessions.ContainsKey(_currentHeader.sessionId))
                         {
-                            SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.SMUX_PROV, 0, SNICommon.InvalidParameterError, string.Empty);
+                            SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.SMUX_PROV, 0, SNICommon.InvalidParameterError, Strings.SNI_ERROR_5);
                             HandleReceiveError(packet);
                             _lowerHandle.Dispose();
                             _lowerHandle = null;
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNIMarsHandle.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNIMarsHandle.cs
@@ -530,7 +530,7 @@ public override uint Receive(out SNIPacket packet, int timeoutInMilliseconds)
 
                     if (!_packetEvent.Wait(timeoutInMilliseconds))
                     {
-                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.SMUX_PROV, 0, SNICommon.ConnTimeoutError, string.Empty);
+                        SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.SMUX_PROV, 0, SNICommon.ConnTimeoutError, Strings.SNI_ERROR_11);
                         return TdsEnums.SNI_WAIT_TIMEOUT;
                     }
                 }
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNINpHandle.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNINpHandle.cs
@@ -22,7 +22,6 @@ internal sealed class SNINpHandle : SNIPhysicalHandle
         private const int MAX_PIPE_INSTANCES = 255;
 
         private readonly string _targetServer;
-        private readonly object _callbackObject;
         private readonly object _sendSync;
 
         private Stream _stream;
@@ -38,15 +37,14 @@ internal sealed class SNINpHandle : SNIPhysicalHandle
         private int _bufferSize = TdsEnums.DEFAULT_LOGIN_PACKET_SIZE;
         private readonly Guid _connectionId = Guid.NewGuid();
 
-        public SNINpHandle(string serverName, string pipeName, long timerExpire, object callbackObject)
+        public SNINpHandle(string serverName, string pipeName, long timerExpire)
         {
             long scopeID = SqlClientEventSource.Log.TrySNIScopeEnterEvent("<sc.SNI.SNINpHandle.SNINpHandle |SNI|INFO|SCOPE> Constructor");
             SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.SNINpHandle.SNINpHandle |SNI|INFO> Constructor. server name = {0}, pipe name = {1}", serverName, pipeName);
             try
             {
                 _sendSync = new object();
                 _targetServer = serverName;
-                _callbackObject = callbackObject;
 
                 try
                 {
@@ -86,7 +84,7 @@ public SNINpHandle(string serverName, string pipeName, long timerExpire, object
 
                 if (!_pipeStream.IsConnected || !_pipeStream.CanWrite || !_pipeStream.CanRead)
                 {
-                    SNICommon.ReportSNIError(SNIProviders.NP_PROV, 0, SNICommon.ConnOpenFailedError, string.Empty);
+                    SNICommon.ReportSNIError(SNIProviders.NP_PROV, 0, SNICommon.ConnOpenFailedError, Strings.SNI_ERROR_1);
                     _status = TdsEnums.SNI_ERROR;
                     SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.SNINpHandle.SNINpHandle |SNI|ERR> Pipe stream is not connected or cannot write or read to/from it.");
                     return;
@@ -126,7 +124,7 @@ public override int ProtocolVersion
             {
                 try
                 {
-                    return (int)_sslStream.SslProtocol;
+                    return (int)_sslStream?.SslProtocol;
                 }
                 catch
                 {
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNIPacket.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNIPacket.cs
@@ -278,7 +278,7 @@ private void ReadFromStreamAsyncContinuation(Task<int> t, object state)
 
                 if (_dataLength == 0)
                 {
-                    SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.TCP_PROV, 0, SNICommon.ConnTerminatedError, string.Empty);
+                    SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.TCP_PROV, 0, SNICommon.ConnTerminatedError, Strings.SNI_ERROR_2);
                     error = true;
                 }
             }
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNIProxy.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNIProxy.cs
@@ -379,7 +379,7 @@ private SNITCPHandle CreateTcpHandle(DataSource details, long timerExpire, objec
             string hostName = details.ServerName;
             if (string.IsNullOrWhiteSpace(hostName))
             {
-                SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.TCP_PROV, 0, SNICommon.InvalidConnStringError, string.Empty);
+                SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.TCP_PROV, 0, SNICommon.InvalidConnStringError, Strings.SNI_ERROR_25);
                 return null;
             }
 
@@ -425,10 +425,11 @@ private SNINpHandle CreateNpHandle(DataSource details, long timerExpire, object
         {
             if (parallel)
             {
-                SNICommon.ReportSNIError(SNIProviders.NP_PROV, 0, SNICommon.MultiSubnetFailoverWithNonTcpProtocol, string.Empty);
+                // Connecting to a SQL Server instance using the MultiSubnetFailover connection option is only supported when using the TCP protocol
+                SNICommon.ReportSNIError(SNIProviders.NP_PROV, 0, SNICommon.MultiSubnetFailoverWithNonTcpProtocol, Strings.SNI_ERROR_49);
                 return null;
             }
-            return new SNINpHandle(details.PipeHostName, details.PipeName, timerExpire, callbackObject);
+            return new SNINpHandle(details.PipeHostName, details.PipeName, timerExpire);
         }
 
         /// <summary>
@@ -632,7 +633,7 @@ internal static string GetLocalDBInstance(string dataSource, out bool error)
                 }
                 else
                 {
-                    SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBNoInstanceName, string.Empty);
+                    SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBNoInstanceName, Strings.SNI_ERROR_51);
                     error = true;
                     return null;
                 }
@@ -758,7 +759,7 @@ private bool InferConnectionDetails()
 
         private void ReportSNIError(SNIProviders provider)
         {
-            SNILoadHandle.SingletonInstance.LastError = new SNIError(provider, 0, SNICommon.InvalidConnStringError, string.Empty);
+            SNILoadHandle.SingletonInstance.LastError = new SNIError(provider, 0, SNICommon.InvalidConnStringError, Strings.SNI_ERROR_25);
             IsBadDataSource = true;
         }
 
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNITcpHandle.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNITcpHandle.cs
@@ -217,7 +217,7 @@ public SNITCPHandle(string serverName, int port, long timerExpire, object callba
 
                     if (reportError)
                     {
-                        ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, string.Empty);
+                        ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, Strings.SNI_ERROR_40);
                     }
                     return;
                 }
@@ -259,7 +259,7 @@ private Socket TryConnectParallel(string hostName, int port, TimeSpan ts, bool i
             {
                 // Fail if above 64 to match legacy behavior
                 callerReportError = false;
-                ReportTcpSNIError(0, SNICommon.MultiSubnetFailoverWithMoreThan64IPs, string.Empty);
+                ReportTcpSNIError(0, SNICommon.MultiSubnetFailoverWithMoreThan64IPs, Strings.SNI_ERROR_47);
                 return availableSocket;
             }
 
@@ -288,7 +288,7 @@ private Socket TryConnectParallel(string hostName, int port, TimeSpan ts, bool i
             if (!(isInfiniteTimeOut ? connectTask.Wait(-1) : connectTask.Wait(ts)))
             {
                 callerReportError = false;
-                ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, string.Empty);
+                ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, Strings.SNI_ERROR_40);
                 return availableSocket;
             }
 
@@ -644,7 +644,7 @@ public override uint Receive(out SNIPacket packet, int timeoutInMilliseconds)
                     else
                     {
                         // otherwise it is timeout for 0 or less than -1
-                        ReportTcpSNIError(0, SNICommon.ConnTimeoutError, string.Empty);
+                        ReportTcpSNIError(0, SNICommon.ConnTimeoutError, Strings.SNI_ERROR_11);
                         return TdsEnums.SNI_WAIT_TIMEOUT;
                     }
 

Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public uint StartReceive()`
`75`	`75`	`return TdsEnums.SNI_SUCCESS_IO_PENDING;`
`76`	`76`	`}`
`77`	`77`	`SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.SNIMarsConnection.StartReceive \|SNI\|ERR> Connection not useable.");`
`78`		`- return SNICommon.ReportSNIError(SNIProviders.SMUX_PROV, 0, SNICommon.ConnNotUsableError, string.Empty);`
	`78`	`+ return SNICommon.ReportSNIError(SNIProviders.SMUX_PROV, 0, SNICommon.ConnNotUsableError, Strings.SNI_ERROR_19);`
`79`	`79`	`}`
`80`	`80`	`finally`
`81`	`81`	`{`
`@@ -293,7 +293,7 @@ public void HandleReceiveComplete(SNIPacket packet, uint sniErrorCode)`
`293`	`293`
`294`	`294`	`if (!_sessions.ContainsKey(_currentHeader.sessionId))`
`295`	`295`	`{`
`296`		`- SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.SMUX_PROV, 0, SNICommon.InvalidParameterError, string.Empty);`
	`296`	`+ SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.SMUX_PROV, 0, SNICommon.InvalidParameterError, Strings.SNI_ERROR_5);`
`297`	`297`	`HandleReceiveError(packet);`
`298`	`298`	`_lowerHandle.Dispose();`
`299`	`299`	`_lowerHandle = null;`
Original file line number	Diff line number	Diff line change
`@@ -530,7 +530,7 @@ public override uint Receive(out SNIPacket packet, int timeoutInMilliseconds)`
`530`	`530`
`531`	`531`	`if (!_packetEvent.Wait(timeoutInMilliseconds))`
`532`	`532`	`{`
`533`		`- SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.SMUX_PROV, 0, SNICommon.ConnTimeoutError, string.Empty);`
	`533`	`+ SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.SMUX_PROV, 0, SNICommon.ConnTimeoutError, Strings.SNI_ERROR_11);`
`534`	`534`	`return TdsEnums.SNI_WAIT_TIMEOUT;`
`535`	`535`	`}`
`536`	`536`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@ internal sealed class SNINpHandle : SNIPhysicalHandle`
`22`	`22`	`private const int MAX_PIPE_INSTANCES = 255;`
`23`	`23`
`24`	`24`	`private readonly string _targetServer;`
`25`		`- private readonly object _callbackObject;`
`26`	`25`	`private readonly object _sendSync;`
`27`	`26`
`28`	`27`	`private Stream _stream;`
`@@ -38,15 +37,14 @@ internal sealed class SNINpHandle : SNIPhysicalHandle`
`38`	`37`	`private int _bufferSize = TdsEnums.DEFAULT_LOGIN_PACKET_SIZE;`
`39`	`38`	`private readonly Guid _connectionId = Guid.NewGuid();`
`40`	`39`
`41`		`- public SNINpHandle(string serverName, string pipeName, long timerExpire, object callbackObject)`
	`40`	`+ public SNINpHandle(string serverName, string pipeName, long timerExpire)`
`42`	`41`	`{`
`43`	`42`	`long scopeID = SqlClientEventSource.Log.TrySNIScopeEnterEvent("<sc.SNI.SNINpHandle.SNINpHandle \|SNI\|INFO\|SCOPE> Constructor");`
`44`	`43`	`SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.SNINpHandle.SNINpHandle \|SNI\|INFO> Constructor. server name = {0}, pipe name = {1}", serverName, pipeName);`
`45`	`44`	`try`
`46`	`45`	`{`
`47`	`46`	`_sendSync = new object();`
`48`	`47`	`_targetServer = serverName;`
`49`		`- _callbackObject = callbackObject;`
`50`	`48`
`51`	`49`	`try`
`52`	`50`	`{`
`@@ -86,7 +84,7 @@ public SNINpHandle(string serverName, string pipeName, long timerExpire, object`
`86`	`84`
`87`	`85`	`if (!_pipeStream.IsConnected \|\| !_pipeStream.CanWrite \|\| !_pipeStream.CanRead)`
`88`	`86`	`{`
`89`		`- SNICommon.ReportSNIError(SNIProviders.NP_PROV, 0, SNICommon.ConnOpenFailedError, string.Empty);`
	`87`	`+ SNICommon.ReportSNIError(SNIProviders.NP_PROV, 0, SNICommon.ConnOpenFailedError, Strings.SNI_ERROR_1);`
`90`	`88`	`_status = TdsEnums.SNI_ERROR;`
`91`	`89`	`SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.SNINpHandle.SNINpHandle \|SNI\|ERR> Pipe stream is not connected or cannot write or read to/from it.");`
`92`	`90`	`return;`
`@@ -126,7 +124,7 @@ public override int ProtocolVersion`
`126`	`124`	`{`
`127`	`125`	`try`
`128`	`126`	`{`
`129`		`- return (int)_sslStream.SslProtocol;`
	`127`	`+ return (int)_sslStream?.SslProtocol;`
`130`	`128`	`}`
`131`	`129`	`catch`
`132`	`130`	`{`
Original file line number	Diff line number	Diff line change
`@@ -278,7 +278,7 @@ private void ReadFromStreamAsyncContinuation(Task<int> t, object state)`
`278`	`278`
`279`	`279`	`if (_dataLength == 0)`
`280`	`280`	`{`
`281`		`- SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.TCP_PROV, 0, SNICommon.ConnTerminatedError, string.Empty);`
	`281`	`+ SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.TCP_PROV, 0, SNICommon.ConnTerminatedError, Strings.SNI_ERROR_2);`
`282`	`282`	`error = true;`
`283`	`283`	`}`
`284`	`284`	`}`
Original file line number	Diff line number	Diff line change
`@@ -379,7 +379,7 @@ private SNITCPHandle CreateTcpHandle(DataSource details, long timerExpire, objec`
`379`	`379`	`string hostName = details.ServerName;`
`380`	`380`	`if (string.IsNullOrWhiteSpace(hostName))`
`381`	`381`	`{`
`382`		`- SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.TCP_PROV, 0, SNICommon.InvalidConnStringError, string.Empty);`
	`382`	`+ SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.TCP_PROV, 0, SNICommon.InvalidConnStringError, Strings.SNI_ERROR_25);`
`383`	`383`	`return null;`
`384`	`384`	`}`
`385`	`385`
`@@ -425,10 +425,11 @@ private SNINpHandle CreateNpHandle(DataSource details, long timerExpire, object`
`425`	`425`	`{`
`426`	`426`	`if (parallel)`
`427`	`427`	`{`
`428`		`- SNICommon.ReportSNIError(SNIProviders.NP_PROV, 0, SNICommon.MultiSubnetFailoverWithNonTcpProtocol, string.Empty);`
	`428`	`+ // Connecting to a SQL Server instance using the MultiSubnetFailover connection option is only supported when using the TCP protocol`
	`429`	`+ SNICommon.ReportSNIError(SNIProviders.NP_PROV, 0, SNICommon.MultiSubnetFailoverWithNonTcpProtocol, Strings.SNI_ERROR_49);`
`429`	`430`	`return null;`
`430`	`431`	`}`
`431`		`- return new SNINpHandle(details.PipeHostName, details.PipeName, timerExpire, callbackObject);`
	`432`	`+ return new SNINpHandle(details.PipeHostName, details.PipeName, timerExpire);`
`432`	`433`	`}`
`433`	`434`
`434`	`435`	`/// <summary>`
`@@ -632,7 +633,7 @@ internal static string GetLocalDBInstance(string dataSource, out bool error)`
`632`	`633`	`}`
`633`	`634`	`else`
`634`	`635`	`{`
`635`		`- SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBNoInstanceName, string.Empty);`
	`636`	`+ SNILoadHandle.SingletonInstance.LastError = new SNIError(SNIProviders.INVALID_PROV, 0, SNICommon.LocalDBNoInstanceName, Strings.SNI_ERROR_51);`
`636`	`637`	`error = true;`
`637`	`638`	`return null;`
`638`	`639`	`}`
`@@ -758,7 +759,7 @@ private bool InferConnectionDetails()`
`758`	`759`
`759`	`760`	`private void ReportSNIError(SNIProviders provider)`
`760`	`761`	`{`
`761`		`- SNILoadHandle.SingletonInstance.LastError = new SNIError(provider, 0, SNICommon.InvalidConnStringError, string.Empty);`
	`762`	`+ SNILoadHandle.SingletonInstance.LastError = new SNIError(provider, 0, SNICommon.InvalidConnStringError, Strings.SNI_ERROR_25);`
`762`	`763`	`IsBadDataSource = true;`
`763`	`764`	`}`
`764`	`765`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ public SNITCPHandle(string serverName, int port, long timerExpire, object callba`
`217`	`217`
`218`	`218`	`if (reportError)`
`219`	`219`	`{`
`220`		`- ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, string.Empty);`
	`220`	`+ ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, Strings.SNI_ERROR_40);`
`221`	`221`	`}`
`222`	`222`	`return;`
`223`	`223`	`}`
`@@ -259,7 +259,7 @@ private Socket TryConnectParallel(string hostName, int port, TimeSpan ts, bool i`
`259`	`259`	`{`
`260`	`260`	`// Fail if above 64 to match legacy behavior`
`261`	`261`	`callerReportError = false;`
`262`		`- ReportTcpSNIError(0, SNICommon.MultiSubnetFailoverWithMoreThan64IPs, string.Empty);`
	`262`	`+ ReportTcpSNIError(0, SNICommon.MultiSubnetFailoverWithMoreThan64IPs, Strings.SNI_ERROR_47);`
`263`	`263`	`return availableSocket;`
`264`	`264`	`}`
`265`	`265`
`@@ -288,7 +288,7 @@ private Socket TryConnectParallel(string hostName, int port, TimeSpan ts, bool i`
`288`	`288`	`if (!(isInfiniteTimeOut ? connectTask.Wait(-1) : connectTask.Wait(ts)))`
`289`	`289`	`{`
`290`	`290`	`callerReportError = false;`
`291`		`- ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, string.Empty);`
	`291`	`+ ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, Strings.SNI_ERROR_40);`
`292`	`292`	`return availableSocket;`
`293`	`293`	`}`
`294`	`294`
`@@ -644,7 +644,7 @@ public override uint Receive(out SNIPacket packet, int timeoutInMilliseconds)`
`644`	`644`	`else`
`645`	`645`	`{`
`646`	`646`	`// otherwise it is timeout for 0 or less than -1`
`647`		`- ReportTcpSNIError(0, SNICommon.ConnTimeoutError, string.Empty);`
	`647`	`+ ReportTcpSNIError(0, SNICommon.ConnTimeoutError, Strings.SNI_ERROR_11);`
`648`	`648`	`return TdsEnums.SNI_WAIT_TIMEOUT;`
`649`	`649`	`}`
`650`	`650`