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.
 
@@ -1669,6 +1679,9 @@ private static HttpClient CreateHttpClient(HttpClientParameters parameters, Http
                 {
                     var socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
 
+                    // Start resolve dns task
+                    Task<IPAddress[]> addressesTask = Dns.GetHostAddressesAsync(context.DnsEndPoint.Host, cancellationToken);
+                    IPAddress[]? addresses = null;
                     try
                     {
                         if (parameters.ServicePoint is { } servicePoint)
@@ -1684,19 +1697,54 @@ private static HttpClient CreateHttpClient(HttpClientParameters parameters, Http
                                 socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveTime, keepAlive.Time);
                                 socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveInterval, keepAlive.Interval);
                             }
+
+                            if (servicePoint.BindIPEndPointDelegate != null)
+                            {
+                                addresses ??= await addressesTask.ConfigureAwait(false);
+                                foreach (IPAddress address in addresses)
+                                {
+                                    int retryCount = 0;
+                                    for (; retryCount < int.MaxValue; retryCount++)
+                                    {
+                                        IPEndPoint? endPoint = servicePoint.BindIPEndPointDelegate(servicePoint, new IPEndPoint(address, context.DnsEndPoint.Port), retryCount);
+                                        if (endPoint != null)
+                                        {
+                                            try
+                                            {
+                                                socket.Bind(endPoint);
+                                                break;
+                                            }
+                                            catch
+                                            {
+                                                continue;
+                                            }
+                                        }
+                                    }
+
+                                    if (retryCount == int.MaxValue)
+                                    {
+                                        throw new OverflowException(); //TODO (aaksoy): Add SR for this.
+                                    }
+                                }
+                            }
+
+                            if (servicePoint.UseNagleAlgorithm is not true)
+                            {
+                                socket.NoDelay = true;
+                            }
                         }
 
-                        socket.NoDelay = true;
+                        addresses ??= await addressesTask.ConfigureAwait(false);
 
                         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,28 @@ public override Stream GetResponseStream()
             CheckDisposed();
             if (_httpResponseMessage.Content != null)
             {
-                return _httpResponseMessage.Content.ReadAsStream();
+                Stream contentStream = _httpResponseMessage.Content.ReadAsStream();
+                if (_maxErrorResponseLength == -1 || StatusCode <= (HttpStatusCode)399)
+                {
+                    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;
+                }
+
+                return memoryStream;
             }
 
             return Stream.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/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();
         }