Merge pull request #2557 from kapilash/proxy

HttpClient via libcurl : proxy support

Author: stephentoub

src/Common/src/Interop/Unix/libcurl/Interop.libcurl_types.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+
 internal static partial class Interop
 {
     internal static partial class libcurl
@@ -12,8 +14,14 @@ internal static partial class CURLoption
             private const int CurlOptionLongBase = 0;
             private const int CurlOptionObjectPointBase = 10000;
 
-            internal const int CURLOPT_FOLLOWLOCATION = CurlOptionLongBase + 52;
             internal const int CURLOPT_URL = CurlOptionObjectPointBase + 2;
+            internal const int CURLOPT_FOLLOWLOCATION = CurlOptionLongBase + 52;
+            internal const int CURLOPT_PROXYPORT = CurlOptionLongBase + 59;
+            internal const int CURLOPT_PROXYTYPE = CurlOptionLongBase + 101;
+
+            internal const int CURLOPT_WRITEDATA = CurlOptionObjectPointBase + 1;
+            internal const int CURLOPT_PROXY = CurlOptionObjectPointBase + 4;
+            internal const int CURLOPT_PROXYUSERPWD = CurlOptionObjectPointBase + 6;
         }
 
         // Class for constants defined for the enum CURLINFO in curl.h
@@ -24,6 +32,12 @@ internal static partial class CURLINFO
             internal const int CURLINFO_RESPONSE_CODE = CurlInfoLongBase + 2;
         }
 
+        // Class for constants defined for the enum curl_proxytype in curl.h
+        internal static partial class curl_proxytype
+        {
+            internal const int CURLPROXY_HTTP = 0;
+        }
+
         // Class for constants defined for the enum CURLcode in curl.h
         internal static partial class CURLcode
         {

src/System.Net.Http/src/System/Net/Http/Unix/CurlHandler.cs

@@ -12,6 +12,7 @@
 using CURLoption = Interop.libcurl.CURLoption;
 using CURLcode = Interop.libcurl.CURLcode;
 using CURLINFO = Interop.libcurl.CURLINFO;
+using CURLProxyType = Interop.libcurl.curl_proxytype;
 
 namespace System.Net.Http
 {
@@ -20,14 +21,17 @@ internal class CurlHandler : HttpMessageHandler
         #region Constants
 
         private const string UriSchemeHttps = "https";
-
+        private readonly static string[] AuthenticationSchemes = { "Negotiate", "Digest", "Basic" }; // the order in which libcurl goes over authentication schemes
         #endregion
 
         #region Fields
 
         private volatile bool _anyOperationStarted;
         private volatile bool _disposed;
         private bool _automaticRedirection = true;
+        private IWebProxy _proxy = null;
+        private ICredentials _serverCredentials = null;
+        private ProxyUsePolicy _proxyPolicy = ProxyUsePolicy.UseDefaultProxy;
 
         #endregion
 
@@ -50,6 +54,59 @@ internal bool AutomaticRedirection
             }
         }
 
+        internal bool SupportsProxy
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        internal bool UseProxy
+        {
+            get
+            {
+                return _proxyPolicy != ProxyUsePolicy.DoNotUseProxy;
+            }
+            set
+            {
+                CheckDisposedOrStarted();
+                if (value)
+                {
+                    _proxyPolicy = ProxyUsePolicy.UseCustomProxy;
+                }
+                else
+                {
+                    _proxyPolicy = ProxyUsePolicy.DoNotUseProxy;
+                }
+            }
+        }
+
+        internal IWebProxy Proxy
+        {
+            get
+            {
+                return _proxy;
+            }
+            set
+            {
+                CheckDisposedOrStarted();
+                _proxy = value;
+            }
+        }
+        
+        internal ICredentials Credentials
+        {
+            get
+            {
+                return _serverCredentials;
+            }
+            set
+            {
+                CheckDisposedOrStarted();
+                _serverCredentials = value;
+            }
+        }
         #endregion
 
         protected override void Dispose(bool disposing)
@@ -175,11 +232,83 @@ private SafeCurlHandle CreateRequestHandle(RequestCompletionSource state)
                 Interop.libcurl.curl_easy_setopt(requestHandle, CURLoption.CURLOPT_FOLLOWLOCATION, 1);
             }
 
-            // TODO: Handle headers, proxy and other options
+            SetProxyOptions(state, requestHandle);
+            // TODO: Handle headers and other options
 
             return requestHandle;
         }
 
+        private static void SetProxyOptions(RequestCompletionSource state, SafeCurlHandle requestHandle)
+        {
+            var requestUri = state.RequestMessage.RequestUri;
+            Debug.Assert(state.Handler != null);
+            if (state.Handler._proxyPolicy == ProxyUsePolicy.DoNotUseProxy)
+            {
+                Interop.libcurl.curl_easy_setopt(requestHandle, CURLoption.CURLOPT_PROXY, string.Empty);
+                return;
+            }
+
+            if ((state.Handler._proxyPolicy == ProxyUsePolicy.UseDefaultProxy) || (state.Handler.Proxy == null))
+            {
+                return;
+            }
+
+            Debug.Assert( (state.Handler.Proxy != null) && (state.Handler._proxyPolicy == ProxyUsePolicy.UseCustomProxy));
+            if (state.Handler.Proxy.IsBypassed(requestUri))
+            {
+                Interop.libcurl.curl_easy_setopt(requestHandle, CURLoption.CURLOPT_PROXY, string.Empty);
+                return;
+            }
+
+            var proxyUri = state.Handler.Proxy.GetProxy(requestUri);
+            if (proxyUri == null)
+            {
+                return;
+            }
+
+            Interop.libcurl.curl_easy_setopt(requestHandle, CURLoption.CURLOPT_PROXYTYPE, CURLProxyType.CURLPROXY_HTTP);
+            Interop.libcurl.curl_easy_setopt(requestHandle, CURLoption.CURLOPT_PROXY, proxyUri.AbsoluteUri);
+            Interop.libcurl.curl_easy_setopt(requestHandle, CURLoption.CURLOPT_PROXYPORT, proxyUri.Port);
+            NetworkCredential credentials = GetCredentials(state.Handler.Proxy.Credentials, requestUri);
+            if (credentials != null)
+            {
+                if (string.IsNullOrEmpty(credentials.UserName))
+                {
+                    throw new ArgumentException(SR.net_http_argument_empty_string, "UserName");
+                }
+
+                string credentialText;
+                if (string.IsNullOrEmpty(credentials.Domain))
+                {
+                    credentialText = string.Format("{0}:{1}", credentials.UserName, credentials.Password);
+                }
+                else
+                {
+                    credentialText = string.Format("{2}\\{0}:{1}", credentials.UserName, credentials.Password, credentials.Domain);
+                }
+                Interop.libcurl.curl_easy_setopt(requestHandle, CURLoption.CURLOPT_PROXYUSERPWD, credentialText);
+            }
+        }
+
+        private static NetworkCredential GetCredentials(ICredentials proxyCredentials, Uri requestUri)
+        {
+            if (proxyCredentials == null)
+            {
+                return null;
+            }
+
+            foreach (var authScheme in AuthenticationSchemes)
+            {
+                NetworkCredential proxyCreds = proxyCredentials.GetCredential(requestUri, authScheme);
+                if (proxyCreds != null)
+                {
+                    return proxyCreds;
+                }
+            }
+
+            return null;
+        }
+
         private HttpResponseMessage CreateResponseMessage(SafeCurlHandle requestHandle, HttpRequestMessage request)
         {
             var response = new HttpResponseMessage();
@@ -190,7 +319,7 @@ private HttpResponseMessage CreateResponseMessage(SafeCurlHandle requestHandle,
             {
                 throw new HttpRequestException(SR.net_http_client_execution_error, GetCurlException(result));
             }
-            response.StatusCode = (HttpStatusCode) httpStatusCode;
+            response.StatusCode = (HttpStatusCode)httpStatusCode;
 
             // TODO: Do error processing if needed and return actual response
             response.Content =
@@ -255,5 +384,13 @@ private sealed class RequestCompletionSource : TaskCompletionSource<HttpResponse
 
             public CurlHandler Handler { get; set; }
         }
+
+        private enum ProxyUsePolicy
+        {
+            DoNotUseProxy = 0, // Do not use proxy. Ignores the value set in the environment.
+            UseDefaultProxy = 1, // Do not set the proxy parameter. Use the value of environment variable, if any.
+            UseCustomProxy = 2  // Use The proxy specified by the user.
+        }
     }
 }
+

src/System.Net.Http/src/System/Net/Http/Unix/HttpClientHandler.Unix.cs

@@ -17,7 +17,7 @@ public virtual bool SupportsAutomaticDecompression
 
         public virtual bool SupportsProxy
         {
-            get { throw NotImplemented.ByDesignWithMessage("HTTP stack not implemented"); }
+            get { return this._curlHandler.SupportsProxy; }
         }
 
         public virtual bool SupportsRedirectConfiguration
@@ -51,14 +51,14 @@ public DecompressionMethods AutomaticDecompression
 
         public bool UseProxy
         {
-            get { throw NotImplemented.ByDesignWithMessage("HTTP stack not implemented"); }
-            set { throw NotImplemented.ByDesignWithMessage("HTTP stack not implemented"); }
+            get { return this._curlHandler.UseProxy; }
+            set { this._curlHandler.UseProxy = value; }
         }
 
         public IWebProxy Proxy
         {
-            get { throw NotImplemented.ByDesignWithMessage("HTTP stack not implemented"); }
-            set { throw NotImplemented.ByDesignWithMessage("HTTP stack not implemented"); }
+            get { return this._curlHandler.Proxy; }
+            set { this._curlHandler.Proxy = value; }
         }
 
         public bool PreAuthenticate
@@ -75,8 +75,8 @@ public bool UseDefaultCredentials
 
         public ICredentials Credentials
         {
-            get { throw NotImplemented.ByDesignWithMessage("HTTP stack not implemented"); }
-            set { throw NotImplemented.ByDesignWithMessage("HTTP stack not implemented"); }
+            get { return this._curlHandler.Credentials; }
+            set { this._curlHandler.Credentials = value; }
         }
 
         public bool AllowAutoRedirect