/// <devdoc>
/// <para>
/// Causes an abort of any aborted requests waiting in the ConnectionGroup
/// </para>
/// </devdoc>
private bool Abort(HttpWebRequest request, WebException webException)
{
lock (m_ConnectionList)
{
AsyncWaitHandle.Set();
}
return(true);
}
/// <devdoc>
/// <para>
/// Called when a connection is idle and ready to process new requests
/// </para>
/// </devdoc>
internal void ConnectionGoneIdle()
{
if (m_AuthenticationGroup)
{
lock (m_ConnectionList) {
AsyncWaitHandle.Set();
}
}
}
/// <devdoc>
/// <para>
/// Called when a connection is idle and ready to process new requests
/// </para>
/// </devdoc>
internal void ConnectionGoneIdle()
{
if (m_AuthenticationGroup)
{
lock (m_ConnectionList) {
GlobalLog.Print("ConnectionGroup::ConnectionGoneIdle() setting the event");
AsyncWaitHandle.Set();
}
}
}
protected internal void Complete(Exception ex)
{
// Ensure we only complete once - Needed because in encryption there could be
// both a pending send and pending receive so if there is an error, both will
// attempt to complete the encryption handshake meaning this is called twice.
if (IsCompleted)
{
return;
}
SavedException = ex;
CompletedSynchronously = false;
IsCompleted = true;
AsyncWaitHandle.Set();
Callback?.Invoke(this);
}
/// <devdoc>
/// <para>
/// Used by the ServicePoint to find a free or new Connection
/// for use in making Requests, this is done with the cavet,
/// that once a Connection is "locked" it can only be used
/// by a specific request.
///
/// NOTE: For Whidbey: try to integrate this code into FindConnection()
/// </para>
/// </devdoc>
private Connection FindConnectionAuthenticationGroup(HttpWebRequest request, string connName)
{
Connection leastBusyConnection = null;
GlobalLog.Print("ConnectionGroup::FindConnectionAuthenticationGroup [" + connName + "] for request#" + request.GetHashCode() + ", m_ConnectionList.Count:" + m_ConnectionList.Count.ToString());
//
// First try and find a free Connection (i.e. one not busy with Authentication handshake)
// or try to find a Request that has already locked a specific Connection,
// if a matching Connection is found, then we're done
//
lock (m_ConnectionList) {
Connection matchingConnection;
matchingConnection = FindMatchingConnection(request, connName, out leastBusyConnection);
if (matchingConnection != null)
{
matchingConnection.MarkAsReserved();
return(matchingConnection);
}
if (AuthenticationRequestQueue.Count == 0)
{
if (leastBusyConnection != null)
{
if (request.LockConnection)
{
m_NtlmNegGroup = true;
m_IISVersion = leastBusyConnection.IISVersion;
}
if (request.LockConnection || (m_NtlmNegGroup && !request.Pipelined && request.UnsafeOrProxyAuthenticatedConnectionSharing && m_IISVersion >= 6))
{
GlobalLog.Print("Assigning New Locked Request#" + request.GetHashCode().ToString());
leastBusyConnection.LockedRequest = request;
}
leastBusyConnection.MarkAsReserved();
return(leastBusyConnection);
}
}
else if (leastBusyConnection != null)
{
AsyncWaitHandle.Set();
}
AuthenticationRequestQueue.Enqueue(request);
}
//
// If all the Connections are busy, then we queue ourselves and need to wait. As soon as
// one of the Connections are free, we grab the lock, and see if we find ourselves
// at the head of the queue. If not, we loop backaround.
// Care is taken to examine the request when we wakeup, in case the request is aborted.
//
while (true)
{
GlobalLog.Print("waiting");
request.AbortDelegate = m_AbortDelegate;
if (!request.Aborted)
{
AsyncWaitHandle.WaitOne();
}
GlobalLog.Print("wait up");
lock (m_ConnectionList) {
if (request.Aborted)
{
PruneAbortedRequests();
// Note that request is not on any connection and it will not be submitted
return(null);
}
FindMatchingConnection(request, connName, out leastBusyConnection);
if (AuthenticationRequestQueue.Peek() == request)
{
GlobalLog.Print("dequeue");
AuthenticationRequestQueue.Dequeue();
if (leastBusyConnection != null)
{
if (request.LockConnection)
{
m_NtlmNegGroup = true;
m_IISVersion = leastBusyConnection.IISVersion;
}
if (request.LockConnection || (m_NtlmNegGroup && !request.Pipelined && request.UnsafeOrProxyAuthenticatedConnectionSharing && m_IISVersion >= 6))
{
leastBusyConnection.LockedRequest = request;
}
leastBusyConnection.MarkAsReserved();
return(leastBusyConnection);
}
AuthenticationRequestQueue.Enqueue(request);
}
if (leastBusyConnection == null)
{
AsyncWaitHandle.Reset();
}
}
}
}
/// <devdoc>
/// <para>
/// Used by the ServicePoint to find a free or new Connection
/// for use in making Requests, this is done with the cavet,
/// that once a Connection is "locked" it can only be used
/// by a specific request.
///
/// NOTE: For Whidbey: try to integrate this code into FindConnection()
/// </para>
/// </devdoc>
private Connection FindConnectionAuthenticationGroup(HttpWebRequest request, string connName)
{
Connection leastBusyConnection = null;
GlobalLog.Print("ConnectionGroup::FindConnectionAuthenticationGroup [" + connName + "] m_ConnectionList.Count:" + m_ConnectionList.Count.ToString());
//
// First try and find a free Connection (i.e. one not busy with Authentication handshake)
// or try to find a Request that has already locked a specific Connection,
// if a matching Connection is found, then we're done
//
lock (m_ConnectionList) {
Connection matchingConnection;
matchingConnection = FindMatchingConnection(request, connName, out leastBusyConnection);
if (matchingConnection != null)
{
return(matchingConnection);
}
if (AuthenticationRequestQueue.Count == 0)
{
if (leastBusyConnection != null)
{
if (request.LockConnection)
{
GlobalLog.Print("Assigning New Locked Request#" + request.GetHashCode().ToString());
leastBusyConnection.LockedRequest = request;
}
return(leastBusyConnection);
}
}
else if (leastBusyConnection != null)
{
AsyncWaitHandle.Set();
}
AuthenticationRequestQueue.Enqueue(request);
}
//
// If all the Connections are busy, then we queue ourselves and need to wait. As soon as
// one of the Connections are free, we grab the lock, and see if we find ourselves
// at the head of the queue. If not, we loop backaround.
// Care is taken to examine the request when we wakeup, in case the request is aborted.
//
while (true)
{
GlobalLog.Print("waiting");
request.AbortDelegate = m_AbortDelegate;
AsyncWaitHandle.WaitOne();
GlobalLog.Print("wait up");
lock (m_ConnectionList) {
if (m_Abort)
{
PruneAbortedRequests();
}
if (request.Aborted)
{
throw new WebException(
NetRes.GetWebStatusString("net_requestaborted", WebExceptionStatus.RequestCanceled),
WebExceptionStatus.RequestCanceled);
}
FindMatchingConnection(request, connName, out leastBusyConnection);
if (AuthenticationRequestQueue.Peek() == request)
{
GlobalLog.Print("dequeue");
AuthenticationRequestQueue.Dequeue();
if (leastBusyConnection != null)
{
if (request.LockConnection)
{
leastBusyConnection.LockedRequest = request;
}
return(leastBusyConnection);
}
AuthenticationRequestQueue.Enqueue(request);
}
if (leastBusyConnection == null)
{
AsyncWaitHandle.Reset();
}
}
}
}