public ChunkedInputStream(HttpListenerContext context, Stream stream,
byte[] buffer, int offset, int length)
: base(stream, buffer, offset, length)
{
_context = context;
Decoder = new ChunkStream(context.Request.Headers);
}
internal WebSocketContext(HttpListenerContext context, string protocol)
{
_context = context;
WebSocket = new WebSocket(this, protocol);
}
void Cleanup(bool closeExisting)
{
lock (_registry)
{
if (closeExisting)
{
// Need to copy this since closing will call UnregisterContext
var keys = _registry.Keys;
var all = new HttpListenerContext[keys.Count];
keys.CopyTo(all, 0);
_registry.Clear();
for (var i = all.Length - 1; i >= 0; i--)
all[i].Connection.Close(true);
}
lock (_connections.SyncRoot)
{
var keys = _connections.Keys;
var conns = new HttpConnection[keys.Count];
keys.CopyTo(conns, 0);
_connections.Clear();
for (var i = conns.Length - 1; i >= 0; i--)
conns[i].Close(true);
}
lock (_ctxQueue)
{
var ctxs = (HttpListenerContext[])_ctxQueue.ToArray(typeof(HttpListenerContext));
_ctxQueue.Clear();
for (var i = ctxs.Length - 1; i >= 0; i--)
ctxs[i].Connection.Close(true);
}
lock (_waitQueue)
{
Exception exc = new ObjectDisposedException("listener");
foreach (ListenerAsyncResult ares in _waitQueue)
{
ares.Complete(exc);
}
_waitQueue.Clear();
}
}
}
internal AuthenticationSchemes SelectAuthenticationScheme(HttpListenerContext context)
{
return AuthenticationSchemeSelectorDelegate?.Invoke(context.Request) ?? _authSchemes;
}
internal void RegisterContext(HttpListenerContext context)
{
lock (_registry)
_registry[context] = context;
ListenerAsyncResult ares = null;
lock (_waitQueue)
{
if (_waitQueue.Count == 0)
{
lock (_ctxQueue)
_ctxQueue.Add(context);
}
else
{
ares = (ListenerAsyncResult)_waitQueue[0];
_waitQueue.RemoveAt(0);
}
}
ares?.Complete(context);
}
internal void UnregisterContext(HttpListenerContext context)
{
lock (_registry)
_registry.Remove(context);
lock (_ctxQueue)
{
var idx = _ctxQueue.IndexOf(context);
if (idx >= 0)
_ctxQueue.RemoveAt(idx);
}
}
internal void Complete(HttpListenerContext context, bool synch)
{
#if AUTHENTICATION
if (_forward != null)
{
_forward.Complete(context, synch);
return;
}
#endif
_synch = synch;
_context = context;
lock (_locker)
{
#if AUTHENTICATION
var schemes = context.Listener.SelectAuthenticationScheme(context);
if ((schemes == AuthenticationSchemes.Basic ||
context.Listener.AuthenticationSchemes == AuthenticationSchemes.Negotiate) &&
context.Request.Headers["Authorization"] == null)
{
context.Response.StatusCode = 401;
context.Response.Headers["WWW-Authenticate"] = schemes + " realm=\"" + context.Listener.Realm + "\"";
context.Response.OutputStream.Dispose();
var ares = context.Listener.BeginGetContext(_cb, _state);
_forward = (ListenerAsyncResult) ares;
lock (_forward._locker)
{
if (_handle != null)
_forward._handle = _handle;
}
var next = _forward;
for (var i = 0; next._forward != null; i++)
{
if (i > 20)
Complete(new HttpListenerException(400, "Too many authentication errors"));
next = next._forward;
}
}
else
{
#endif
_completed = true;
_synch = false;
_handle?.Set();
if (_cb != null)
ThreadPool.QueueUserWorkItem(_invokeCb, this);
#if AUTHENTICATION
}
#endif
}
}
internal HttpListenerResponse(HttpListenerContext context)
{
_context = context;
}
internal void Complete(HttpListenerContext context)
{
Complete(context, false);
}
internal HttpListenerRequest(HttpListenerContext context)
{
_context = context;
Headers = new NameValueCollection();
ProtocolVersion = HttpVersion.Version10;
}
internal void UnregisterContext(HttpListenerContext context) => _ctxQueue.TryRemove(context.Id, out _);
internal void UnregisterContext(HttpListenerContext context)
{
HttpListenerContext removedContext;
_ctxQueue.TryRemove(context.Id, out removedContext);
}
internal AuthenticationSchemes SelectAuthenticationScheme(HttpListenerContext context)
{
return(AuthenticationSchemeSelectorDelegate?.Invoke(context.Request) ?? _authSchemes);
}
