Implement more ServicePoint properties

src/libraries/System.Net.Requests/src/System.Net.Requests.csproj

@@ -110,6 +110,7 @@
     <Reference Include="System.Diagnostics.Tracing" />
     <Reference Include="System.Memory" />
     <Reference Include="System.Net.Http" />
+    <Reference Include="System.Net.NameResolution" />
     <Reference Include="System.Net.Primitives" />
     <Reference Include="System.Net.Security" />
     <Reference Include="System.Net.Sockets" />

src/libraries/System.Net.Requests/src/System/Net/HttpWebRequest.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
+using System.Net;
 using System.Net.Cache;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -806,10 +807,12 @@ public Version ProtocolVersion
                 if (value.Equals(HttpVersion.Version11))
                 {
                     IsVersionHttp10 = false;
+                    ServicePoint.ProtocolVersion = HttpVersion.Version11;
                 }
                 else if (value.Equals(HttpVersion.Version10))
                 {
                     IsVersionHttp10 = true;
+                    ServicePoint.ProtocolVersion = HttpVersion.Version10;
                 }
                 else
                 {
@@ -1196,7 +1199,7 @@ private async Task<WebResponse> SendRequest(bool async)
 
                 HttpResponseMessage responseMessage = await _sendRequestTask.ConfigureAwait(false);
 
-                HttpWebResponse response = new HttpWebResponse(responseMessage, _requestUri, _cookieContainer);
+                HttpWebResponse response = new HttpWebResponse(responseMessage, _requestUri, _cookieContainer, DefaultMaximumErrorResponseLength);
 
                 int maxSuccessStatusCode = AllowAutoRedirect ? 299 : 399;
                 if ((int)response.StatusCode > maxSuccessStatusCode || (int)response.StatusCode < 200)
@@ -1621,6 +1624,13 @@ private static HttpClient CreateHttpClient(HttpClientParameters parameters, Http
                     handler.UseCookies = false;
                 }
 
+                if (parameters.ServicePoint is { } servicePoint)
+                {
+                    handler.MaxConnectionsPerServer = servicePoint.ConnectionLimit;
+                    handler.PooledConnectionIdleTimeout = servicePoint.MaxIdleTime == -1 ? Threading.Timeout.InfiniteTimeSpan : TimeSpan.FromMilliseconds(servicePoint.MaxIdleTime);
+                    handler.PooledConnectionLifetime = servicePoint.ConnectionLeaseTimeout == -1 ? Threading.Timeout.InfiniteTimeSpan : TimeSpan.FromMilliseconds(servicePoint.ConnectionLeaseTimeout);
+                }
+
                 Debug.Assert(handler.UseProxy); // Default of handler.UseProxy is true.
                 Debug.Assert(handler.Proxy == null); // Default of handler.Proxy is null.
 
@@ -1671,6 +1681,8 @@ private static HttpClient CreateHttpClient(HttpClientParameters parameters, Http
 
                     try
                     {
+                        //Start dns resolve
+                        IPAddress[] addresses = await Dns.GetHostAddressesAsync(context.DnsEndPoint.Host, cancellationToken).ConfigureAwait(false);
                         if (parameters.ServicePoint is { } servicePoint)
                         {
                             if (servicePoint.ReceiveBufferSize != -1)
@@ -1684,19 +1696,54 @@ private static HttpClient CreateHttpClient(HttpClientParameters parameters, Http
                                 socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveTime, keepAlive.Time);
                                 socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveInterval, keepAlive.Interval);
                             }
-                        }
 
-                        socket.NoDelay = true;
+                            if (servicePoint.BindIPEndPointDelegate != null)
+                            {
+                                var bindHelper = () =>
+                                {
+                                    const int MaxRetries = 100;
+                                    foreach (IPAddress address in addresses)
+                                    {
+                                        int retryCount = 0;
+                                        for (; retryCount < MaxRetries; retryCount++)
+                                        {
+                                            IPEndPoint? endPoint = servicePoint.BindIPEndPointDelegate(servicePoint, new IPEndPoint(address, context.DnsEndPoint.Port), retryCount);
+                                            if (endPoint == null) // Get other address to try
+                                            {
+                                                break;
+                                            }
+                                            try
+                                            {
+                                                socket.Bind(endPoint);
+                                                return; // Bind successful, exit loops.
+                                            }
+                                            catch
+                                            {
+                                                continue;
+                                            }
+                                        }
+
+                                        if (retryCount >= MaxRetries)
+                                        {
+                                            throw new OverflowException(); //TODO (aaksoy): Add SR for this.
+                                        }
+                                    }
+                                };
+                                bindHelper();
+                            }
+
+                            socket.NoDelay = !servicePoint.UseNagleAlgorithm;
+                        }
 
                         if (parameters.Async)
                         {
-                            await socket.ConnectAsync(context.DnsEndPoint, cancellationToken).ConfigureAwait(false);
+                            await socket.ConnectAsync(addresses, context.DnsEndPoint.Port, cancellationToken).ConfigureAwait(false);
                         }
                         else
                         {
                             using (cancellationToken.UnsafeRegister(s => ((Socket)s!).Dispose(), socket))
                             {
-                                socket.Connect(context.DnsEndPoint);
+                                socket.Connect(addresses, context.DnsEndPoint.Port);
                             }
 
                             // Throw in case cancellation caused the socket to be disposed after the Connect completed

src/libraries/System.Net.Requests/src/System/Net/HttpWebResponse.cs

@@ -25,6 +25,7 @@ public class HttpWebResponse : WebResponse, ISerializable
         private WebHeaderCollection? _webHeaderCollection;
         private string? _characterSet;
         private readonly bool _isVersionHttp11 = true;
+        private readonly int _maxErrorResponseLength = -1;
 
         [Obsolete("This API supports the .NET infrastructure and is not intended to be used directly from your code.", true)]
         [EditorBrowsable(EditorBrowsableState.Never)]
@@ -53,10 +54,11 @@ protected override void GetObjectData(SerializationInfo serializationInfo, Strea
             throw new PlatformNotSupportedException();
         }
 
-        internal HttpWebResponse(HttpResponseMessage _message, Uri requestUri, CookieContainer? cookieContainer)
+        internal HttpWebResponse(HttpResponseMessage _message, Uri requestUri, CookieContainer? cookieContainer, int maxErrorResponseLength)
         {
             _httpResponseMessage = _message;
             _requestUri = requestUri;
+            _maxErrorResponseLength = maxErrorResponseLength;
 
             // Match Desktop behavior. If the request didn't set a CookieContainer, we don't populate the response's CookieCollection.
             if (cookieContainer != null)
@@ -337,7 +339,35 @@ public override Stream GetResponseStream()
             CheckDisposed();
             if (_httpResponseMessage.Content != null)
             {
-                return _httpResponseMessage.Content.ReadAsStream();
+                Stream contentStream = _httpResponseMessage.Content.ReadAsStream();
+                if (_maxErrorResponseLength < 0 || StatusCode < HttpStatusCode.BadRequest)
+                {
+                    return contentStream;
+                }
+
+                MemoryStream memoryStream = new MemoryStream();
+                byte[] buffer = new byte[1024];
+                int readLength = 0;
+
+                while (readLength < _maxErrorResponseLength)
+                {
+                    int len = contentStream.Read(buffer, 0, Math.Min(_maxErrorResponseLength - readLength, buffer.Length));
+                    if (len == 0)
+                    {
+                        break;
+                    }
+                    memoryStream.Write(buffer, 0, len);
+                    readLength += len;
+                }
+                memoryStream.Seek(0, SeekOrigin.Begin);
+                try
+                {
+                    return memoryStream;
+                }
+                finally
+                {
+                    contentStream.Dispose();
+                }
             }
 
             return Stream.Null;

src/libraries/System.Net.Requests/src/System/Net/ServicePoint/ServicePoint.cs

@@ -16,6 +16,15 @@ public class ServicePoint
 
         internal TcpKeepAlive? KeepAlive { get; set; }
 
+        internal int CurrentAddressIndex { get; set; }
+
+        internal DateTime LastDnsResolve { get; set; }
+
+        internal bool NeedDnsResolve => LastDnsResolve
+            .CompareTo(DateTime.Now.AddMilliseconds(-ServicePointManager.DnsRefreshTimeout)) >= 0;
+
+        internal IPAddress[]? CachedAddresses { get; set; }
+
         internal ServicePoint(Uri address)
         {
             Debug.Assert(address != null);

src/libraries/System.Net.Requests/src/System/Net/ServicePoint/ServicePointManager.cs

@@ -78,7 +78,7 @@ public static int MaxServicePointIdleTime
             }
         }
 
-        public static bool UseNagleAlgorithm { get; set; } = true;
+        public static bool UseNagleAlgorithm { get; set; }
 
         public static bool Expect100Continue { get; set; } = true;
 

src/libraries/System.Net.Requests/tests/HttpWebRequestTest.cs

@@ -2167,6 +2167,96 @@ await server.AcceptConnectionAsync(
             );
         }
 
+        [Fact]
+        public async Task SendHttpRequest_WhenDefaultMaximumErrorResponseLengthSet_Success()
+        {
+            await LoopbackServer.CreateClientAndServerAsync(
+                async (uri) =>
+                {
+                    HttpWebRequest request = WebRequest.CreateHttp(uri);
+                    HttpWebRequest.DefaultMaximumErrorResponseLength = 5;
+                    var exception = await Assert.ThrowsAsync<WebException>(() => request.GetResponseAsync());
+                    using (var responseStream = exception.Response.GetResponseStream())
+                    {
+                        Assert.Equal(5, responseStream.Length);
+                        var buffer = new byte[10];
+                        int readLen = responseStream.Read(buffer, 0, buffer.Length);
+                        Assert.Equal(5, readLen);
+                        Assert.Equal(new string('a', 5), Encoding.UTF8.GetString(buffer[0..readLen]));
+                    }
+                },
+                async (server) =>
+                {
+                    await server.AcceptConnectionAsync(
+                        async (client) =>
+                        {
+                            await client.SendResponseAsync(statusCode: HttpStatusCode.InternalServerError, content: new string('a', 10));
+                        });
+                });
+        }
+
+        [Fact]
+        public void HttpWebRequest_SetProtocolVersion_Success()
+        {
+            HttpWebRequest request = WebRequest.CreateHttp(Configuration.Http.RemoteEchoServer);
+
+            request.ProtocolVersion = HttpVersion.Version10;
+            Assert.Equal(HttpVersion.Version10, request.ServicePoint.ProtocolVersion);
+
+            request.ProtocolVersion = HttpVersion.Version11;
+            Assert.Equal(HttpVersion.Version11, request.ServicePoint.ProtocolVersion);
+        }
+
+        [Fact]
+        public async Task SendHttpRequest_BindIPEndPoint_Success()
+        {
+            await LoopbackServer.CreateClientAndServerAsync(
+                async (uri) =>
+                {
+                    HttpWebRequest request = WebRequest.CreateHttp(uri);
+                    request.ServicePoint.BindIPEndPointDelegate =
+                        (sp, ep, retryCount) => { return new IPEndPoint(IPAddress.Loopback, 27277); };
+                    using (var response = (HttpWebResponse)await request.GetResponseAsync())
+                    {
+                        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+                    }
+                },
+                async (server) =>
+                {
+                    await server.AcceptConnectionAsync(
+                        async (client) =>
+                        {
+                            var ipEp = (IPEndPoint)client.Socket.RemoteEndPoint;
+                            Assert.Equal(27277, ipEp.Port);
+                            await client.SendResponseAsync();
+                        });
+                });
+        }
+
+        [Fact]
+        public async Task SendHttpRequest_BindIPEndPoint_Throws()
+        {
+            Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+            socket.Bind(new IPEndPoint(IPAddress.Loopback, 0));
+            await LoopbackServer.CreateClientAndServerAsync(
+                async (uri) =>
+                {
+                    HttpWebRequest request = WebRequest.CreateHttp(uri);
+                    request.ServicePoint.BindIPEndPointDelegate =
+                        (sp, ep, retryCount) => { return (IPEndPoint)socket.LocalEndPoint!; };
+                    var exception = await Assert.ThrowsAsync<WebException>(() => request.GetResponseAsync());
+                    Assert.IsType<OverflowException>(exception.InnerException?.InnerException);
+                },
+                async (server) =>
+                {
+                    await server.AcceptConnectionAsync(
+                        async (client) =>
+                        {
+                            await client.SendResponseAsync();
+                        });
+                });
+        }
+
         private void RequestStreamCallback(IAsyncResult asynchronousResult)
         {
             RequestState state = (RequestState)asynchronousResult.AsyncState;

src/libraries/System.Net.Requests/tests/ServicePointTests/ServicePointManagerTest.cs

@@ -181,7 +181,7 @@ public static void ServerCertificateValidationCallback_Roundtrips()
         [Fact]
         public static void UseNagleAlgorithm_Roundtrips()
         {
-            Assert.True(ServicePointManager.UseNagleAlgorithm);
+            Assert.False(ServicePointManager.UseNagleAlgorithm);
             try
             {
                 ServicePointManager.UseNagleAlgorithm = false;
@@ -325,7 +325,7 @@ public static void FindServicePoint_ReturnedServicePointMatchesExpectedValues()
                 Assert.Equal(new Version(1, 1), sp.ProtocolVersion);
                 Assert.Equal(-1, sp.ReceiveBufferSize);
                 Assert.True(sp.SupportsPipelining, "SupportsPipelining");
-                Assert.True(sp.UseNagleAlgorithm, "UseNagleAlgorithm");
+                Assert.False(sp.UseNagleAlgorithm, "UseNagleAlgorithm");
             }).Dispose();
         }