internal HttpListenerRequest(HttpListenerContext context)
 {
     _context = context;
       _contentLength = -1;
       _headers = new WebHeaderCollection ();
       _identifier = Guid.NewGuid ();
 }

 public ChunkedRequestStream (
   HttpListenerContext context, Stream stream, byte [] buffer, int offset, int length)
   : base (stream, buffer, offset, length)
 {
   _context = context;
   _decoder = new ChunkStream ((WebHeaderCollection) context.Request.Headers);
 }

 internal ChunkedRequestStream (
   Stream stream, byte[] buffer, int offset, int count, HttpListenerContext context)
   : base (stream, buffer, offset, count)
 {
   _context = context;
   _decoder = new ChunkStream ((WebHeaderCollection) context.Request.Headers);
 }

        //This gets called when the listener receives a request
        private void ProcessRequest (HttpListenerContext context)
        {
            var getContext = Task.Factory.FromAsync<HttpListenerContext>(_listener.BeginGetContext, _listener.EndGetContext, null);
            getContext.ContinueWith(t => ProcessRequest(t.Result));

            _router.HandleRequest(ContextGenerator(context));
        }

        public ChunkedInputStream(
			HttpListenerContext context, Stream stream, byte [] buffer, int offset, int length)
            : base(stream, buffer, offset, length)
        {
            this.context = context;
            WebHeaderCollection coll = (WebHeaderCollection) context.Request.Headers;
            decoder = new ChunkStream (coll);
        }

 internal HttpListenerResponse (HttpListenerContext context)
 {
   _context = context;
   _keepAlive = true;
   _statusCode = 200;
   _statusDescription = "OK";
   _version = HttpVersion.Version11;
 }

        private void InitTask(HttpListenerContext context)
        {
            try
            {
                var task = this.ProcessRequestAsync(context);
                task.ContinueWith(x => HandleError(x.Exception, context), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent);

                if (task.Status == TaskStatus.Created)
                {
                    task.RunSynchronously();
                }
            }
            catch (Exception ex)
            {
                HandleError(ex, context);
            }
        }

        private Task ProcessRequestAsync(HttpListenerContext context)
        {
            var request = context.Request;

            LogHttpRequest(request);

            if (request.IsWebSocketRequest)
            {
                ProcessWebSocketRequest(context);
                return Task.FromResult(true);
            }

            if (string.IsNullOrEmpty(context.Request.RawUrl))
                return ((object)null).AsTaskResult();

            var httpReq = GetRequest(context);

            return RequestHandler(httpReq, request.Url);
        }

 internal void Complete (HttpListenerContext context)
 {
   Complete (context, false);
 }

 internal static WsStream CreateServerStream(HttpListenerContext context)
 {
     var conn = context.Connection;
       return new WsStream (conn.Stream, conn.IsSecure);
 }

        internal void Complete(HttpListenerContext context, bool syncCompleted)
        {
            var listener = context.Listener;
              var schm = listener.SelectAuthenticationScheme (context);
              if (schm != AuthenticationSchemes.Anonymous &&
              !authenticate (context, schm, listener.Realm, listener.UserCredentialsFinder)) {
            listener.BeginGetContext (this);
            return;
              }

              _context = context;
              _syncCompleted = syncCompleted;

              lock (_sync)
            complete (this);
        }

        void CleanupContextRegistry()
        {
            lock (((ICollection)registry).SyncRoot) {
                if (registry.Count == 0)
                    return;

                // Need to copy this since closing will call UnregisterContext
                ICollection keys = registry.Keys;
                var all = new HttpListenerContext [keys.Count];
                keys.CopyTo (all, 0);
                registry.Clear ();
                for (int i = all.Length - 1; i >= 0; i--)
                    all [i].Connection.Close (true);
            }
        }

 internal AuthenticationSchemes SelectAuthenticationScheme(HttpListenerContext context)
 {
     if (AuthenticationSchemeSelectorDelegate != null)
         return AuthenticationSchemeSelectorDelegate (context.Request);
     else
         return auth_schemes;
 }

    internal void UnregisterContext (HttpListenerContext context)
    {
      lock (_ctxRegistrySync)
        _ctxRegistry.Remove (context);

      lock (_ctxQueueSync) {
        var idx = _ctxQueue.IndexOf (context);
        if (idx >= 0)
          _ctxQueue.RemoveAt (idx);
      }
    }

        internal void RegisterContext(HttpListenerContext context)
        {
            lock (((ICollection)registry).SyncRoot)
                registry [context] = context;

            ListenerAsyncResult ares = null;
            lock (((ICollection)wait_queue).SyncRoot) {
                if (wait_queue.Count == 0) {
                    lock (((ICollection)ctx_queue).SyncRoot)
                        ctx_queue.Add (context);
                } else {
                    ares = wait_queue [0];
                    wait_queue.RemoveAt (0);
                }
            }

            if (ares != null)
                ares.Complete (context);
        }

        internal bool RegisterContext(HttpListenerContext context)
        {
            if (!_listening)
            return false;

              lock (_ctxRegistrySync) {
            if (!_listening)
              return false;

            _ctxRegistry[context] = context;

            var ares = getAsyncResultFromQueue ();
            if (ares == null)
              _ctxQueue.Add (context);
            else
              ares.Complete (context);

            return true;
              }
        }

        internal void UnregisterContext(HttpListenerContext context)
        {
            lock (((ICollection)registry).SyncRoot)
                registry.Remove (context);

            lock (((ICollection)ctx_queue).SyncRoot) {
                int idx = ctx_queue.IndexOf (context);
                if (idx >= 0)
                    ctx_queue.RemoveAt (idx);
            }
        }

 internal void UnregisterContext(HttpListenerContext context)
 {
     lock (_ctxRegistrySync)
     _ctxRegistry.Remove (context);
 }

 public ResponseEventArgs(HttpListenerContext context)
 {
     Request  = context.Request;
       Response = context.Response;
 }

    internal void Complete (HttpListenerContext context, bool syncCompleted)
    {
      var lsnr = context.Listener;
      if (!lsnr.Authenticate (context)) {
        lsnr.BeginGetContext (this);
        return;
      }

      _context = context;
      _syncCompleted = syncCompleted;

      lock (_sync)
        complete (this);
    }