When the TLS Handshake fails in `MonoTlsStream.CreateStream()`, then we must dispose
the `SslStream` to avoid a memory leak.
In addition to this, `MonoTlsStream` now implements `IDisposable` and is disposes
in `WebConnection.CloseSocket()`.
Fixes#8689
Fix a regression introduced in the new web stack - when connecting
to a DNS host name that resolves to multiple IP addresses, we need
to probe them all.
On iOS, "localhost" will resolve to both "::1" and "127.0.0.1".
Setting ReadTimeout in WebResponseStream.ctor throws System.Net.Sockets.SocketException : Invalid arguments on iOS.
Set it in WebConnection.InitConnection() immediately after establishing a connection, before we read/write anything.
* [System]: Fully stub-out SslStream on platforms where it's not supported.
* Remove 'SECURITY_DEP' conditional from LocalCertificateSelectionCallback.
* Add the internal delegates and remove 'SECURITY_DEP' from SslStream.platformnotsupported.cs.
* In SslStream.cs, we now provide the full API when '!SECURITY_DEP' using the
PlatformNotSupportedException()-based implementation from SslStream.platformnotsupported.cs
* [System]: Rename the internal class 'ChunkStream' into 'MonoChunkStream'.
Our 'ChunkStream' is used by 'WebConnection', so it will stay after using
HttpListener from corefx.
* [WebConnection] Make ReadDone and InitRead instance methods to avoid passing cnc around
* [WebConnection] Inline only call to InitConnection
* [WebConnection] Fix race condition between Close and BeginWrite
* Removed Mono.Security.Protocol.Tls.ValidationResult, use
Mono.Security.Interface instead. This is an API breaking
change, but you can fix your application by simply adding
the new using directive.
The rationale behind this is to avoid a dependency on the
Mono.Security.Protocol.Tls namespace when building and
related classes when building the new TLS stack.
* Enable ChainValidationHelper in WebConnection, LegacySslStream
and SslStream.
The custom conditionals that were previously required for the
mobile profiles are now gone as ChainValidationHelper already
handles that internally.
* This is an internal API, the public front-end is
Mono.Security.Interface.CertificateValidationHelper.
CertificateValidationHelper can be used to access the system
certificate validator on OS X and iOS; we do not compute the
X509Chain on these platforms as it's not supported by the OS.
(cherry picked from commit 9713f35878dd90fe87423b5052b4f82ddc0b87f0)
Make sure we always complete the async operations on error and
also send callbacks outside the lock.
(cherry picked from commit 9027f0ad28bf733ebb8ac9964c78c22853ca93c7)
When using "HTTP CONNECT" to create a tunnel to a proxy server,
check the proxy server's response for the HTTP Version and close
the connection if it's HTTP/1.0.
This patch builds upon commit 96a8500795 which placed parts of Mono.Security
responsible for dealing with SSL/TLS certificates for the purpose of certificate verification. The code enables
validation of the certifcates even if the user does not provide their own validation callback. The changes as related to
the original commit are few, basically consisting of enabling the same code used by MonoTouch in the MonoDroid context with
the only actual code change being the certificate validation bit mentioned above.
Since the change involves adding a subset of Mono.Security files to the monodroid version of System.dll, it is
also necessary to remove Mono.Android's dependence on Mono.Security.dll. The reason is that the code in AndroidPlatform
which looks up TLS support methods in Mono.Android.dll would use a type (X509CertificateCollection) that is now part of
System.dll but is *also* in Mono.Security.dll referenced by Mono.Android.dll and therefore the lookup would fail since
we'd have two distinct types from the reflection point of view.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=18962
* Merged WebConnection.EndWrite() and EndWrite2().
* WebConnectionStream.BeginWrite(): Use the same async-write
callback for both chunked and non-chunked; remove the single-use
small WriteRequestAsync() and inline it here to make the code
more readable.
* WebConnectionStream.WriteRequestAsyncCB(): Now called for all
async writes, call WebConnection.EndWrite() here.
The code is now more readable and easier to understand. This is
the first part of a series of cleanups, which should eventually
lead towards full async and 100-continue.
* ServicePoint now uses an idle timer to close idle connections.
* WebConnectionGroup has been mostly rewritten to use a linked
list of open connections and their idle times.
This fixes both the problem that we were leaking sockets and
that we were not reusing existing connections.
* ServicePoint now correctly keeps track of the number of open
connections.
* ServicePointManager now uses the correct default idle time
of 100 seconds (previously 15 minutes).
* WebConnection uses the new WebConnectionGroup's busy logic
to correctly flag connections as busy / reusable.
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=15857
Scenario (for which I couldn't easily create a testcase, but can
sketch out): Imagine using HttpClient...in a multithreaded manner:
// shared:
static CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource ();
// Thread 1
var request = new HttpRequestMessage(HttpMethod.Post, "https://www.google.com/") {
Content = new StringContent (new string('x', 1024)),
};
using (request)
using (HttpClient httpClient = new HttpClient())
using (HttpResponseMessage response = await httpClient.SendAsync(request,
_cancellationTokenSource.Token)) {
string responseContent = await response.Content.ReadAsStringAsync();
Console.WriteLine ("Read {0} chars", responseContent.Length);
}
// Thread 2
_cancellationTokenSource.Cancel ();
This isn't entirely farfetched; in the case of #15857, Thread 2 was
the Main thread (due to the user clicking a button), while Thread 1
was the ThreadPool (because of async/await).
The _occasional_ result: a TargetInvocationException exception:
System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. ---> System.NullReferenceException: Object reference not set to an instance of an object
at (wrapper delegate-invoke) <Module>:invoke_bool__this___HttpsClientStream (Mono.Security.Protocol.Tls.HttpsClientStream)
at System.Reflection.MonoProperty.GetterAdapterFrame[HttpsClientStream,Boolean] (System.Reflection.Getter`2 getter, System.Object obj)
at System.Reflection.MonoProperty.GetValue (System.Object obj, System.Object[] index)
--- End of inner exception stack trace ---
at System.Reflection.MonoProperty.GetValue (System.Object obj, System.Object[] index)
at System.Net.WebConnection.Write (System.Net.HttpWebRequest request, System.Byte[] buffer, Int32 offset, Int32 size, System.String& err_msg)
at System.Net.WebConnectionStream.WriteHeaders ()
at System.Net.WebConnectionStream.SetHeaders (System.Byte[] buffer)
at System.Net.HttpWebRequest.SendRequestHeaders (Boolean propagate_error)
--- End of stack trace from previous location where exception was thrown ---
at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw ()
at System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1+ConfiguredTaskAwaiter[System.Net.Http.HttpResponseMessage].GetResult ()
at System.Net.Http.HttpClient+<SendAsyncWorker>c__async0.MoveNext ()
--- End of stack trace from previous location where exception was thrown ---
at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw ()
at System.Runtime.CompilerServices.TaskAwaiter`1[System.Net.Http.HttpResponseMessage].GetResult ()
at HttpClientAsyncCancellationRepro.Activity1+<AccessGoogleButton_Click>c__async0.MoveNext ()
Huh?
The reason why is because HttpClientHandler.SendAsync() registers a
Cancel handler with the CancellationTokenSource, and the registered
handler calls HttpWebRequest.Abort() (which eventually calls
WebConnection.Close()). This causes WebConnection.nstream to _change_
while WebConnection.Write() is executing, causing
WebConnection.nstream to go from non-null to null, which
WebConnection.Write() does not expect:
# WebConnection.CreateStream; from 5 Threadpool worker
# WebConnection.Write; from 5 Threadpool worker
# WebConnection.Close; from 1 at at System.Environment.get_StackTrace()
at System.Net.WebConnection.Close(Boolean sendNext)
at System.Net.WebConnection.Abort(System.Object sender, System.EventArgs args)
at System.Net.WebConnection+AbortHelper.Abort(System.Object sender, System.EventArgs args)
at System.Net.HttpWebRequest.Abort()
at System.Net.Http.HttpClientHandler+<SendAsync>c__async0.<>m__0(System.Object l)
at System.Threading.CancellationToken+<Register>c__AnonStorey0.<>m__0()
at System.Threading.CancellationTokenSource.Cancel(Boolean throwOnFirstException)
at System.Threading.CancellationTokenSource.Cancel()
at System.Threading.CancellationTokenSource.SafeLinkedCancel()
at System.Threading.CancellationTokenSource.Cancel(Boolean throwOnFirstException)
at System.Threading.CancellationTokenSource.Cancel()
at HttpClientAsyncCancellationRepro.Activity1.CancelButton_Click(System.Object sender, System.EventArgs e)
at Android.Views.View+IOnClickListenerImplementor.OnClick(Android.Views.View v)
at Android.Views.View+IOnClickListenerInvoker.n_OnClick_Landroid_view_View_(IntPtr jnienv, IntPtr native__this, IntPtr native_v)
at System.Object.e7b5b870-ea0f-434f-bc31-984f665a44ad(IntPtr , IntPtr , IntPtr )
# WebConnection.Write: checking piTrustFailure; from 5 Threadpool worker
(Yay extra logging. Notice that WebConnection creates a stream from
the ThreadPool, starts WebConnection.Write(), then before it can se
piTrustFailure the instance is Close()d, which nulls out nstream.)
Since WebConnection.Write() attempts to access the (now null)
WebConnection.nstream field, it results in a NullReferenceException,
which is wrapped into a TargetInvocationException by
System.Reflection.
The fix? As usual, "don't do that."
In this case, WebConnection.Write() has already captured
WebConnection.nstream into the local variable `s` (which thus can't be
changed by another thread). Instead of using WebConnection.nstream,
reuse the `s` local variable, which cannot be null, thus avoiding the
NullReferenceException.
(This solution could fail if HttpsClientStream ever throws e.g.
ObjectDisposedException from HttpsClientStream.TrustFailure, but at
present HttpsClientStream.TrustFailure never throws, so this is fine.)
HttpWebRequest is a very tricky piece of code when it comes to its socket, this patch is more like a hack to get something working out of it but it's definitely not the best option.
This fixes #12355/#12395/#5904.
When EndRead() is called with a null "inner" IAsyncResult, then
we should not consider this as an end-of-stream condition.
This happens sometimes when using SSL and chunked encoding.
This reverts commit b190db44cb.
The reason is:
"The HttpWebRequests tests are not enough"
"A quick review of the code shows that the code is taking a lock, while
calling a function that retries connections (which in turn takes another
important lock --for the socket--) which might casue a stack overflow
if someone calls SetWriteStream"
"This also will make the opereation sync when calling Begin/End"
"Finally, this is a patch that improves the use of the threadpool, but
the threadpool still will end up exhausted"
Probably best to just increase the number of threads?