internal Connection(System.Net.ConnectionGroup connectionGroup) : base(null)
 {
     this.m_IISVersion = -1;
     this.m_Free = true;
     this.m_Idle = true;
     this.m_KeepAlive = true;
     this.m_MaximumUnauthorizedUploadLength = SettingsSectionInternal.Section.MaximumUnauthorizedUploadLength;
     if (this.m_MaximumUnauthorizedUploadLength > 0L)
     {
         this.m_MaximumUnauthorizedUploadLength *= 0x400L;
     }
     this.m_ResponseData = new CoreResponseData();
     this.m_ConnectionGroup = connectionGroup;
     this.m_ReadBuffer = new byte[0x1000];
     this.m_ReadState = ReadState.Start;
     this.m_WaitList = new List<WaitListItem>();
     this.m_WriteList = new ArrayList();
     this.m_AbortDelegate = new HttpAbortDelegate(this.AbortOrDisassociate);
     this.m_ConnectionUnlock = new UnlockConnectionDelegate(this.UnlockRequest);
     this.m_StatusLineValues = new StatusLineValues();
     this.m_RecycleTimer = this.ConnectionGroup.ServicePoint.ConnectionLeaseTimerQueue.CreateTimer();
     this.ConnectionGroup.Associate(this);
     this.m_ReadDone = true;
     this.m_WriteDone = true;
     this.m_Error = WebExceptionStatus.Success;
 }

		void ReadComplete( IAsyncResult iar )
		{
			int toread = 4;
			int bytes = 0;
			try
			{
				bytes = socket.EndReceive( iar );
			}
			catch( Exception )
			{
				socket.Close();
				disconnected = true;
				return;
			}
			switch( state )
			{
			case ReadState.readLength:
				toread = BitConverter.ToInt32( buffer.GetBuffer(), 0 );
				state = ReadState.readData;
				break;
			case ReadState.readData:
				state = ReadState.readLength;
				Protocol.Message msgId = (Protocol.Message)BitConverter.ToInt32( buffer.GetBuffer(), 0 );
				switch( msgId )
				{
				default:
					Log.log( "Received unhandled message: {0}", msgId );
					break;
					//case Protocol.Message.
				}
				break;
			}
			buffer.SetLength( toread );
			socket.BeginReceive( buffer.GetBuffer(), 0, toread, SocketFlags.None, ReadComplete, null );
		}

 internal void BeginRead()
 {
     NetworkStream netstream = _tcp.GetStream();
     int bufferSize = _tcp.ReceiveBufferSize;
     var state = new ReadState(netstream, bufferSize);
     netstream.BeginRead(state.Buffer, 0, state.Buffer.Length, ReadCallback, state);
 }

 public void Poll()
 {
     while (_stream.DataAvailable) {
         switch (_readState) {
         case ReadState.ReadLength:
             _bufInt32Offset += _stream.Read(_bufInt32, _bufInt32Offset, 4 - _bufInt32Offset);
             if (_bufInt32Offset == 4) {
                 _readState = ReadState.ReadType;
                 _bufInt32Offset = 0;
                 _intConverter.FromBytes(_bufInt32, 0);
                 _payload = new byte[_intConverter.intdata];
             }
             break;
         case ReadState.ReadType:
             _bufInt32Offset += _stream.Read (_bufInt32, _bufInt32Offset, 4 - _bufInt32Offset);
             if (_bufInt32Offset == 4) {
                 _readState = ReadState.ReadPayload;
                 _bufInt32Offset = 0;
                 _intConverter.FromBytes(_bufInt32, 0);
                 _type = (PacketType)_intConverter.intdata;
             }
             break;
         case ReadState.ReadPayload:
             _payloadOffset += _stream.Read(_payload, _payloadOffset, _payload.Length - _payloadOffset);
             if (_payloadOffset == _payload.Length) {
                 _readState = ReadState.ReadLength;
                 _payloadOffset = 0;
                 if (OnResponse != null) {
                     OnResponse(new Packet(){ type = _type, payload = _payload });
                 }
             }
             break;
         }
     }
 }

			internal CommState()
			{
				idle_tick = new Timer( CheckIdle, null, 30000, 30000 );
				readstate = ReadState.getLength;
				buffer = new MemoryStream( 1024 );
				send_buffer = new MemoryStream( 1024 );
			}

 public ChunkParser(Connection connection,ArraySegment<byte> initialBuffer, int initialBufferOffset, int initialBufferCount)
 {
     _connection = connection;
     _buffer = initialBuffer;
     _bufferCurrentPos = initialBufferOffset;
     _bufferSize = initialBufferOffset + initialBufferCount;
     _readState = ReadState.ChunkLength;
     _currentChunkLength = -1;
 }

 public RilList Get(ReadState state, DateTime? since, int? count, int? page, bool myAppOnly, bool tags)
 {
     var list = new RilList();
     list.Items = new Dictionary<string, RilListItem>();
     list.Items.Add("12345", new RilListItem() { Title = "Website 1", Url = "www.web1.com" });
     list.Items.Add("23456", new RilListItem() { Title = "Website 2", Url = "www.web2.com" });
     list.Items.Add("34567", new RilListItem() { Title = "Website 3", Url = "www.web3.com", Tags = "existing-tag" });
     return list;
 }

			internal MasterServerConnection( TcpClient client)
			{
				this.tcpClient = client;
				socket = client.Client;
				state = ReadState.readLength;
				socket.NoDelay = true;
				buffer.SetLength( 4 ); // makes ure buffer has a buffer
				socket.BeginReceive( buffer.GetBuffer(), 0, 4, SocketFlags.None, ReadComplete, client );
				SendHello();
			}

		public TextIncludingReader(Uri includeLocation, string encoding,
			string accept, string acceptLanguage, bool exposeCDATA) {
			_includeLocation = includeLocation;			
			_href = includeLocation.AbsoluteUri;
			_encoding = encoding;
			_state = ReadState.Initial;
			_accept = accept;			
			_acceptLanguage = acceptLanguage;
            _exposeCDATA = exposeCDATA;
		}

        private void ResetForNewResponse()
        {
            if (_errorDecoder != null)
            {
            	_errorDecoder.Dispose();
                _errorDecoder = null;
            }

            _readState = new ReadState();
            _currentReadState = ReadResponseHeader;
        }

        internal static string Read(Record record, int lengthBits, ref int continueIndex, ref ushort offset)
        {
            string text = string.Empty;

            ReadState state = new ReadState(record, lengthBits, continueIndex, offset);
            Read(state);
            continueIndex = state.ContinueIndex;
            offset = state.Offset;

            return new string(state.CharactersRead.ToArray());
        }

 public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage, Action onClose)
 {
     var readState = new ReadState();
     return new ComposableHandler
     {
         Handshake = () => Hybi13Handler.BuildHandshake(request),
         Frame = s => Hybi13Handler.FrameData(Encoding.UTF8.GetBytes(s), FrameType.Text),
         Close = i => Hybi13Handler.FrameData(i.ToBigEndianBytes<ushort>(), FrameType.Close),
         RecieveData = d => Hybi13Handler.ReceiveData(d, readState, (op, data) => Hybi13Handler.ProcessFrame(op, data, onMessage, onClose))
     };
 }

 public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage, Fleck2Extensions.Action onClose, Action<byte[]> onBinary)
 {
     var readState = new ReadState();
     return new ComposableHandler
     {
         Handshake = () => BuildHandshake(request),
         TextFrame = data => FrameData(Encoding.UTF8.GetBytes(data), FrameType.Text),
         BinaryFrame = data => FrameData(data, FrameType.Binary),
         CloseFrame = i => FrameData(i.ToBigEndianBytes<ushort>(), FrameType.Close),
         ReceiveData = bytes => ReceiveData(bytes, readState, (op, data) => ProcessFrame(op, data, onMessage, onClose, onBinary))
     };
 }

 private bool BufferEnd()
 {
     if (this.maxOffset != 0)
     {
         return false;
     }
     if ((this.readState != ReadState.ReadWS) && (this.readState != ReadState.ReadValue))
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.Runtime.Serialization.SR.GetString("MimeReaderMalformedHeader")));
     }
     this.readState = ReadState.EOF;
     return true;
 }

 public XmlMicrodataReader(HtmlAgilityPack.HtmlNode rootEntity)
 {
     this.readState = System.Xml.ReadState.Initial;
     this.rootEntity = new Item(rootEntity);
     this.nodeType = XmlNodeType.None;
     var typeAttr = rootEntity.GetAttributeItemType();
     if (typeAttr != null)
     {
         Uri type;
         Uri.TryCreate(typeAttr.Value, UriKind.Absolute, out type);
         this.Type = type;
     }
 }

		public override bool Read()
		{
			switch (readState) {
				case ReadState.Initial:
					readState = ReadState.Interactive;
					return ReadCurrentPosition();
				case ReadState.Interactive:
					objectIterator.MoveInto();
					return ReadCurrentPosition();
				default:
					return false;
			}
		}

 public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage, Action onClose, Action<byte[]> onBinary, Action<byte[]> onPing, Action<byte[]> onPong)
 {
     var readState = new ReadState();
     return new ComposableHandler
     {
         Handshake = sub => Hybi13Handler.BuildHandshake(request, sub),
         TextFrame = s => Hybi13Handler.FrameData(Encoding.UTF8.GetBytes(s), FrameType.Text),
         BinaryFrame = s => Hybi13Handler.FrameData(s, FrameType.Binary),
         PingFrame = s => Hybi13Handler.FrameData(s, FrameType.Ping),
         PongFrame = s => Hybi13Handler.FrameData(s, FrameType.Pong),
         CloseFrame = i => Hybi13Handler.FrameData(i.ToBigEndianBytes<ushort>(), FrameType.Close),
         ReceiveData = d => Hybi13Handler.ReceiveData(d, readState, (op, data) => Hybi13Handler.ProcessFrame(op, data, onMessage, onClose, onBinary, onPing, onPong))
     };
 }

 private static void BeginRead(ReadState rs, Action callback)
 {
     AsyncCallback asyncCallback = ar => {
                                   	int count = rs.Stream.EndRead(ar);
                                   	rs.Offset += count;
                                   	rs.Count -= count;
                                   	if(rs.Count > 0) {
                                   		BeginRead(rs, callback);
                                   	}
                                   	else {
                                   		callback();
                                   	}
                                   };
     rs.Stream.BeginRead(rs.Buffer, rs.Offset, rs.Count, asyncCallback, rs);
 }

		/// <summary>
		/// See <see cref="XmlReader.Read"/>.
		/// </summary>
		public override bool Read()
		{
			if (state == ReadState.Initial)
			{
				state = ReadState.Interactive;
				isRoot = true;
				nodeType = XmlNodeType.Element;
				return true;
			}
			else if (state == ReadState.EndOfFile)
			{
				return false;
			}

			bool read = base.Read();

			if (isRoot)
			{
				if (!read)
				{
					isRoot = false;
					nodeType = XmlNodeType.None;
					state = ReadState.EndOfFile;
				}
				else
				{
					isRoot = false;
				}
			}
			else
			{
				if (!read)
				{
					isRoot = true;
					nodeType = XmlNodeType.EndElement;
					return true;
				}
			}

			return read;
		}

        private void ReadNewLine(byte[] buffer, int startIndex, int lastIndex, bool beforeContentDisposition)
        {
            _readState = beforeContentDisposition ? ReadState.ReadBeforeContentDisposition : ReadState.ReadAfterContentDisposition;

            for (int i = startIndex; i < lastIndex; ++i)
            {
                if (!beforeContentDisposition)
                {
                    _contentDisposition.Add(buffer[i]);
                }

                if (buffer[i] == _newLine[_newLineIndex])
                {
                    _newLineIndex++;
                    if (_newLineIndex == 2)
                    {
                        _newLineIndex = 0;

                        if (beforeContentDisposition)
                        {
                            // found a new line character here. now start parsing the content-disposition 
                            _contentDisposition.Clear();
                            ReadNewLine(buffer, i + 1, lastIndex, false);
                        }
                        else
                        {
                            // reach the end of content-disposition. extract the filename out of it
                            _currentFileName = ParseContentDisposition(_contentDisposition.ToArray());
                            SearchForBoundary(buffer, i + 1, lastIndex);
                        }

                        return;
                    }
                }
                else
                {
                    _newLineIndex = 0;
                }
            }
        }