HttpClient should not miss Set-Cookie response headers

Recent changes due to PR dotnet#3199 caused `HttpClient` on Windows to miss
`Set-Cookie` response headers when one of the header values was large
enough to cause `WinHttpQueryHeaders` to fail with
`ERROR_INSUFFICIENT_BUFFER` and advance the index.

This commit addresses the regression, by always setting the index
back to the index we want to retrieve.

Added a new test to validate this change.

Fixes #6737.

Author: justinvp

src/System.Net.Http.WinHttpHandler/src/System/Net/Http/WinHttpResponseParser.cs

@@ -132,6 +132,7 @@ public unsafe static bool GetResponseHeader(
             Debug.Assert(buffer == null || (buffer != null && buffer.Length > StackLimit));
 
             int bufferLength;
+            uint originalIndex = index;
 
             if (buffer == null)
             {
@@ -166,6 +167,11 @@ public unsafe static bool GetResponseHeader(
 
             if (lastError == Interop.WinHttp.ERROR_INSUFFICIENT_BUFFER)
             {
+                // WinHttpQueryHeaders may advance the index even when it fails due to insufficient buffer,
+                // so we set the index back to its original value so we can try to retrieve the same
+                // index again with a larger buffer.
+                index = originalIndex;
+
                 buffer = new char[bufferLength];
                 return GetResponseHeader(requestHandle, infoLevel, ref buffer, ref index, out headerValue);
             }

src/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.cs

@@ -2,11 +2,10 @@
 // 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.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.IO;
-using System.Net.Http.Headers;
 using System.Net.Test.Common;
 using System.Security.Authentication.ExtendedProtection;
 using System.Text;
@@ -465,6 +464,65 @@ public async Task GetAsync_RequestHeadersAddCustomHeaders_HeaderAndValueSent(str
             }
         }
 
+        private static KeyValuePair<string, string> GenerateCookie(string name, char repeat, int overallHeaderValueLength)
+        {
+            string emptyHeaderValue = $"{name}=; Path=/";
+
+            Debug.Assert(overallHeaderValueLength > emptyHeaderValue.Length);
+
+            int valueCount = overallHeaderValueLength - emptyHeaderValue.Length;
+            string value = new string(repeat, valueCount);
+
+            return new KeyValuePair<string, string>(name, value);
+        }
+
+        public static object[][] CookieNameValues =
+        {
+            new object[] { GenerateCookie(name: "foo", repeat: 'a', overallHeaderValueLength: 254) },
+            new object[] { GenerateCookie(name: "foo", repeat: 'a', overallHeaderValueLength: 255) },
+            new object[] { GenerateCookie(name: "foo", repeat: 'a', overallHeaderValueLength: 256) },
+            new object[] { GenerateCookie(name: "foo", repeat: 'a', overallHeaderValueLength: 257) },
+            new object[]
+            {
+                new KeyValuePair<string, string>(
+                    ".AspNetCore.Antiforgery.Xam7_OeLcN4",
+                    "CfDJ8NGNxAt7CbdClq3UJ8_6w_4661wRQZT1aDtUOIUKshbcV4P0NdS8klCL5qGSN-PNBBV7w23G6MYpQ81t0PMmzIN4O04fqhZ0u1YPv66mixtkX3iTi291DgwT3o5kozfQhe08-RAExEmXpoCbueP_QYM")
+            }
+        };
+
+        [Theory]
+        [MemberData(nameof(CookieNameValues))]
+        public async Task GetAsync_ResponseWithSetCookieHeaders_AllCookiesRead(KeyValuePair<string, string> cookie1)
+        {
+            var cookie2 = new KeyValuePair<string, string>(".AspNetCore.Session", "RAExEmXpoCbueP_QYM");
+            var cookie3 = new KeyValuePair<string, string>("name", "value");
+
+            string url = string.Format(
+                "http://httpbin.org/cookies/set?{0}={1}&{2}={3}&{4}={5}",
+                cookie1.Key,
+                cookie1.Value,
+                cookie2.Key,
+                cookie2.Value,
+                cookie3.Key,
+                cookie3.Value);
+
+            var handler = new HttpClientHandler()
+            {
+                AllowAutoRedirect = false
+            };
+
+            using (var client = new HttpClient(handler))
+            using (HttpResponseMessage response = await client.GetAsync(url))
+            {
+                CookieCollection cookies = handler.CookieContainer.GetCookies(new Uri(url));
+
+                Assert.Equal(3, handler.CookieContainer.Count);
+                Assert.Equal(cookie1.Value, cookies[cookie1.Key].Value);
+                Assert.Equal(cookie2.Value, cookies[cookie2.Key].Value);
+                Assert.Equal(cookie3.Value, cookies[cookie3.Key].Value);
+            }
+        }
+
         [Fact]
         public async Task GetAsync_ResponseHeadersRead_ReadFromEachIterativelyDoesntDeadlock()
         {