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,36 @@ 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 is "np:servername" or "np:servername\instance"
                 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
+                            ReadOnlySpan<string> arr = tokensByBackSlash; 
+                            PipeHostName = ServerName = arr[0];
+                            InferLocalServerName();
+                            PipeName = $"{InstancePrefix}{arr[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,12 @@ 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
+            // Non-Windows OS do not have registry
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return null;
+            }
+
             try
             {
                 using (RegistryKey key = Registry.LocalMachine.OpenSubKey(subkey, false))

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

@@ -3,8 +3,10 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.IO.Pipes;
 using System.Net;
 using System.Net.Sockets;
+using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
@@ -13,6 +15,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 +79,62 @@ 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);
             }
         }
 
+        [PlatformSpecific(TestPlatforms.Windows)]
+        [SkipOnTargetFramework(TargetFrameworkMonikers.Netcoreapp)]
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
+        [InlineData("")]
+        [InlineData("MSSQLSERVER02")]
+        public static void NamedPipeInstanceNormalizedPipePathTest(string instance)
+        {
+            var instancePrefix = "MSSQL$";
+            var pathSeparator = "\\";
+            var defaultPipeName = "sql\\sqlquery";
+
+            SqlConnectionStringBuilder builder = new(DataTestUtility.NPConnectionString); 
+
+            Assert.True(DataTestUtility.ParseDataSource(builder.DataSource, out string hostname, out _, out string instanceName));
+            instanceName = instance;
+
+            // Mimic the SNIProxy.InferNamedPipesInformation's logic to initialize the PipeName.  It is private so can not be used here.
+            string pipeName = $"{defaultPipeName}";
+            if (instanceName != string.Empty)
+            {
+                // This is how InferNamedPipesInformation build the pipeName when there's an instance provided. 
+                pipeName = $"{instancePrefix}{instanceName.ToUpper()}{pathSeparator}{defaultPipeName}";
+            }
+
+            NamedPipeClientStream pipeStream = new NamedPipeClientStream(
+                    hostname,
+                    pipeName,
+                    PipeDirection.InOut,
+                    PipeOptions.Asynchronous | PipeOptions.WriteThrough);
+
+            string normalizedPipePath = pipeStream
+                .GetType()
+                .GetField("m_normalizedPipePath", BindingFlags.Instance | BindingFlags.NonPublic)
+                .GetValue(pipeStream).ToString();
+
+            // Check if the normalized pipe path parsed by NamedPipeClientStream object from supplied 
+            // host and pipename has a valid format
+            if (instanceName != string.Empty)
+            {
+                // Secondary NamedPipe Instance normalized pipe path format check
+                Assert.Matches(@"\\\\.*\\pipe\\MSSQL\$.*\\sql\\sqlquery", normalizedPipePath);
+            }
+            else
+            {
+                // Default NamedPipe Instance normalized pipe path format check
+                Assert.Matches(@"\\\\.*\\pipe\\sql\\sqlquery", normalizedPipePath);
+            }
+        }
+
         private static bool IsBrowserAlive(string browserHostname)
         {
             const byte ClntUcastEx = 0x03;