using System;
using System.IO;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace System.Net
{
	// Token: 0x02000265 RID: 613
	internal class WebConnectionStream : Stream
	{
		// Token: 0x0600165F RID: 5727 RVA: 0x0004A5D0 File Offset: 0x000487D0
		public WebConnectionStream(WebConnection cnc)
		{
			this.isRead = true;
			this.pending = new ManualResetEvent(true);
			this.request = cnc.Data.request;
			this.read_timeout = this.request.ReadWriteTimeout;
			this.write_timeout = this.read_timeout;
			this.cnc = cnc;
			string text = cnc.Data.Headers["Transfer-Encoding"];
			bool flag = text != null && text.ToLower().IndexOf("chunked") != -1;
			string text2 = cnc.Data.Headers["Content-Length"];
			if (!flag && text2 != null && text2 != string.Empty)
			{
				try
				{
					this.contentLength = int.Parse(text2);
					if (this.contentLength == 0 && !this.IsNtlmAuth())
					{
						this.ReadAll();
					}
				}
				catch
				{
					this.contentLength = int.MaxValue;
				}
			}
			else
			{
				this.contentLength = int.MaxValue;
			}
		}

		// Token: 0x06001660 RID: 5728 RVA: 0x0004A708 File Offset: 0x00048908
		public WebConnectionStream(WebConnection cnc, HttpWebRequest request)
		{
			this.read_timeout = request.ReadWriteTimeout;
			this.write_timeout = this.read_timeout;
			this.isRead = false;
			this.cnc = cnc;
			this.request = request;
			this.allowBuffering = request.InternalAllowBuffering;
			this.sendChunked = request.SendChunked;
			if (this.sendChunked)
			{
				this.pending = new ManualResetEvent(true);
			}
			else if (this.allowBuffering)
			{
				this.writeBuffer = new MemoryStream();
			}
		}

		// Token: 0x06001662 RID: 5730 RVA: 0x0004A7B8 File Offset: 0x000489B8
		private bool IsNtlmAuth()
		{
			bool flag = this.request.Proxy != null && !this.request.Proxy.IsBypassed(this.request.Address);
			string text = ((!flag) ? "WWW-Authenticate" : "Proxy-Authenticate");
			string text2 = this.cnc.Data.Headers[text];
			return text2 != null && text2.IndexOf("NTLM") != -1;
		}

		// Token: 0x06001663 RID: 5731 RVA: 0x0004A840 File Offset: 0x00048A40
		internal void CheckResponseInBuffer()
		{
			if (this.contentLength > 0 && this.readBufferSize - this.readBufferOffset >= this.contentLength && !this.IsNtlmAuth())
			{
				this.ReadAll();
			}
		}

		// Token: 0x1700072E RID: 1838
		// (get) Token: 0x06001664 RID: 5732 RVA: 0x0004A878 File Offset: 0x00048A78
		internal HttpWebRequest Request
		{
			get
			{
				return this.request;
			}
		}

		// Token: 0x1700072F RID: 1839
		// (get) Token: 0x06001665 RID: 5733 RVA: 0x0004A880 File Offset: 0x00048A80
		internal WebConnection Connection
		{
			get
			{
				return this.cnc;
			}
		}

		// Token: 0x17000730 RID: 1840
		// (get) Token: 0x06001666 RID: 5734 RVA: 0x0004A888 File Offset: 0x00048A88
		public override bool CanTimeout
		{
			get
			{
				return true;
			}
		}

		// Token: 0x17000731 RID: 1841
		// (get) Token: 0x06001667 RID: 5735 RVA: 0x0004A88C File Offset: 0x00048A8C
		// (set) Token: 0x06001668 RID: 5736 RVA: 0x0004A894 File Offset: 0x00048A94
		public override int ReadTimeout
		{
			get
			{
				return this.read_timeout;
			}
			set
			{
				if (value < -1)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				this.read_timeout = value;
			}
		}

		// Token: 0x17000732 RID: 1842
		// (get) Token: 0x06001669 RID: 5737 RVA: 0x0004A8B0 File Offset: 0x00048AB0
		// (set) Token: 0x0600166A RID: 5738 RVA: 0x0004A8B8 File Offset: 0x00048AB8
		public override int WriteTimeout
		{
			get
			{
				return this.write_timeout;
			}
			set
			{
				if (value < -1)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				this.write_timeout = value;
			}
		}

		// Token: 0x17000733 RID: 1843
		// (get) Token: 0x0600166B RID: 5739 RVA: 0x0004A8D4 File Offset: 0x00048AD4
		internal bool CompleteRequestWritten
		{
			get
			{
				return this.complete_request_written;
			}
		}

		// Token: 0x17000734 RID: 1844
		// (set) Token: 0x0600166C RID: 5740 RVA: 0x0004A8DC File Offset: 0x00048ADC
		internal bool SendChunked
		{
			set
			{
				this.sendChunked = value;
			}
		}

		// Token: 0x17000735 RID: 1845
		// (set) Token: 0x0600166D RID: 5741 RVA: 0x0004A8E8 File Offset: 0x00048AE8
		internal byte[] ReadBuffer
		{
			set
			{
				this.readBuffer = value;
			}
		}

		// Token: 0x17000736 RID: 1846
		// (set) Token: 0x0600166E RID: 5742 RVA: 0x0004A8F4 File Offset: 0x00048AF4
		internal int ReadBufferOffset
		{
			set
			{
				this.readBufferOffset = value;
			}
		}

		// Token: 0x17000737 RID: 1847
		// (set) Token: 0x0600166F RID: 5743 RVA: 0x0004A900 File Offset: 0x00048B00
		internal int ReadBufferSize
		{
			set
			{
				this.readBufferSize = value;
			}
		}

		// Token: 0x17000738 RID: 1848
		// (get) Token: 0x06001670 RID: 5744 RVA: 0x0004A90C File Offset: 0x00048B0C
		internal byte[] WriteBuffer
		{
			get
			{
				return this.writeBuffer.GetBuffer();
			}
		}

		// Token: 0x17000739 RID: 1849
		// (get) Token: 0x06001671 RID: 5745 RVA: 0x0004A91C File Offset: 0x00048B1C
		internal int WriteBufferLength
		{
			get
			{
				return (this.writeBuffer == null) ? (-1) : ((int)this.writeBuffer.Length);
			}
		}

		// Token: 0x06001672 RID: 5746 RVA: 0x0004A93C File Offset: 0x00048B3C
		internal void ForceCompletion()
		{
			if (!this.nextReadCalled)
			{
				if (this.contentLength == 2147483647)
				{
					this.contentLength = 0;
				}
				this.nextReadCalled = true;
				this.cnc.NextRead();
			}
		}

		// Token: 0x06001673 RID: 5747 RVA: 0x0004A980 File Offset: 0x00048B80
		internal void CheckComplete()
		{
			if (!this.nextReadCalled && this.readBufferSize - this.readBufferOffset == this.contentLength)
			{
				this.nextReadCalled = true;
				this.cnc.NextRead();
			}
		}

		// Token: 0x06001674 RID: 5748 RVA: 0x0004A9C4 File Offset: 0x00048BC4
		internal void ReadAll()
		{
			if (!this.isRead || this.read_eof || this.totalRead >= this.contentLength || this.nextReadCalled)
			{
				if (this.isRead && !this.nextReadCalled)
				{
					this.nextReadCalled = true;
					this.cnc.NextRead();
				}
				return;
			}
			this.pending.WaitOne();
			object obj = this.locker;
			lock (obj)
			{
				if (this.totalRead >= this.contentLength)
				{
					return;
				}
				int num = this.readBufferSize - this.readBufferOffset;
				byte[] array2;
				int num3;
				if (this.contentLength == 2147483647)
				{
					MemoryStream memoryStream = new MemoryStream();
					byte[] array = null;
					if (this.readBuffer != null && num > 0)
					{
						memoryStream.Write(this.readBuffer, this.readBufferOffset, num);
						if (this.readBufferSize >= 8192)
						{
							array = this.readBuffer;
						}
					}
					if (array == null)
					{
						array = new byte[8192];
					}
					int num2;
					while ((num2 = this.cnc.Read(this.request, array, 0, array.Length)) != 0)
					{
						memoryStream.Write(array, 0, num2);
					}
					array2 = memoryStream.GetBuffer();
					num3 = (int)memoryStream.Length;
					this.contentLength = num3;
				}
				else
				{
					num3 = this.contentLength - this.totalRead;
					array2 = new byte[num3];
					if (this.readBuffer != null && num > 0)
					{
						if (num > num3)
						{
							num = num3;
						}
						Buffer.BlockCopy(this.readBuffer, this.readBufferOffset, array2, 0, num);
					}
					int num4 = num3 - num;
					int num5 = -1;
					while (num4 > 0 && num5 != 0)
					{
						num5 = this.cnc.Read(this.request, array2, num, num4);
						num4 -= num5;
						num += num5;
					}
				}
				this.readBuffer = array2;
				this.readBufferOffset = 0;
				this.readBufferSize = num3;
				this.totalRead = 0;
				this.nextReadCalled = true;
			}
			this.cnc.NextRead();
		}

		// Token: 0x06001675 RID: 5749 RVA: 0x0004AC00 File Offset: 0x00048E00
		private void WriteCallbackWrapper(IAsyncResult r)
		{
			WebAsyncResult webAsyncResult = r as WebAsyncResult;
			if (webAsyncResult != null && webAsyncResult.AsyncWriteAll)
			{
				return;
			}
			if (r.AsyncState != null)
			{
				webAsyncResult = (WebAsyncResult)r.AsyncState;
				webAsyncResult.InnerAsyncResult = r;
				webAsyncResult.DoCallback();
			}
			else
			{
				this.EndWrite(r);
			}
		}

		// Token: 0x06001676 RID: 5750 RVA: 0x0004AC58 File Offset: 0x00048E58
		private void ReadCallbackWrapper(IAsyncResult r)
		{
			if (r.AsyncState != null)
			{
				WebAsyncResult webAsyncResult = (WebAsyncResult)r.AsyncState;
				webAsyncResult.InnerAsyncResult = r;
				webAsyncResult.DoCallback();
			}
			else
			{
				this.EndRead(r);
			}
		}

		// Token: 0x06001677 RID: 5751 RVA: 0x0004AC98 File Offset: 0x00048E98
		public override int Read(byte[] buffer, int offset, int size)
		{
			AsyncCallback asyncCallback = new AsyncCallback(this.ReadCallbackWrapper);
			WebAsyncResult webAsyncResult = (WebAsyncResult)this.BeginRead(buffer, offset, size, asyncCallback, null);
			if (!webAsyncResult.IsCompleted && !webAsyncResult.WaitUntilComplete(this.ReadTimeout, false))
			{
				this.nextReadCalled = true;
				this.cnc.Close(true);
				throw new WebException("The operation has timed out.", WebExceptionStatus.Timeout);
			}
			return this.EndRead(webAsyncResult);
		}

		// Token: 0x06001678 RID: 5752 RVA: 0x0004AD08 File Offset: 0x00048F08
		public override IAsyncResult BeginRead(byte[] buffer, int offset, int size, AsyncCallback cb, object state)
		{
			if (!this.isRead)
			{
				throw new NotSupportedException("this stream does not allow reading");
			}
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			int num = buffer.Length;
			if (offset < 0 || num < offset)
			{
				throw new ArgumentOutOfRangeException("offset");
			}
			if (size < 0 || num - offset < size)
			{
				throw new ArgumentOutOfRangeException("size");
			}
			object obj = this.locker;
			lock (obj)
			{
				this.pendingReads++;
				this.pending.Reset();
			}
			WebAsyncResult webAsyncResult = new WebAsyncResult(cb, state, buffer, offset, size);
			if (this.totalRead >= this.contentLength)
			{
				webAsyncResult.SetCompleted(true, -1);
				webAsyncResult.DoCallback();
				return webAsyncResult;
			}
			int num2 = this.readBufferSize - this.readBufferOffset;
			if (num2 > 0)
			{
				int num3 = ((num2 <= size) ? num2 : size);
				Buffer.BlockCopy(this.readBuffer, this.readBufferOffset, buffer, offset, num3);
				this.readBufferOffset += num3;
				offset += num3;
				size -= num3;
				this.totalRead += num3;
				if (size == 0 || this.totalRead >= this.contentLength)
				{
					webAsyncResult.SetCompleted(true, num3);
					webAsyncResult.DoCallback();
					return webAsyncResult;
				}
				webAsyncResult.NBytes = num3;
			}
			if (cb != null)
			{
				cb = new AsyncCallback(this.ReadCallbackWrapper);
			}
			if (this.contentLength != 2147483647 && this.contentLength - this.totalRead < size)
			{
				size = this.contentLength - this.totalRead;
			}
			if (!this.read_eof)
			{
				webAsyncResult.InnerAsyncResult = this.cnc.BeginRead(this.request, buffer, offset, size, cb, webAsyncResult);
			}
			else
			{
				webAsyncResult.SetCompleted(true, webAsyncResult.NBytes);
				webAsyncResult.DoCallback();
			}
			return webAsyncResult;
		}

		// Token: 0x06001679 RID: 5753 RVA: 0x0004AF10 File Offset: 0x00049110
		public override int EndRead(IAsyncResult r)
		{
			WebAsyncResult webAsyncResult = (WebAsyncResult)r;
			if (webAsyncResult.EndCalled)
			{
				int nbytes = webAsyncResult.NBytes;
				return (nbytes < 0) ? 0 : nbytes;
			}
			webAsyncResult.EndCalled = true;
			if (!webAsyncResult.IsCompleted)
			{
				int num = -1;
				try
				{
					num = this.cnc.EndRead(this.request, webAsyncResult);
				}
				catch (Exception ex)
				{
					object obj = this.locker;
					lock (obj)
					{
						this.pendingReads--;
						if (this.pendingReads == 0)
						{
							this.pending.Set();
						}
					}
					this.nextReadCalled = true;
					this.cnc.Close(true);
					webAsyncResult.SetCompleted(false, ex);
					webAsyncResult.DoCallback();
					throw;
				}
				if (num < 0)
				{
					num = 0;
					this.read_eof = true;
				}
				this.totalRead += num;
				webAsyncResult.SetCompleted(false, num + webAsyncResult.NBytes);
				webAsyncResult.DoCallback();
				if (num == 0)
				{
					this.contentLength = this.totalRead;
				}
			}
			object obj2 = this.locker;
			lock (obj2)
			{
				this.pendingReads--;
				if (this.pendingReads == 0)
				{
					this.pending.Set();
				}
			}
			if (this.totalRead >= this.contentLength && !this.nextReadCalled)
			{
				this.ReadAll();
			}
			int nbytes2 = webAsyncResult.NBytes;
			return (nbytes2 < 0) ? 0 : nbytes2;
		}

		// Token: 0x0600167A RID: 5754 RVA: 0x0004B0E8 File Offset: 0x000492E8
		private void WriteRequestAsyncCB(IAsyncResult r)
		{
			WebAsyncResult webAsyncResult = (WebAsyncResult)r.AsyncState;
			try
			{
				this.cnc.EndWrite2(this.request, r);
				webAsyncResult.SetCompleted(false, 0);
				if (!this.initRead)
				{
					this.initRead = true;
					WebConnection.InitRead(this.cnc);
				}
			}
			catch (Exception ex)
			{
				this.KillBuffer();
				this.nextReadCalled = true;
				this.cnc.Close(true);
				if (ex is global::System.Net.Sockets.SocketException)
				{
					ex = new IOException("Error writing request", ex);
				}
				webAsyncResult.SetCompleted(false, ex);
			}
			this.complete_request_written = true;
			webAsyncResult.DoCallback();
		}

		// Token: 0x0600167B RID: 5755 RVA: 0x0004B1A4 File Offset: 0x000493A4
		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int size, AsyncCallback cb, object state)
		{
			if (this.request.Aborted)
			{
				throw new WebException("The request was canceled.", null, WebExceptionStatus.RequestCanceled);
			}
			if (this.isRead)
			{
				throw new NotSupportedException("this stream does not allow writing");
			}
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			int num = buffer.Length;
			if (offset < 0 || num < offset)
			{
				throw new ArgumentOutOfRangeException("offset");
			}
			if (size < 0 || num - offset < size)
			{
				throw new ArgumentOutOfRangeException("size");
			}
			if (this.sendChunked)
			{
				object obj = this.locker;
				lock (obj)
				{
					this.pendingWrites++;
					this.pending.Reset();
				}
			}
			WebAsyncResult webAsyncResult = new WebAsyncResult(cb, state);
			if (!this.sendChunked)
			{
				this.CheckWriteOverflow(this.request.ContentLength, this.totalWritten, (long)size);
			}
			if (this.allowBuffering && !this.sendChunked)
			{
				if (this.writeBuffer == null)
				{
					this.writeBuffer = new MemoryStream();
				}
				this.writeBuffer.Write(buffer, offset, size);
				this.totalWritten += (long)size;
				if (this.request.ContentLength > 0L && this.totalWritten == this.request.ContentLength)
				{
					try
					{
						webAsyncResult.AsyncWriteAll = true;
						webAsyncResult.InnerAsyncResult = this.WriteRequestAsync(new AsyncCallback(this.WriteRequestAsyncCB), webAsyncResult);
						if (webAsyncResult.InnerAsyncResult == null)
						{
							if (!webAsyncResult.IsCompleted)
							{
								webAsyncResult.SetCompleted(true, 0);
							}
							webAsyncResult.DoCallback();
						}
					}
					catch (Exception ex)
					{
						webAsyncResult.SetCompleted(true, ex);
						webAsyncResult.DoCallback();
					}
				}
				else
				{
					webAsyncResult.SetCompleted(true, 0);
					webAsyncResult.DoCallback();
				}
				return webAsyncResult;
			}
			AsyncCallback asyncCallback = null;
			if (cb != null)
			{
				asyncCallback = new AsyncCallback(this.WriteCallbackWrapper);
			}
			if (this.sendChunked)
			{
				this.WriteRequest();
				string text = string.Format("{0:X}\r\n", size);
				byte[] bytes = Encoding.ASCII.GetBytes(text);
				int num2 = 2 + size + bytes.Length;
				byte[] array = new byte[num2];
				Buffer.BlockCopy(bytes, 0, array, 0, bytes.Length);
				Buffer.BlockCopy(buffer, offset, array, bytes.Length, size);
				Buffer.BlockCopy(WebConnectionStream.crlf, 0, array, bytes.Length + size, WebConnectionStream.crlf.Length);
				buffer = array;
				offset = 0;
				size = num2;
			}
			webAsyncResult.InnerAsyncResult = this.cnc.BeginWrite(this.request, buffer, offset, size, asyncCallback, webAsyncResult);
			this.totalWritten += (long)size;
			return webAsyncResult;
		}

		// Token: 0x0600167C RID: 5756 RVA: 0x0004B47C File Offset: 0x0004967C
		private void CheckWriteOverflow(long contentLength, long totalWritten, long size)
		{
			if (contentLength == -1L)
			{
				return;
			}
			long num = contentLength - totalWritten;
			if (size > num)
			{
				this.KillBuffer();
				this.nextReadCalled = true;
				this.cnc.Close(true);
				throw new ProtocolViolationException("The number of bytes to be written is greater than the specified ContentLength.");
			}
		}

		// Token: 0x0600167D RID: 5757 RVA: 0x0004B4C4 File Offset: 0x000496C4
		public override void EndWrite(IAsyncResult r)
		{
			if (r == null)
			{
				throw new ArgumentNullException("r");
			}
			WebAsyncResult webAsyncResult = r as WebAsyncResult;
			if (webAsyncResult == null)
			{
				throw new ArgumentException("Invalid IAsyncResult");
			}
			if (webAsyncResult.EndCalled)
			{
				return;
			}
			webAsyncResult.EndCalled = true;
			if (webAsyncResult.AsyncWriteAll)
			{
				webAsyncResult.WaitUntilComplete();
				if (webAsyncResult.GotException)
				{
					throw webAsyncResult.Exception;
				}
				return;
			}
			else
			{
				if (this.allowBuffering && !this.sendChunked)
				{
					return;
				}
				if (webAsyncResult.GotException)
				{
					throw webAsyncResult.Exception;
				}
				try
				{
					this.cnc.EndWrite2(this.request, webAsyncResult.InnerAsyncResult);
					webAsyncResult.SetCompleted(false, 0);
					webAsyncResult.DoCallback();
				}
				catch (Exception ex)
				{
					webAsyncResult.SetCompleted(false, ex);
					webAsyncResult.DoCallback();
					throw;
				}
				finally
				{
					if (this.sendChunked)
					{
						object obj = this.locker;
						lock (obj)
						{
							this.pendingWrites--;
							if (this.pendingWrites == 0)
							{
								this.pending.Set();
							}
						}
					}
				}
				return;
			}
		}

		// Token: 0x0600167E RID: 5758 RVA: 0x0004B630 File Offset: 0x00049830
		public override void Write(byte[] buffer, int offset, int size)
		{
			AsyncCallback asyncCallback = new AsyncCallback(this.WriteCallbackWrapper);
			WebAsyncResult webAsyncResult = (WebAsyncResult)this.BeginWrite(buffer, offset, size, asyncCallback, null);
			if (!webAsyncResult.IsCompleted && !webAsyncResult.WaitUntilComplete(this.WriteTimeout, false))
			{
				this.KillBuffer();
				this.nextReadCalled = true;
				this.cnc.Close(true);
				throw new IOException("Write timed out.");
			}
			this.EndWrite(webAsyncResult);
		}

		// Token: 0x0600167F RID: 5759 RVA: 0x0004B6A4 File Offset: 0x000498A4
		public override void Flush()
		{
		}

		// Token: 0x06001680 RID: 5760 RVA: 0x0004B6A8 File Offset: 0x000498A8
		internal void SetHeaders(byte[] buffer)
		{
			if (this.headersSent)
			{
				return;
			}
			this.headers = buffer;
			long num = this.request.ContentLength;
			string method = this.request.Method;
			bool flag = method == "GET" || method == "CONNECT" || method == "HEAD" || method == "TRACE" || method == "DELETE";
			if (this.sendChunked || num > -1L || flag)
			{
				this.WriteHeaders();
				if (!this.initRead)
				{
					this.initRead = true;
					WebConnection.InitRead(this.cnc);
				}
				if (!this.sendChunked && num == 0L)
				{
					this.requestWritten = true;
				}
			}
		}

		// Token: 0x1700073A RID: 1850
		// (get) Token: 0x06001681 RID: 5761 RVA: 0x0004B784 File Offset: 0x00049984
		internal bool RequestWritten
		{
			get
			{
				return this.requestWritten;
			}
		}

		// Token: 0x06001682 RID: 5762 RVA: 0x0004B78C File Offset: 0x0004998C
		private IAsyncResult WriteRequestAsync(AsyncCallback cb, object state)
		{
			this.requestWritten = true;
			byte[] buffer = this.writeBuffer.GetBuffer();
			int num = (int)this.writeBuffer.Length;
			IAsyncResult asyncResult2;
			if (num > 0)
			{
				IAsyncResult asyncResult = this.cnc.BeginWrite(this.request, buffer, 0, num, cb, state);
				asyncResult2 = asyncResult;
			}
			else
			{
				asyncResult2 = null;
			}
			return asyncResult2;
		}

		// Token: 0x06001683 RID: 5763 RVA: 0x0004B7E0 File Offset: 0x000499E0
		private void WriteHeaders()
		{
			if (this.headersSent)
			{
				return;
			}
			this.headersSent = true;
			string text = null;
			if (!this.cnc.Write(this.request, this.headers, 0, this.headers.Length, ref text))
			{
				throw new WebException("Error writing request: " + text, null, WebExceptionStatus.SendFailure, null);
			}
		}

		// Token: 0x06001684 RID: 5764 RVA: 0x0004B840 File Offset: 0x00049A40
		internal void WriteRequest()
		{
			if (this.requestWritten)
			{
				return;
			}
			this.requestWritten = true;
			if (this.sendChunked)
			{
				return;
			}
			if (!this.allowBuffering || this.writeBuffer == null)
			{
				return;
			}
			byte[] buffer = this.writeBuffer.GetBuffer();
			int num = (int)this.writeBuffer.Length;
			if (this.request.ContentLength != -1L && this.request.ContentLength < (long)num)
			{
				this.nextReadCalled = true;
				this.cnc.Close(true);
				throw new WebException("Specified Content-Length is less than the number of bytes to write", null, WebExceptionStatus.ServerProtocolViolation, null);
			}
			if (!this.headersSent)
			{
				string method = this.request.Method;
				if (!(method == "GET") && !(method == "CONNECT") && !(method == "HEAD") && !(method == "TRACE") && !(method == "DELETE"))
				{
					this.request.InternalContentLength = (long)num;
				}
				this.request.SendRequestHeaders(true);
			}
			this.WriteHeaders();
			if (this.cnc.Data.StatusCode != 0 && this.cnc.Data.StatusCode != 100)
			{
				return;
			}
			IAsyncResult asyncResult = null;
			if (num > 0)
			{
				asyncResult = this.cnc.BeginWrite(this.request, buffer, 0, num, null, null);
			}
			if (!this.initRead)
			{
				this.initRead = true;
				WebConnection.InitRead(this.cnc);
			}
			if (num > 0)
			{
				this.complete_request_written = this.cnc.EndWrite(this.request, asyncResult);
			}
			else
			{
				this.complete_request_written = true;
			}
		}

		// Token: 0x06001685 RID: 5765 RVA: 0x0004BA08 File Offset: 0x00049C08
		internal void InternalClose()
		{
			this.disposed = true;
		}

		// Token: 0x06001686 RID: 5766 RVA: 0x0004BA14 File Offset: 0x00049C14
		public override void Close()
		{
			if (this.sendChunked)
			{
				if (this.disposed)
				{
					return;
				}
				this.disposed = true;
				this.pending.WaitOne();
				byte[] bytes = Encoding.ASCII.GetBytes("0\r\n\r\n");
				string text = null;
				this.cnc.Write(this.request, bytes, 0, bytes.Length, ref text);
				return;
			}
			else
			{
				if (this.isRead)
				{
					if (!this.nextReadCalled)
					{
						this.CheckComplete();
						if (!this.nextReadCalled)
						{
							this.nextReadCalled = true;
							this.cnc.Close(true);
						}
					}
					return;
				}
				if (!this.allowBuffering)
				{
					this.complete_request_written = true;
					if (!this.initRead)
					{
						this.initRead = true;
						WebConnection.InitRead(this.cnc);
					}
					return;
				}
				if (this.disposed || this.requestWritten)
				{
					return;
				}
				long num = this.request.ContentLength;
				if (!this.sendChunked && num != -1L && this.totalWritten != num)
				{
					IOException ex = new IOException("Cannot close the stream until all bytes are written");
					this.nextReadCalled = true;
					this.cnc.Close(true);
					throw new WebException("Request was cancelled.", ex, WebExceptionStatus.RequestCanceled);
				}
				this.WriteRequest();
				this.disposed = true;
				return;
			}
		}

		// Token: 0x06001687 RID: 5767 RVA: 0x0004BB5C File Offset: 0x00049D5C
		internal void KillBuffer()
		{
			this.writeBuffer = null;
		}

		// Token: 0x06001688 RID: 5768 RVA: 0x0004BB68 File Offset: 0x00049D68
		public override long Seek(long a, SeekOrigin b)
		{
			throw new NotSupportedException();
		}

		// Token: 0x06001689 RID: 5769 RVA: 0x0004BB70 File Offset: 0x00049D70
		public override void SetLength(long a)
		{
			throw new NotSupportedException();
		}

		// Token: 0x1700073B RID: 1851
		// (get) Token: 0x0600168A RID: 5770 RVA: 0x0004BB78 File Offset: 0x00049D78
		public override bool CanSeek
		{
			get
			{
				return false;
			}
		}

		// Token: 0x1700073C RID: 1852
		// (get) Token: 0x0600168B RID: 5771 RVA: 0x0004BB7C File Offset: 0x00049D7C
		public override bool CanRead
		{
			get
			{
				return !this.disposed && this.isRead;
			}
		}

		// Token: 0x1700073D RID: 1853
		// (get) Token: 0x0600168C RID: 5772 RVA: 0x0004BB94 File Offset: 0x00049D94
		public override bool CanWrite
		{
			get
			{
				return !this.disposed && !this.isRead;
			}
		}

		// Token: 0x1700073E RID: 1854
		// (get) Token: 0x0600168D RID: 5773 RVA: 0x0004BBB0 File Offset: 0x00049DB0
		public override long Length
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		// Token: 0x1700073F RID: 1855
		// (get) Token: 0x0600168E RID: 5774 RVA: 0x0004BBB8 File Offset: 0x00049DB8
		// (set) Token: 0x0600168F RID: 5775 RVA: 0x0004BBC0 File Offset: 0x00049DC0
		public override long Position
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		// Token: 0x0400123B RID: 4667
		private static byte[] crlf = new byte[] { 13, 10 };

		// Token: 0x0400123C RID: 4668
		private bool isRead;

		// Token: 0x0400123D RID: 4669
		private WebConnection cnc;

		// Token: 0x0400123E RID: 4670
		private HttpWebRequest request;

		// Token: 0x0400123F RID: 4671
		private byte[] readBuffer;

		// Token: 0x04001240 RID: 4672
		private int readBufferOffset;

		// Token: 0x04001241 RID: 4673
		private int readBufferSize;

		// Token: 0x04001242 RID: 4674
		private int contentLength;

		// Token: 0x04001243 RID: 4675
		private int totalRead;

		// Token: 0x04001244 RID: 4676
		private long totalWritten;

		// Token: 0x04001245 RID: 4677
		private bool nextReadCalled;

		// Token: 0x04001246 RID: 4678
		private int pendingReads;

		// Token: 0x04001247 RID: 4679
		private int pendingWrites;

		// Token: 0x04001248 RID: 4680
		private ManualResetEvent pending;

		// Token: 0x04001249 RID: 4681
		private bool allowBuffering;

		// Token: 0x0400124A RID: 4682
		private bool sendChunked;

		// Token: 0x0400124B RID: 4683
		private MemoryStream writeBuffer;

		// Token: 0x0400124C RID: 4684
		private bool requestWritten;

		// Token: 0x0400124D RID: 4685
		private byte[] headers;

		// Token: 0x0400124E RID: 4686
		private bool disposed;

		// Token: 0x0400124F RID: 4687
		private bool headersSent;

		// Token: 0x04001250 RID: 4688
		private object locker = new object();

		// Token: 0x04001251 RID: 4689
		private bool initRead;

		// Token: 0x04001252 RID: 4690
		private bool read_eof;

		// Token: 0x04001253 RID: 4691
		private bool complete_request_written;

		// Token: 0x04001254 RID: 4692
		private int read_timeout;

		// Token: 0x04001255 RID: 4693
		private int write_timeout;
	}
}