Add IP address preference support for TCP connection

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

@@ -339,9 +339,6 @@ private static Socket Connect(string serverName, int port, TimeSpan timeout, boo
             string IPv4String = null;
             string IPv6String = null;         
 
-            Socket[] sockets = new Socket[2];
-            AddressFamily[] preferedIPFamilies = new AddressFamily[2];
-
             if (ipPreference == SqlConnectionIPAddressPreference.IPv6First)
             {
                 preferedIPFamilies[0] = AddressFamily.InterNetworkV6;
@@ -352,6 +349,14 @@ private static Socket Connect(string serverName, int port, TimeSpan timeout, boo
                 preferedIPFamilies[0] = AddressFamily.InterNetwork;
                 preferedIPFamilies[1] = AddressFamily.InterNetworkV6;
             }
+            // Returning null socket is handled by the caller function.
+            if(ipAddresses == null || ipAddresses.Length == 0)
+            {
+                return null;
+            }
+
+            Socket[] sockets = new Socket[ipAddresses.Length];
+            AddressFamily[] preferedIPFamilies = new AddressFamily[] { AddressFamily.InterNetwork, AddressFamily.InterNetworkV6 };
 
             CancellationTokenSource cts = null;
 
@@ -383,13 +388,14 @@ void Cancel()
             Socket availableSocket = null;
             try
             {
+                int n = 0; // Socket index
+
                 // We go through the IP list twice.
                 // In the first traversal, we only try to connect with the preferedIPFamilies[0].
                 // In the second traversal, we only try to connect with the preferedIPFamilies[1].
                 // For UsePlatformDefault preference, we do traveral once.
                 for (int i = 0; i < preferedIPFamilies.Length; ++i)
                 {
-
                     foreach (IPAddress ipAddress in ipAddresses)
                     {
                         try
@@ -401,18 +407,18 @@ void Cancel()
                                     continue;
                                 }
 
-                                sockets[i] = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+                                sockets[n] = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
 
                                 // enable keep-alive on socket
-                                SetKeepAliveValues(ref sockets[i]);
+                                SetKeepAliveValues(ref sockets[n]);
 
                                 SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.INFO, "Connecting to IP address {0} and port {1}", args0: ipAddress, args1: port);
-                                sockets[i].Connect(ipAddress, port);
-                                if (sockets[i] != null) // sockets[i] can be null if cancel callback is executed during connect()
+                                sockets[n].Connect(ipAddress, port);
+                                if (sockets[n] != null) // sockets[n] can be null if cancel callback is executed during connect()
                                 {
-                                    if (sockets[i].Connected)
+                                    if (sockets[n].Connected)
                                     {
-                                        availableSocket = sockets[i];
+                                        availableSocket = sockets[n];
                                         if (ipAddress.AddressFamily == AddressFamily.InterNetwork)
                                         {
                                             IPv4String = ipAddress.ToString();
@@ -421,12 +427,13 @@ void Cancel()
                                         {
                                             IPv6String = ipAddress.ToString();
                                         }
+
                                         break;
                                     }
                                     else
                                     {
-                                        sockets[i].Dispose();
-                                        sockets[i] = null;
+                                        sockets[n].Dispose();
+                                        sockets[n] = null;
                                     }
                                 }
                                 n++;

src/Microsoft.Data.SqlClient/tests/FunctionalTests/SqlConnectionStringBuilderTest.cs

@@ -55,6 +55,8 @@ public partial class SqlConnectionStringBuilderTest
         [InlineData("Initial Catalog = Northwind; Failover Partner = randomserver.sys.local")]
         [InlineData("Initial Catalog = tempdb")]
         [InlineData("Integrated Security = true")]
+        [InlineData("IPAddressPreference = IPv4First")]
+        [InlineData("IPAddressPreference = IPv6First")]
         [InlineData("Trusted_Connection = false")]
         [InlineData("Max Pool Size = 50")]
         [InlineData("Min Pool Size = 20")]

src/Microsoft.Data.SqlClient/tests/FunctionalTests/SqlConnectionTest.cs

@@ -11,7 +11,7 @@ namespace Microsoft.Data.SqlClient.Tests
 {
     public partial class SqlConnectionTest
     {
-        private static readonly string[] s_retrieveInternalInfoKeys = 
+        private static readonly string[] s_retrieveInternalInfoKeys =
         {
             "SQLDNSCachingSupportedState",
             "SQLDNSCachingSupportedStateBeforeRedirect"
@@ -53,7 +53,7 @@ public void Constructor2()
             Assert.Null(cn.Site);
             Assert.Equal(ConnectionState.Closed, cn.State);
             Assert.False(cn.StatisticsEnabled);
-            Assert.True(string.Compare (Environment.MachineName, cn.WorkstationId, true) == 0);
+            Assert.True(string.Compare(Environment.MachineName, cn.WorkstationId, true) == 0);
 
             cn = new SqlConnection((string)null);
             Assert.Equal(string.Empty, cn.ConnectionString);
@@ -67,7 +67,7 @@ public void Constructor2()
             Assert.Null(cn.Site);
             Assert.Equal(ConnectionState.Closed, cn.State);
             Assert.False(cn.StatisticsEnabled);
-            Assert.True(string.Compare (Environment.MachineName, cn.WorkstationId, true) == 0);
+            Assert.True(string.Compare(Environment.MachineName, cn.WorkstationId, true) == 0);
         }
 
         [Fact]
@@ -107,7 +107,7 @@ public void Constructor2_ConnectionString_Invalid()
             try
             {
                 new SqlConnection("Packet Size=511");
-           }
+            }
             catch (ArgumentException ex)
             {
                 // Invalid 'Packet Size'.  The value must be an
@@ -1326,7 +1326,7 @@ public void RetrieveInternalInfo_ExpectedKeysInDictionary_Success()
             Assert.NotEmpty(d.Values);
             Assert.Equal(s_retrieveInternalInfoKeys.Length, d.Values.Count);
 
-            foreach(string key in s_retrieveInternalInfoKeys)
+            foreach (string key in s_retrieveInternalInfoKeys)
             {
                 Assert.True(d.ContainsKey(key));
 
@@ -1343,5 +1343,65 @@ public void RetrieveInternalInfo_UnexpectedKeysInDictionary_Success()
             IDictionary<string, object> d = cn.RetrieveInternalInfo();
             Assert.False(d.ContainsKey("Foo"));
         }
+
+        [Fact]
+        public void ConnectionString_IPAddressPreference()
+        {
+            SqlConnection cn = new SqlConnection();
+            cn.ConnectionString = "IPAddressPreference=IPv4First";
+            cn.ConnectionString = "IPAddressPreference=IPv6First";
+            cn.ConnectionString = "IPAddressPreference=UsePlatformDefault";
+        }
+
+        [Fact]
+        public void ConnectionString_IPAddressPreference_Invalid()
+        {
+            SqlConnection cn = new SqlConnection();
+
+            // number
+            try
+            {
+                cn.ConnectionString = "IPAddressPreference=-1";
+            }
+            catch (ArgumentException ex)
+            {
+                // Invalid value for key 'ip address preference'
+                Assert.Equal(typeof(ArgumentException), ex.GetType());
+                Assert.Null(ex.InnerException);
+                Assert.NotNull(ex.Message);
+                Assert.Contains("'ip address preference'", ex.Message);
+                Assert.Null(ex.ParamName);
+            }
+
+            // symbols
+            try
+            {
+                cn.ConnectionString = "IPAddressPreference=!@#";
+            }
+            catch (ArgumentException ex)
+            {
+                // Invalid value for key 'ip address preference'
+                Assert.Equal(typeof(ArgumentException), ex.GetType());
+                Assert.Null(ex.InnerException);
+                Assert.NotNull(ex.Message);
+                Assert.Contains("'ip address preference'", ex.Message);
+                Assert.Null(ex.ParamName);
+            }
+
+            // invalid ip preference
+            try
+            {
+                cn.ConnectionString = "IPAddressPreference=ABC";
+            }
+            catch (ArgumentException ex)
+            {
+                // Invalid value for key 'ip address preference'
+                Assert.Equal(typeof(ArgumentException), ex.GetType());
+                Assert.Null(ex.InnerException);
+                Assert.NotNull(ex.Message);
+                Assert.Contains("'ip address preference'", ex.Message);
+                Assert.Null(ex.ParamName);
+            }
+        }
     }
 }

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

@@ -9,6 +9,9 @@
 using System.Diagnostics.Tracing;
 using System.Globalization;
 using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
 using System.Security;
 using System.Threading;
 using System.Threading.Tasks;
@@ -345,6 +348,20 @@ public static bool IsTCPConnectionStringPasswordIncluded()
             return RetrieveValueFromConnStr(TCPConnectionString, new string[] { "Password", "PWD" }) != string.Empty;
         }
 
+        public static bool DoesHostAddressContainBothIPv4AndIPv6()
+        {
+            if (!IsDNSCachingSetup())
+            {
+                return false;
+            }
+            using (var connection = new SqlConnection(DNSCachingConnString))
+            {
+                List<IPAddress> ipAddresses = Dns.GetHostAddresses(connection.DataSource).ToList();
+                return ipAddresses.Exists(ip => ip.AddressFamily == AddressFamily.InterNetwork) &&
+                    ipAddresses.Exists(ip => ip.AddressFamily == AddressFamily.InterNetworkV6);
+            }
+        }
+
         /// <summary>
         /// Generate a unique name to use in Sql Server; 
         /// some providers does not support names (Oracle supports up to 30).

src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTesting.Tests.csproj

@@ -70,6 +70,7 @@
       <Link>Common\System\Collections\DictionaryExtensions.cs</Link>
     </Compile>
     <Compile Include="DataCommon\AADUtility.cs" />
+    <Compile Include="SQL\ConfigurableIpPreferenceTest\ConfigurableIpPreferenceTest.cs" />
     <None Include="SQL\RetryLogic\Resources\CustomConfigurableRetryLogic.cs" />
     <Compile Include="SQL\RetryLogic\RetryLogicConfigHelper.cs" />
     <Compile Include="SQL\SqlBulkCopyTest\OrderHint.cs" />

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

@@ -0,0 +1,67 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Reflection;
+using Xunit;
+
+using static Microsoft.Data.SqlClient.ManualTesting.Tests.DataTestUtility;
+using static Microsoft.Data.SqlClient.ManualTesting.Tests.DNSCachingTest;
+
+namespace Microsoft.Data.SqlClient.ManualTesting.Tests
+{
+    public class ConfigurableIpPreferenceTest
+    {
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DoesHostAddressContainBothIPv4AndIPv6))]
+        [InlineData(";IPAddressPreference=IPv6First")]
+        [InlineData(";IPAddressPreference=IPv4First")]
+        public void ConfigurableIpPreferenceManagedSni(string ipPreference)
+        {
+            AppContext.SetSwitch("Switch.Microsoft.Data.SqlClient.UseManagedNetworkingOnWindows", true);
+            TestConfigurableIpPreference(ipPreference);
+            AppContext.SetSwitch("Switch.Microsoft.Data.SqlClient.UseManagedNetworkingOnWindows", false);
+        }
+
+
+        private void TestConfigurableIpPreference(string ipPreference)
+        {
+            using (SqlConnection connection = new SqlConnection(DNSCachingConnString + ipPreference))
+            {
+                // each successful connection updates the dns cache entry for the data source
+                connection.Open();
+                var SQLFallbackDNSCacheInstance = GetDnsCache();
+
+                // get the dns cache entry with the given key. parameters[1] will be initialized as the entry
+                object[] parameters = new object[] { connection.DataSource, null };
+                SQLFallbackDNSCacheGetDNSInfo.Invoke(SQLFallbackDNSCacheInstance, parameters);
+                var dnsCacheEntry = parameters[1];
+
+                const string AddrIPv4Property = "AddrIPv4";
+                const string AddrIPv6Property = "AddrIPv6";
+                const string FQDNProperty = "FQDN";
+
+                Assert.Equal(connection.DataSource, GetPropertyValueFromCacheEntry(FQDNProperty, dnsCacheEntry));
+
+                if (ipPreference == ";IPAddressPreference=IPv4First")
+                {
+                    Assert.NotNull(GetPropertyValueFromCacheEntry(AddrIPv4Property, dnsCacheEntry));
+                    Assert.Null(GetPropertyValueFromCacheEntry(AddrIPv6Property, dnsCacheEntry));
+                }
+                else if (ipPreference == ";IPAddressPreference=IPv6First")
+                {
+                    Assert.NotNull(GetPropertyValueFromCacheEntry(AddrIPv6Property, dnsCacheEntry));
+                    Assert.Null(GetPropertyValueFromCacheEntry(AddrIPv4Property, dnsCacheEntry));
+                }
+                string x = "Aabqsaada";
+                Console.WriteLine(x);
+            }
+
+            object GetDnsCache() =>
+               SQLFallbackDNSCacheType.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public).GetValue(null);
+
+            string GetPropertyValueFromCacheEntry(string property, object dnsCacheEntry) =>
+               (string)SQLDNSInfoType.GetProperty(property).GetValue(dnsCacheEntry);
+        }
+    }
+}