Add support for httpCookieFile

Author: miya789

src/shared/Core.Tests/HttpClientFactoryTests.cs

@@ -311,6 +311,36 @@ public void HttpClientFactory_GetClient_ChecksCertBundleOnlyIfEnabled(string cus
             fileSystemMock.Verify(fs => fs.FileExists(It.IsAny<string>()), expectBundleChecked ? Times.Once : Times.Never);
         }
 
+        [Theory]
+        [InlineData(null, false, null)]
+        [InlineData("~/.git-cookie", true, "# Netscape HTTP Cookie File\n" +
+                          "# https://curl.haxx.se/rfc/cookie_spec.html\n" +
+                          "# This is a generated file! Do not edit.\n" +
+                          "\n" +
+                          ".example.com\tTRUE\t/\tTRUE\t0\tcookie1\tvalue1\n" +
+                          ".example.com\tTRUE\t/\tTRUE\t0\tcookie2\tvalue2\n" +
+                          "#HttpOnly_.example.com\tTRUE\t/\tTRUE\t0\tcookie3\tvalue3\n")]
+        public void HttpClientFactory_GetClient_SetCookieOnlyIfEnabled(string cookieFilePath, bool expectCookieChecked, string cookieFileContent)
+        {
+            var fileSystemMock = new Mock<IFileSystem>();
+            fileSystemMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+            if (!string.IsNullOrWhiteSpace(cookieFileContent))
+            {
+                fileSystemMock.Setup(fs => fs.ReadAllText(cookieFilePath)).Returns(cookieFileContent);
+            }
+
+            var settings = new TestSettings()
+            {
+                CustomCookieFilePath = cookieFilePath
+            };
+
+            var factory = new HttpClientFactory(fileSystemMock.Object, Mock.Of<ITrace>(), Mock.Of<ITrace2>(), settings, new TestStandardStreams());
+
+            HttpClient client = factory.CreateClient();
+
+            fileSystemMock.Verify(fs => fs.FileExists(It.IsAny<string>()), expectCookieChecked ? Times.AtLeastOnce : Times.Never);
+        }
+
         private static void AssertDefaultCredentials(ICredentials credentials)
         {
             var netCred = (NetworkCredential) credentials;

src/shared/Core/Constants.cs

@@ -171,6 +171,7 @@ public static class Http
                 public const string SslVerify = "sslVerify";
                 public const string SslCaInfo = "sslCAInfo";
                 public const string SslAutoClientCert = "sslAutoClientCert";
+                public const string CookieFile = "cookieFile";
             }
 
             public static class Remote

src/shared/Core/HttpClientFactory.cs

@@ -197,6 +197,40 @@ public HttpClient CreateClient()
 #endif
             }
 
+            _trace.WriteLine($"Custom cookie file has been enabled with {_settings.CustomCookieFilePath}");
+            // If IsUsingCookieEnabled is enabled, set Cookie header from cookie file, which is written by libcurl
+            if (!string.IsNullOrWhiteSpace(_settings.CustomCookieFilePath))
+            {
+                // get the filename from gitconfig
+                string cookieFilePath = _settings.CustomCookieFilePath;
+                _trace.WriteLine($"Custom cookie file has been enabled with {cookieFilePath}");
+                
+                // Throw exception if cookie file not found
+                if (!_fileSystem.FileExists(cookieFilePath) || string.IsNullOrEmpty(_fileSystem.ReadAllText(cookieFilePath)))
+                {
+                    var format = "Custom cookie file not found at path: {0}";
+                    var message = string.Format(format, cookieFilePath);
+                    throw new Trace2FileNotFoundException(_trace2, message, format, cookieFilePath);
+                }
+
+                // get cookie from cookie file
+                var cookieParser = new CurlCookieParser(_trace);
+                var cookies = cookieParser.Parse(_fileSystem.ReadAllText(cookieFilePath));
+
+                // Set the cookie
+                var cookieContainer = new CookieContainer();
+                foreach (var cookie in cookies)
+                {
+                    var schema = cookie.Secure ? "https" : "http";
+                    var uri = new UriBuilder(schema, cookie.Domain).Uri;
+                    cookieContainer.Add(uri, new Cookie(cookie.Name, cookie.Value));
+                }
+                handler.CookieContainer = cookieContainer;
+                
+                _trace.WriteLine("Configured to automatically send cookie header.");
+
+            }
+
             var client = new HttpClient(handler);
 
             // Add default headers
@@ -301,5 +335,68 @@ public bool TryCreateProxy(out IWebProxy proxy)
             proxy = null;
             return false;
         }
+
+        public class CurlCookieParser
+        {
+            private readonly ITrace _trace;
+
+            public CurlCookieParser(ITrace trace)
+            {
+                _trace = trace;
+            }
+
+            public IList<Cookie> Parse(string content)
+            {
+                var cookies = new List<Cookie>();
+
+                // Parse the cookie file content
+                var lines = content.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
+                for (int i = 3; i < lines.Length; i++)
+                {
+                    var parts = lines[i].Split(new[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
+                    if (parts.Length >= 7)
+                    {
+                        var domain = parts[0];
+                        domain = domain.StartsWith("#HttpOnly_") ? parts[0].Substring("#HttpOnly_".Length) : parts[0];
+                        domain = domain.TrimStart('.');
+                        var includeSubdomains = parts[1] == "TRUE";
+                        var path = parts[2];
+                        var secureOnly = parts[3] == "TRUE";
+                        var expires = parts[4];
+                        var name = parts[5];
+                        var value = parts[6];
+
+                        cookies.Add(new Cookie(name, value, path, domain)
+                        {
+                            Expires = ParseExpires(expires),
+                            Secure = secureOnly,
+                            HttpOnly = true
+                        });
+                    }
+                    else
+                    {
+                        _trace.WriteLine($"Invalid cookie line: {lines[i]}");
+                    }
+                }
+
+                return cookies;
+            }
+
+            private static DateTime ParseExpires(string expires)
+            {
+                if (expires.Equals("0", StringComparison.OrdinalIgnoreCase))
+                {
+                    return DateTime.MinValue;
+                }
+                else if (DateTime.TryParse(expires, out var result))
+                {
+                    return result;
+                }
+                else
+                {
+                    return DateTime.MaxValue;
+                }
+            }
+        }
     }
 }

src/shared/Core/Settings.cs

@@ -154,6 +154,12 @@ public interface ISettings : IDisposable
         /// <remarks>The default value is null if unset.</remarks>
         string CustomCertificateBundlePath { get; }
 
+        /// <summary>
+        // Optional path to a file containing one or more cookies.
+        /// </summary>
+        /// <remarks>The default value is null if unset.</remarks>
+        string CustomCookieFilePath { get; }
+
         /// <summary>
         /// The SSL/TLS backend.
         /// </summary>
@@ -625,6 +631,9 @@ public bool IsCertificateVerificationEnabled
         public string CustomCertificateBundlePath =>
             TryGetPathSetting(KnownEnvars.GitSslCaInfo, KnownGitCfg.Http.SectionName, KnownGitCfg.Http.SslCaInfo, out string value) ? value : null;
 
+        public string CustomCookieFilePath =>
+            TryGetPathSetting(null, KnownGitCfg.Http.SectionName, KnownGitCfg.Http.CookieFile, out string value) ? value : null;
+
         public TlsBackend TlsBackend =>
             TryGetSetting(null, KnownGitCfg.Http.SectionName, KnownGitCfg.Http.SslBackend, out string config)
                 ? (Enum.TryParse(config, true, out TlsBackend backend) ? backend : GitCredentialManager.TlsBackend.Other)

src/shared/TestInfrastructure/Objects/TestSettings.cs

@@ -43,6 +43,8 @@ public class TestSettings : ISettings
 
         public string CustomCertificateBundlePath { get; set; }
 
+        public string CustomCookieFilePath { get; set; }
+
         public TlsBackend TlsBackend { get; set; }
 
         public bool UseCustomCertificateBundleWithSchannel { get; set; }
@@ -171,6 +173,8 @@ ProxyConfiguration ISettings.GetProxyConfiguration()
 
         string ISettings.CustomCertificateBundlePath => CustomCertificateBundlePath;
 
+        string ISettings.CustomCookieFilePath => CustomCookieFilePath;
+
         TlsBackend ISettings.TlsBackend => TlsBackend;
 
         bool ISettings.UseCustomCertificateBundleWithSchannel => UseCustomCertificateBundleWithSchannel;