We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Net \ BufferChunkBytes

SSCLI

//------------------------------------------------------------------------------
// <copyright file="_Connection.cs" company="Microsoft">
//
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
// </copyright>
//------------------------------------------------------------------------------
namespace System.Net
{
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Security;
using System.Globalization;
using System.Net.Configuration;
internal enum ReadState
{
Start,
StatusLine,
// about to parse status line
Headers,
// reading headers
Data
// now read data
}
internal enum DataParseStatus
{
NeedMoreData = 0,
// need more data
ContinueParsing,
// continue parsing
Done,
// done
Invalid,
// bad data format
DataTooBig
// data exceeds the allowed size
}
internal enum WriteBufferState
{
Disabled,
Headers,
Buffer,
Playback
}
// The enum lietrals will be displayed to the user in the exception message
internal enum WebParseErrorSection
{
Generic,
ResponseHeader,
ResponseStatusLine,
ResponseBody
}
// The enum literal will be used to look up an error string in the resource file
internal enum WebParseErrorCode
{
Generic,
InvalidHeaderName,
InvalidContentLength,
IncompleteHeaderLine,
CrLfError,
InvalidChunkFormat,
UnexpectedServerResponse
}
// Only defined for DataParseStatus.Invalid
struct WebParseError
{
public WebParseErrorSection Section;
public WebParseErrorCode Code;
}
struct TunnelStateObject
{
internal TunnelStateObject(HttpWebRequest r, Connection c)
{
Connection = c;
OriginalRequest = r;
}
internal Connection Connection;
internal HttpWebRequest OriginalRequest;
}
/*++
BufferChunkBytes - A class to read a chunk stream from a buffer.
A simple little value class that implements the IReadChunkBytes
interface.
--*/
internal struct BufferChunkBytes : IReadChunkBytes
{
public byte[] Buffer;
public int Offset;
public int Count;
public int NextByte {
get {
if (Count != 0) {
Count--;
return (int)Buffer[Offset++];
}
return -1;
}
set {
Count++;
Offset--;
Buffer[Offset] = (byte)value;
}
}
}
//
// ConnectionReturnResult - used to spool requests that have been completed,
// and need to be notified.
//
internal class ConnectionReturnResult
{
private static readonly WaitCallback s_InvokeConnectionCallback = new WaitCallback(InvokeConnectionCallback);
private struct RequestContext
{
internal HttpWebRequest Request;
internal object CoreResponse;
internal RequestContext(HttpWebRequest request, object coreResponse)
{
Request = request;
CoreResponse = coreResponse;
}
}
private List<RequestContext> m_Context;
internal ConnectionReturnResult()
{
m_Context = new List<RequestContext>(5);
}
internal ConnectionReturnResult(int capacity)
{
m_Context = new List<RequestContext>(capacity);
}
internal bool IsNotEmpty {
get { return m_Context.Count != 0; }
}
static internal void Add(ref ConnectionReturnResult returnResult, HttpWebRequest request, CoreResponseData coreResponseData)
{
if (coreResponseData == null)
throw new InternalException();
//This may cause duplicate requests if we let it through in retail
if (returnResult == null) {
returnResult = new ConnectionReturnResult();
}
#if DEBUG
//This may cause duplicate requests if we let it through in retail but it's may be expensive to catch here
for (int j = 0; j < returnResult.m_Context.Count; ++j)
if ((object)returnResult.m_Context[j].Request == (object)request)
throw new InternalException();
#endif
returnResult.m_Context.Add(new RequestContext(request, coreResponseData));
}
static internal void AddExceptionRange(ref ConnectionReturnResult returnResult, HttpWebRequest[] requests, Exception exception)
{
AddExceptionRange(ref returnResult, requests, exception, exception);
}
static internal void AddExceptionRange(ref ConnectionReturnResult returnResult, HttpWebRequest[] requests, Exception exception, Exception firstRequestException)
{
//This may cause duplicate requests if we let it through in retail
if (exception == null)
throw new InternalException();
if (returnResult == null) {
returnResult = new ConnectionReturnResult(requests.Length);
}
// "abortedRequestExeption" is assigned to the "abortedRequest" or to the very first request if the latest is null
// Everyone else will get "exception"
for (int i = 0; i < requests.Length; ++i) {
#if DEBUG
//This may cause duplicate requests if we let it through in retail but it's may be expensive to catch here
for (int j = 0; j < returnResult.m_Context.Count; ++j)
if ((object)returnResult.m_Context[j].Request == (object)requests[i])
throw new InternalException();
#endif
if (i == 0)
returnResult.m_Context.Add(new RequestContext(requests[i], firstRequestException));
else
returnResult.m_Context.Add(new RequestContext(requests[i], exception));
}
}
static internal void SetResponses(ConnectionReturnResult returnResult)
{
if (returnResult == null) {
return;
}
GlobalLog.Print("ConnectionReturnResult#" + ValidationHelper.HashString(returnResult) + "::SetResponses() count=" + returnResult.m_Context.Count.ToString());
for (int i = 0; i < returnResult.m_Context.Count; i++) {
try {
HttpWebRequest request = returnResult.m_Context[i].Request;
#if DEBUG
CoreResponseData coreResponseData = returnResult.m_Context[i].CoreResponse as CoreResponseData;
if (coreResponseData == null)
GlobalLog.DebugRemoveRequest(request);
#endif
request.SetAndOrProcessResponse(returnResult.m_Context[i].CoreResponse);
}
catch (Exception e) {
//ASYNCISSUE
// on error, with more than one callback need to queue others off to another thread
GlobalLog.Print("ConnectionReturnResult#" + ValidationHelper.HashString(returnResult) + "::Exception" + e);
returnResult.m_Context.RemoveRange(0, (i + 1));
if (returnResult.m_Context.Count > 0) {
ThreadPool.UnsafeQueueUserWorkItem(s_InvokeConnectionCallback, returnResult);
}
throw;
}
}
returnResult.m_Context.Clear();
}
private static void InvokeConnectionCallback(object objectReturnResult)
{
ConnectionReturnResult returnResult = (ConnectionReturnResult)objectReturnResult;
SetResponses(returnResult);
}
}
//
// Connection - this is the Connection used to parse
// server responses, queue requests, and pipeline requests
//
internal class Connection : PooledStream
{
//
// thread statics - these values must be per thread, because
// other requests and operations can take place concurrently on this Connection.
// Our concern is to make sure that a nested call does not get confused with an
// operation on another thread. Parameter passing cannot be used, because
// the call stack may exit and then reenter the same Connection object.
//
[ThreadStatic()]
private static int t_SyncReadNesting;
private const int CRLFSize = 2;
private const long c_InvalidContentLength = -2l;
//
// Little status line holder.
//
private class StatusLineValues
{
internal int MajorVersion;
internal int MinorVersion;
internal int StatusCode;
internal string StatusDescription;
}
//
// class members
//
private WebExceptionStatus m_Error;
internal Exception m_InnerException;
internal int m_IISVersion = -1;
//-1 means unread
private byte[] m_ReadBuffer;
private int m_BytesRead;
private int m_BytesScanned;
private int m_TotalResponseHeadersLength;
private int m_MaximumResponseHeadersLength;
private long m_MaximumUnauthorizedUploadLength;
private CoreResponseData m_ResponseData;
private ReadState m_ReadState;
private StatusLineValues m_StatusLineValues;
private int m_StatusState;
private ArrayList m_WaitList;
private ArrayList m_WriteList;
private IAsyncResult m_LastAsyncResult;
private TimerThread.Timer m_RecycleTimer;
private WebParseError m_ParseError;
private bool m_AtLeastOneResponseReceived;
private static readonly WaitCallback m_PostReceiveDelegate = new WaitCallback(PostReceiveWrapper);
private static readonly AsyncCallback m_ReadCallback = new AsyncCallback(ReadCallbackWrapper);
private static readonly AsyncCallback m_TunnelCallback = new AsyncCallback(TunnelThroughProxyWrapper);
private static byte[] s_NullBuffer = new byte[0];
//
// Abort handling variables. When trying to abort the
// connection, we set Aborted = true, and close m_AbortSocket
// if its non-null. m_AbortDelegate, is returned to every
// request from our SubmitRequest method. Calling m_AbortDelegate
// drives us into Abort mode.
//
private HttpAbortDelegate m_AbortDelegate;
private ConnectionGroup m_ConnectionGroup;
private UnlockConnectionDelegate m_ConnectionUnlock;
//
// ReadDone and m_Write - no two vars are so complicated,
// as these two. Used for m_WriteList managment, most be under crit
// section when accessing.
//
// ReadDone tracks the item at the end or
// just recenlty removed from the m_WriteList. While a
// pending BeginRead is in place, we need this to be false, in
// order to indicate to tell the WriteDone callback, that we can
// handle errors/resets. The only exception is when the m_WriteList
// is empty, and there are no outstanding requests, then all it can
// be true.
//
// WriteDone tracks the item just added at the begining of the m_WriteList.
// this needs to be false while we about to write something, but have not
// yet begin or finished the write. Upon completion, its set to true,
// so that DoneReading/ReadStartNextRequest can close the socket, without fear
// of a errand writer still banging away on another thread.
//
private DateTime m_IdleSinceUtc;
private HttpWebRequest m_LockedRequest;
private HttpWebRequest m_CurrentRequest;
// This is the request whose response is being parsed, same as WriteList[0] but could be different if request was aborted.
private bool m_CanPipeline;
private bool m_Free = true;
private bool m_Idle = true;
private bool m_KeepAlive = true;
private bool m_Pipelining;
private bool m_ReadDone;
private bool m_WriteDone;
private bool m_RemovedFromConnectionList;
// Pipeline Throttling: m_IsPipelinePaused==true when we stopped and false when it's ok to add to the pipeline.
private bool m_IsPipelinePaused;
private static int s_MaxPipelinedCount = 10;
private static int s_MinPipelinedCount = 5;
internal override ServicePoint ServicePoint {
get { return ConnectionGroup.ServicePoint; }
}
private ConnectionGroup ConnectionGroup {
get { return m_ConnectionGroup; }
}
//
// LockedRequest is the request that needs exclusive access to this connection
// the ConnectionGroup should proctect the Connection object from any new
// Requests being queued, until this m_LockedRequest is finished.
//
internal HttpWebRequest LockedRequest {
get { return m_LockedRequest; }
set {
HttpWebRequest myLock = m_LockedRequest;
GlobalLog.Print("Connection#" + ValidationHelper.HashString(this) + "::LockedRequest_set() old#" + ((myLock != null) ? myLock.GetHashCode().ToString() : "null") + " new#" + ((value != null) ? value.GetHashCode().ToString() : "null"));
if ((object)value == (object)myLock) {
if (value != null && (object)value.UnlockConnectionDelegate != (object)m_ConnectionUnlock) {
throw new InternalException();
}
return;
}
object myDelegate = myLock == null ? null : myLock.UnlockConnectionDelegate;
if (myDelegate != null && (value != null || (object)m_ConnectionUnlock != (object)myDelegate))
throw new InternalException();
if (value == null) {
m_LockedRequest = null;
myLock.UnlockConnectionDelegate = null;
return;
}
UnlockConnectionDelegate chkDelegate = value.UnlockConnectionDelegate;
//
// If "value" request was already locking a connection that is not "this", unlock that other connection
//
if ((object)chkDelegate != null) {
if ((object)chkDelegate == (object)m_ConnectionUnlock)
throw new InternalException();
GlobalLog.Print("Connection#" + ValidationHelper.HashString(this) + "::LockedRequest_set() Unlocking old request Connection");
chkDelegate();
}
value.UnlockConnectionDelegate = m_ConnectionUnlock;
m_LockedRequest = value;
}
}
/// <devdoc>
/// <para>
/// Delegate called when the request is finished using this Connection
/// exclusively. Called in Abort cases and after NTLM authenticaiton completes.
/// </para>
/// </devdoc>
private void UnlockRequest()
{
GlobalLog.Print("Connection#" + ValidationHelper.HashString(this) + "::UnlockRequest() LockedRequest#" + ValidationHelper.HashString(LockedRequest));
LockedRequest = null;
if (ConnectionGroup != null) {
GlobalLog.Print("Connection#" + ValidationHelper.HashString(this) + "::UnlockRequest() - forcing call to ConnectionGoneIdle()");
ConnectionGroup.ConnectionGoneIdle();
}
}
internal Connection(ConnectionGroup connectionGroup) : base(null)
{
//
// add this Connection to the pool in the connection group,
// keep a weak reference to it
//
m_MaximumUnauthorizedUploadLength = SettingsSectionInternal.Section.MaximumUnauthorizedUploadLength;
if (m_MaximumUnauthorizedUploadLength > 0) {
m_MaximumUnauthorizedUploadLength *= 1024;
}
m_ResponseData = new CoreResponseData();
m_ConnectionGroup = connectionGroup;
m_ReadBuffer = new byte[4096];
// Using a fixed 4k read buffer.
m_ReadState = ReadState.Start;
m_WaitList = new ArrayList();
m_WriteList = new ArrayList();
m_AbortDelegate = new HttpAbortDelegate(AbortOrDisassociate);
m_ConnectionUnlock = new UnlockConnectionDelegate(UnlockRequest);
// for status line parsing
m_StatusLineValues = new StatusLineValues();
m_RecycleTimer = ConnectionGroup.ServicePoint.ConnectionLeaseTimerQueue.CreateTimer();
// the following line must be the last line of the constructor
ConnectionGroup.Associate(this);
m_ReadDone = true;
m_WriteDone = true;
m_Error = WebExceptionStatus.Success;
}
~Connection()
{
#if DEBUG
GlobalLog.SetThreadSource(ThreadKinds.Finalization);
using (GlobalLog.SetThreadKind(ThreadKinds.System | ThreadKinds.Async)) {
#endif
try {
AbortSocket(true);
}
catch (SocketException) {
}
catch (ObjectDisposedException) {
}
#if DEBUG
}
#endif
}
internal int BusyCount {
get { return (m_ReadDone ? 0 : 1) + 2 * (m_WaitList.Count + m_WriteList.Count); }
}
internal int IISVersion {
get { return m_IISVersion; }
}
internal bool AtLeastOneResponseReceived {
get { return m_AtLeastOneResponseReceived; }
}
/*++
SubmitRequest - Submit a request for sending.
The core submit handler. This is called when a request needs to be
submitted to the network. This routine is asynchronous; the caller
passes in an HttpSubmitDelegate that we invoke when the caller
can use the underlying network. The delegate is invoked with the
stream that it can right to.
On the Sync path, we work by attempting to gain control of the Connection
for writing and reading. If some other thread is using the Connection,
We wait inside of a LazyAsyncResult until it is availble.
Input:
request - request that's being submitted.
SubmitDelegate - Delegate to be invoked.
Returns:
true when the request was correctly submitted
--*/
// userReqeustThread says whether we can post IO from this thread or not.
internal bool SubmitRequest(HttpWebRequest request)
{
GlobalLog.Enter("Connection#" + ValidationHelper.HashString(this) + "::SubmitRequest", "request#" + ValidationHelper.HashString(request));
GlobalLog.ThreadContract(ThreadKinds.Unknown, "Connection#" + ValidationHelper.HashString(th