/// <summary>
        /// Sends the body of a non-chunked transfer-encoded message
        /// </summary>
        /// <param name="socket"></param>
        /// <param name="abortEvent"></param>
        /// <param name="message"></param>
        internal protected void SendBodyNonChunked(Socket socket, ManualResetEvent abortEvent, HttpMessage message, EventHandler <HttpMessageProgressEventArgs> onProgress, object stateObject)
        {
            int segmentNumber  = 0;
            int totalBytesSent = 0;

            byte[] body = message.ToByteArray(false /* no headers */, true /* just the body */);
            while (true)
            {
                // if we have sent the entire message then we can abortEvent
                if (totalBytesSent == body.Length)
                {
                    break;
                }

                // start out with a full segment size (this is just the buffer size by which we will send - 8k seems to be really common although i have no idea why other than that it's a power of 2...)
                int chunkSize = MAX_SEGMENT_SIZE_NONCHUNKED;

                // adjust how much we need to send to complete the message
                if (chunkSize > (body.Length - totalBytesSent))
                {
                    chunkSize = (body.Length - totalBytesSent);
                }

                // bump up the segment number
                segmentNumber++;

                // create the chunk to send
                byte[] bytes = new byte[chunkSize];
                Buffer.BlockCopy(body, totalBytesSent /* offset */, bytes, 0, chunkSize);

                // try and send the segment
                int bytesSent = HttpUtils.SendBytes(socket, bytes);

                // update the stream position which is the total number of bytes received
                totalBytesSent += bytesSent;

                // notify the callback of our progress
                this.OnProgress(onProgress, this, new HttpMessageProgressEventArgs(message, false, bytes, totalBytesSent, stateObject));

                // clear that buffer immediately
                bytes = null;

                // see if we have been instructed to abortEvent reading
                if (abortEvent != null)
                {
                    if (abortEvent.WaitOne(1, false))
                    {
                        throw new HttpMessageWriterAbortedException(message);
                    }
                }
            }             // while (true)
        }
        /// <summary>
        /// Writes the message's headers to the socket
        /// </summary>
        /// <param name="socket"></param>
        /// <param name="message"></param>
        internal protected int SendHeaders(Socket socket, HttpMessage message, EventHandler <HttpMessageProgressEventArgs> onProgress, object stateObject)
        {
            // check the headers of the message
            this.CheckHeaders(socket, message);

            /*
             * The only thing we can reliably send at the start of every message are the headers
             * Technically we should be carefull how many bytes the headers are, but at this point
             * until i see it fail, i'm gonna take it easy on the paranoia factor, sometimes i can only defend so much before i'm wasting time... :P
             *
             * So send the headers
             * */
            byte[] bytes = message.ToByteArray(true /* get just the headers */, false /* do not include the body */);

            // send the header bytes
            int bytesSent = HttpUtils.SendBytes(socket, bytes);

            // notify the callback that we have sent the headers
            this.OnProgress(onProgress, this, new HttpMessageProgressEventArgs(message, true, bytes, bytesSent, stateObject));

            return(bytesSent);
        }
        /// <summary>
        /// Sends the body of a chunked transfer-encoded message
        /// </summary>
        /// <param name="socket"></param>
        /// <param name="abortEvent"></param>
        /// <param name="message"></param>
        internal protected void SendBodyChunked(Socket socket, ManualResetEvent abortEvent, HttpMessage message, EventHandler <HttpMessageProgressEventArgs> onProgress, object stateObject)
        {
            int segmentNumber  = 0;
            int totalBytesSent = 0;

            byte[] body = message.ToByteArray(false /* no headers */, true /* just the body */);

            while (true)
            {
                // if we have sent the entire message then we can abortEvent
                if (totalBytesSent > body.Length)
                {
                    break;
                }

                // start out with a full segment size (this is just the buffer size by which we will send - 8k seems to be really common although i have no idea why other than that it's a power of 2...)
                int chunkSize = MAX_SEGMENT_SIZE_CHUNKED;

                // adjust how much we need to send to complete the message
                if (chunkSize > (body.Length - totalBytesSent))
                {
                    chunkSize = (body.Length - totalBytesSent);
                }

                // bump up the segment number
                segmentNumber++;

                // create a chunk of data to send
                byte[] bytes = new byte[chunkSize];
                Buffer.BlockCopy(body, totalBytesSent, bytes, 0, chunkSize);

                // create a chunk around the data
                HttpChunk chunk = new HttpChunk(bytes);

                // send the data
                int bytesSent = HttpUtils.SendBytes(socket, chunk.ToByteArray());

                // if any data was sent
                if (bytesSent > 0)
                {
                    // figure out how much as data, minus the chunks control chars
                    int actualBytesSent = bytesSent - chunk.GetNonDataByteCount();

                    // if the chunksize is zero or less then we'll return what was sent
                    if (chunkSize > 0)
                    {
                        // all other times it'll not count the non data byte count in the chunk
                        bytesSent = actualBytesSent;
                    }
                }

                // tally the number of bytes we have sent
                totalBytesSent += bytesSent;

                // notify the callback of our progress
                this.OnProgress(onProgress, this, new HttpMessageProgressEventArgs(message, false, bytes, totalBytesSent, stateObject));

                // clear that buffer immediately
                bytes = null;

                // see if we have been instructed to abortEvent reading
                if (abortEvent != null)
                {
                    if (abortEvent.WaitOne(1, false))
                    {
                        throw new HttpMessageWriterAbortedException(message);
                    }
                }
            }
        }
		/// <summary>
		/// Sends the body of a non-chunked transfer-encoded message
		/// </summary>
		/// <param name="socket"></param>
		/// <param name="abortEvent"></param>
		/// <param name="message"></param>
		internal protected void SendBodyNonChunked(Socket socket, ManualResetEvent abortEvent, HttpMessage message, EventHandler<HttpMessageProgressEventArgs> onProgress, object stateObject)
		{
			int segmentNumber = 0;
			int totalBytesSent = 0;		
			byte[] body = message.ToByteArray(false /* no headers */, true /* just the body */);
			while(true)
			{
				// if we have sent the entire message then we can abortEvent
				if (totalBytesSent == body.Length)
					break;

				// start out with a full segment size (this is just the buffer size by which we will send - 8k seems to be really common although i have no idea why other than that it's a power of 2...)
				int chunkSize = MAX_SEGMENT_SIZE_NONCHUNKED;

				// adjust how much we need to send to complete the message
				if (chunkSize > (body.Length - totalBytesSent))
					chunkSize = (body.Length - totalBytesSent);
					
				// bump up the segment number
				segmentNumber++;

				// create the chunk to send
				byte[] bytes = new byte[chunkSize];
				Buffer.BlockCopy(body, totalBytesSent /* offset */, bytes, 0, chunkSize);

				// try and send the segment
				int bytesSent = HttpUtils.SendBytes(socket, bytes);

				// update the stream position which is the total number of bytes received
				totalBytesSent += bytesSent;

				// notify the callback of our progress
				this.OnProgress(onProgress, this, new HttpMessageProgressEventArgs(message, false, bytes, totalBytesSent, stateObject));
				
				// clear that buffer immediately
				bytes = null;				
									
				// see if we have been instructed to abortEvent reading
				if (abortEvent != null)
					if (abortEvent.WaitOne(1, false))						
						throw new HttpMessageWriterAbortedException(message);					
			} // while (true)
		}
		/// <summary>
		/// Sends the body of a chunked transfer-encoded message
		/// </summary>
		/// <param name="socket"></param>
		/// <param name="abortEvent"></param>
		/// <param name="message"></param>
		internal protected void SendBodyChunked(Socket socket, ManualResetEvent abortEvent, HttpMessage message, EventHandler<HttpMessageProgressEventArgs> onProgress, object stateObject)
		{
			int segmentNumber = 0;
			int totalBytesSent = 0;
			byte[] body = message.ToByteArray(false /* no headers */, true /* just the body */);

			while(true)
			{				
				// if we have sent the entire message then we can abortEvent
				if (totalBytesSent > body.Length)
					break;

				// start out with a full segment size (this is just the buffer size by which we will send - 8k seems to be really common although i have no idea why other than that it's a power of 2...)
				int chunkSize = MAX_SEGMENT_SIZE_CHUNKED;

				// adjust how much we need to send to complete the message
				if (chunkSize > (body.Length - totalBytesSent))
					chunkSize = (body.Length - totalBytesSent);
					
				// bump up the segment number
				segmentNumber++;

				// create a chunk of data to send
				byte[] bytes = new byte[chunkSize];
				Buffer.BlockCopy(body, totalBytesSent, bytes, 0, chunkSize);

				// create a chunk around the data
				HttpChunk chunk = new HttpChunk(bytes);

				// send the data
				int bytesSent = HttpUtils.SendBytes(socket, chunk.ToByteArray());
				
				// if any data was sent
				if (bytesSent > 0)
				{
					// figure out how much as data, minus the chunks control chars
					int actualBytesSent = bytesSent - chunk.GetNonDataByteCount();

					// if the chunksize is zero or less then we'll return what was sent
					if (chunkSize > 0)
						// all other times it'll not count the non data byte count in the chunk
						bytesSent = actualBytesSent;           
				}

				// tally the number of bytes we have sent
				totalBytesSent += bytesSent;

				// notify the callback of our progress
				this.OnProgress(onProgress, this, new HttpMessageProgressEventArgs(message, false, bytes, totalBytesSent, stateObject));
				
				// clear that buffer immediately
				bytes = null;				
							
				// see if we have been instructed to abortEvent reading
				if (abortEvent != null)
					if (abortEvent.WaitOne(1, false))						
						throw new HttpMessageWriterAbortedException(message);									
			}
		}
		/// <summary>
		/// Writes the message's headers to the socket
		/// </summary>
		/// <param name="socket"></param>
		/// <param name="message"></param>
		internal protected int SendHeaders(Socket socket, HttpMessage message, EventHandler<HttpMessageProgressEventArgs> onProgress, object stateObject)
		{
			// check the headers of the message
			this.CheckHeaders(socket, message);

			/*
			 * The only thing we can reliably send at the start of every message are the headers
			 * Technically we should be carefull how many bytes the headers are, but at this point
			 * until i see it fail, i'm gonna take it easy on the paranoia factor, sometimes i can only defend so much before i'm wasting time... :P
			 * 
			 * So send the headers
			 * */
			byte[] bytes = message.ToByteArray(true /* get just the headers */, false /* do not include the body */);

			// send the header bytes
			int bytesSent = HttpUtils.SendBytes(socket, bytes);

			// notify the callback that we have sent the headers
			this.OnProgress(onProgress, this, new HttpMessageProgressEventArgs(message, true, bytes, bytesSent, stateObject));

			return bytesSent;
		}