Fix | Fixing issue for SQL named Instances in Managed SNI using named pipes.

src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNINpHandle.cs

@@ -68,7 +68,7 @@ public SNINpHandle(string serverName, string pipeName, TimeoutTimer timeout, boo
                     {
                         int timeoutMilliseconds = timeout.MillisecondsRemainingInt;
                         SqlClientEventSource.Log.TrySNITraceEvent(nameof(SNINpHandle), EventType.INFO,
-                                                                  "Connection Id {0}, Setting server name = {1}, pipe name = {2}. Connecting within the {3} sepecified milliseconds.",
+                                                                  "Connection Id {0}, Setting server name = {1}, pipe name = {2}. Connecting within the {3} specified milliseconds.",
                                                                   args0: _connectionId,
                                                                   args1: serverName,
                                                                   args2: pipeName,

src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNIProxy.cs

@@ -418,6 +418,8 @@ internal class DataSource
         private const string LocalDbHost_NP = @"np:\\.\pipe\LOCALDB#";
         private const string NamedPipeInstanceNameHeader = "mssql$";
         private const string DefaultPipeName = "sql\\query";
+        private const string InstancePrefix = "MSSQL$";
+        private const string PathSeparator = "\\";
 
         internal enum Protocol { TCP, NP, None, Admin };
 
@@ -676,12 +678,35 @@ private bool InferNamedPipesInformation()
             // If we have a datasource beginning with a pipe or we have already determined that the protocol is Named Pipe
             if (_dataSourceAfterTrimmingProtocol.StartsWith(PipeBeginning, StringComparison.Ordinal) || _connectionProtocol == Protocol.NP)
             {
-                // If the data source is "np:servername"
+                // If the data source starts with "np:servername"
                 if (!_dataSourceAfterTrimmingProtocol.Contains(PipeBeginning))
                 {
-                    PipeHostName = ServerName = _dataSourceAfterTrimmingProtocol;
-                    InferLocalServerName();
-                    PipeName = SNINpHandle.DefaultPipePath;
+                    // Assuming that user did not change default NamedPipe name, if the datasource is in the format servername\instance, 
+                    // separate servername and instance and prepend instance with MSSQL$ and append default pipe path 
+                    // https://learn.microsoft.com/en-us/sql/tools/configuration-manager/named-pipes-properties?view=sql-server-ver16
+                    if (_dataSourceAfterTrimmingProtocol.Contains(PathSeparator) && _connectionProtocol == Protocol.NP)
+                    {
+                        string[] tokensByBackSlash = _dataSourceAfterTrimmingProtocol.Split(BackSlashCharacter);
+                        if (tokensByBackSlash.Length == 2)
+                        {
+                            // NamedPipeClientStream object will create the network path using PipeHostName and PipeName
+                            // and can be seen in its _normalizedPipePath variable in the format \\servername\pipe\MSSQL$<instancename>\sql\query
+                            PipeHostName = ServerName = tokensByBackSlash[0];
+                            InferLocalServerName();
+                            PipeName = $"{InstancePrefix}{tokensByBackSlash[1].ToUpper()}{PathSeparator}{DefaultPipeName}";
+                        }
+                        else
+                        {
+                            ReportSNIError(SNIProviders.NP_PROV);
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        PipeHostName = ServerName = _dataSourceAfterTrimmingProtocol;
+                        InferLocalServerName();
+                        PipeName = SNINpHandle.DefaultPipePath;
+                    }
                     return true;
                 }
 

src/Microsoft.Data.SqlClient/src/Microsoft/Data/Common/AdapterUtil.Windows.cs

@@ -29,6 +29,15 @@ internal static object LocalMachineRegistryValue(string subkey, string queryvalu
 #if !NET6_0_OR_GREATER
             (new RegistryPermission(RegistryPermissionAccess.Read, "HKEY_LOCAL_MACHINE\\" + subkey)).Assert(); // MDAC 62028
 #endif
+
+// Uncomment this block if debugging in WSL
+//#if DEBUG
+//            // Non-Windows OS do not have registry
+//            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+//            {
+//                return null;
+//            }
+//#endif
             try
             {
                 using (RegistryKey key = Registry.LocalMachine.OpenSubKey(subkey, false))

src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs

@@ -27,6 +27,8 @@ public static class DataTestUtility
     {
         public static readonly string NPConnectionString = null;
         public static readonly string TCPConnectionString = null;
+        public static readonly string NPInstanceConnectionString = null;
+        public static readonly string TCPInstanceConnectionString = null;
         public static readonly string TCPConnectionStringHGSVBS = null;
         public static readonly string TCPConnectionStringAASVBS = null;
         public static readonly string TCPConnectionStringNoneVBS = null;
@@ -90,6 +92,8 @@ static DataTestUtility()
             Config c = Config.Load();
             NPConnectionString = c.NPConnectionString;
             TCPConnectionString = c.TCPConnectionString;
+            NPInstanceConnectionString = c.NPInstanceConnectionString;
+            TCPInstanceConnectionString = c.TCPInstanceConnectionString;
             TCPConnectionStringHGSVBS = c.TCPConnectionStringHGSVBS;
             TCPConnectionStringAASVBS = c.TCPConnectionStringAASVBS;
             TCPConnectionStringNoneVBS = c.TCPConnectionStringNoneVBS;
@@ -311,6 +315,11 @@ public static bool IsTCPConnStringSetup()
             return !string.IsNullOrEmpty(TCPConnectionString);
         }
 
+        public static bool IsNPInstanceConnStringsSetup()
+        {
+            return !string.IsNullOrEmpty(NPInstanceConnectionString);
+        }
+
         // Synapse: Always Encrypted is not supported with Azure Synapse.
         //          Ref: https://feedback.azure.com/forums/307516-azure-synapse-analytics/suggestions/17858869-support-always-encrypted-in-sql-data-warehouse
         public static bool AreConnStringSetupForAE()

src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/InstanceNameTest/InstanceNameTest.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Data;
 using System.Net;
 using System.Net.Sockets;
 using System.Text;
@@ -13,6 +14,7 @@ namespace Microsoft.Data.SqlClient.ManualTesting.Tests
 {
     public static class InstanceNameTest
     {
+
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsNotAzureServer), nameof(DataTestUtility.IsNotAzureSynapse), nameof(DataTestUtility.AreConnStringsSetup))]
         public static void ConnectToSQLWithInstanceNameTest()
         {
@@ -76,13 +78,33 @@ public static void ConnectManagedWithInstanceNameTest(bool useMultiSubnetFailove
             if (!IsValidInstance(hostname, instanceName))
             {
                 builder.DataSource = hostname + "\\" + instanceName;
-                
+
                 using SqlConnection connection = new(builder.ConnectionString);
                 SqlException ex = Assert.Throws<SqlException>(() => connection.Open());
                 Assert.Contains("Error Locating Server/Instance Specified", ex.Message);
             }
         }
 
+        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsNPInstanceConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]
+        [PlatformSpecific(TestPlatforms.Windows)] // Named pipes with the given input strings are not supported on Unix
+        public async static void NamedPipeSecondaryInstanceTest()
+        {
+            AppContext.SetSwitch("Switch.Microsoft.Data.SqlClient.UseManagedNetworkingOnWindows", true);
+
+            SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(DataTestUtility.NPInstanceConnectionString);
+            builder.ConnectTimeout = 5;
+            await OpenGoodConnection(builder.ConnectionString);
+        }
+
+        private async static Task OpenGoodConnection(string connectionString)
+        {
+            using (SqlConnection conn = new SqlConnection(connectionString))
+            {
+                await conn.OpenAsync();
+                DataTestUtility.AssertEqualsWithDescription( ConnectionState.Open, conn.State, "FAILED: Connection should be in open state");
+            }
+        }
+
         private static bool IsBrowserAlive(string browserHostname)
         {
             const byte ClntUcastEx = 0x03;

src/Microsoft.Data.SqlClient/tests/tools/Microsoft.Data.SqlClient.ExtUtilities/SqlDbManager.cs

@@ -23,6 +23,8 @@ public static class SqlDbManager
 
         private const string TCPConnectionString = "TCPConnectionString";
         private const string NPConnectionString = "NPConnectionString";
+        private const string TCPInstanceConnectionString = "TCPInstanceConnectionString";
+        private const string NPInstanceConnectionString = "NPInstanceConnectionString";
         private const string TCPConnectionStringAASSGX = "TCPConnectionStringAASSGX";
         private const string TCPConnectionStringAASVBS = "TCPConnectionStringAASVBS";
         private const string TCPConnectionStringHGSVBS = "TCPConnectionStringHGSVBS";
@@ -63,7 +65,7 @@ public static void Run(string[] args)
                             {
                                 // We do not create database for HGS-VBS since SQL Server for AASVBS and HGSVBS connection strings is same.
                                 // Do not create database for NP connection string, since server is always same as TCP
-                                if (activeConnString.Key != TCPConnectionStringHGSVBS && activeConnString.Key != NPConnectionString)
+                                if (activeConnString.Key != TCPConnectionStringHGSVBS && activeConnString.Key != NPConnectionString && activeConnString.Key != NPInstanceConnectionString)
                                 {
                                     //Create a new database
                                     CreateDatabase(dbName, context);
@@ -77,7 +79,7 @@ public static void Run(string[] args)
                             {
                                 // We do not drop database for HGS-VBS since SQL Server for AASVBS and HGSVBS connection strings is same.
                                 // Do not drop database for NP connection string, since server is always same as TCP
-                                if (activeConnString.Key != TCPConnectionStringHGSVBS && activeConnString.Key != NPConnectionString)
+                                if (activeConnString.Key != TCPConnectionStringHGSVBS && activeConnString.Key != NPConnectionString && activeConnString.Key != NPInstanceConnectionString)
                                 {
                                     // Drop Northwind for test run.
                                     DropIfExistsDatabase(dbName, context);
@@ -118,6 +120,16 @@ private static void LoadActiveConnectionStrings()
             {
                 s_activeConnectionStrings.Add(NPConnectionString, s_configJson.NPConnectionString);
             }
+            if (!string.IsNullOrEmpty(s_configJson.TCPInstanceConnectionString))
+            {
+                Console.WriteLine($"Loading {s_configJson.TCPInstanceConnectionString}");
+                s_activeConnectionStrings.Add(TCPInstanceConnectionString, s_configJson.TCPInstanceConnectionString);
+            }
+            if (!string.IsNullOrEmpty(s_configJson.NPInstanceConnectionString))
+            {
+                Console.WriteLine($"Loading {s_configJson.NPInstanceConnectionString}");
+                s_activeConnectionStrings.Add(NPInstanceConnectionString, s_configJson.NPInstanceConnectionString);
+            }
             if (s_configJson.EnclaveEnabled)
             {
                 if (!string.IsNullOrEmpty(s_configJson.TCPConnectionStringAASSGX))
@@ -145,6 +157,12 @@ private static void UpdateConfig(string key, SqlConnectionStringBuilder builder)
                 case NPConnectionString:
                     s_configJson.NPConnectionString = builder.ConnectionString;
                     break;
+                case TCPInstanceConnectionString:
+                    s_configJson.TCPInstanceConnectionString = builder.ConnectionString;
+                    break;
+                case NPInstanceConnectionString:
+                    s_configJson.NPInstanceConnectionString = builder.ConnectionString;
+                    break;
                 case TCPConnectionStringAASSGX:
                     s_configJson.TCPConnectionStringAASSGX = builder.ConnectionString;
                     break;

src/Microsoft.Data.SqlClient/tests/tools/Microsoft.Data.SqlClient.TestUtilities/Config.cs

@@ -12,6 +12,8 @@ public class Config
     {
         public string TCPConnectionString = null;
         public string NPConnectionString = null;
+        public string TCPInstanceConnectionString = null;
+        public string NPInstanceConnectionString = null;
         public string TCPConnectionStringHGSVBS = null;
         public string TCPConnectionStringAASVBS = null;
         public string TCPConnectionStringNoneVBS = null;

src/Microsoft.Data.SqlClient/tests/tools/Microsoft.Data.SqlClient.TestUtilities/config.default.json

@@ -1,6 +1,8 @@
 {
     "TCPConnectionString": "Data Source=tcp:localhost;Database=Northwind;Integrated Security=true;Encrypt=false;",
     "NPConnectionString": "Data Source=np:localhost;Database=Northwind;Integrated Security=true;Encrypt=false;",
+    "TCPInstanceConnectionString": "",
+    "NPInstanceConnectionString": "",
     "TCPConnectionStringHGSVBS": "",
     "TCPConnectionStringAASVBS": "",
     "TCPConnectionStringNoneVBS": "",