//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)); }
internal HttpListenerRequest(HttpListenerContext context) { _context = context; _contentLength = -1; _headers = new WebHeaderCollection (); _identifier = Guid.NewGuid (); }
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); }
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); }
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 processRequest(WebSocketSharp.Net.HttpListenerContext context) { EventHandler <HttpRequestEventArgs> eventHandler; string httpMethod = context.Request.HttpMethod; if (httpMethod == "GET") { eventHandler = this.OnGet; } else if (httpMethod == "HEAD") { eventHandler = this.OnHead; } else if (httpMethod == "POST") { eventHandler = this.OnPost; } else if (httpMethod == "PUT") { eventHandler = this.OnPut; } else if (httpMethod == "DELETE") { eventHandler = this.OnDelete; } else if (httpMethod == "OPTIONS") { eventHandler = this.OnOptions; } else if (httpMethod == "TRACE") { eventHandler = this.OnTrace; } else if (httpMethod == "CONNECT") { eventHandler = this.OnConnect; } else if (httpMethod == "PATCH") { eventHandler = this.OnPatch; } else { eventHandler = null; } EventHandler <HttpRequestEventArgs> eventHandler1 = eventHandler; if (eventHandler1 == null) { context.Response.StatusCode = 501; } else { eventHandler1(this, new HttpRequestEventArgs(context)); } context.Response.Close(); }
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); }
private void receiveRequest() { while (true) { try { WebSocketSharp.Net.HttpListenerContext context = this._listener.GetContext(); ThreadPool.QueueUserWorkItem((object state) => { try { if (!context.Request.IsUpgradeTo("websocket")) { this.processRequest(context); } else { this.processRequest(context.AcceptWebSocket(null)); } } catch (Exception exception) { this._logger.Fatal(exception.ToString()); context.Connection.Close(true); } }); } catch (WebSocketSharp.Net.HttpListenerException httpListenerException1) { WebSocketSharp.Net.HttpListenerException httpListenerException = httpListenerException1; this._logger.Warn(string.Concat("Receiving has been stopped.\n reason: ", httpListenerException.Message)); break; } catch (Exception exception1) { this._logger.Fatal(exception1.ToString()); break; } } if (this.IsListening) { this.abort(); } }
internal AuthenticationSchemes SelectAuthenticationScheme(HttpListenerContext context) { if (AuthenticationSchemeSelectorDelegate != null) return AuthenticationSchemeSelectorDelegate (context.Request); else return auth_schemes; }
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 void UnregisterContext (HttpListenerContext context) { lock (_ctxRegistrySync) _ctxRegistry.Remove (context); lock (_ctxQueueSync) { var idx = _ctxQueue.IndexOf (context); if (idx >= 0) _ctxQueue.RemoveAt (idx); } }
internal AuthenticationSchemes SelectAuthenticationScheme (HttpListenerContext context) { return AuthenticationSchemeSelector != null ? AuthenticationSchemeSelector (context.Request) : _authSchemes; }
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 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); }
internal HttpListenerWebSocketContext(WebSocketSharp.Net.HttpListenerContext context, string protocol) { this._context = context; this._websocket = new WebSocketSharp.WebSocket(this, protocol); }
private bool closeConnection() { _readyState = WsState.CLOSED; try { if (_httpContext != null) { _httpContext.Response.Close(); _wsStream = null; _httpContext = null; } if (_wsStream != null) { _wsStream.Dispose(); _wsStream = null; } if (_tcpClient != null) { _tcpClient.Close(); _tcpClient = null; } return true; } catch (Exception ex) { onError(ex.Message); return false; } }
internal WebSocket(HttpListenerWebSocketContext context) : this() { _uri = Ext.ToUri(context.Path); _context = context; _httpContext = context.BaseContext; _wsStream = context.Stream; _endPoint = context.ServerEndPoint; _isClient = false; _isSecure = context.IsSecureConnection; }
internal HttpListenerResponse(HttpListenerContext context) { this.context = context; Init(); }
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 static WsStream CreateServerStream(HttpListenerContext context) { var conn = context.Connection; return new WsStream (conn.Stream, conn.IsSecure); }
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 void Complete (HttpListenerContext context) { Complete (context, false); }
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 Complete(HttpListenerContext context) { Complete(context, false); }
internal void UnregisterContext(HttpListenerContext context) { lock (_ctxRegistrySync) _ctxRegistry.Remove (context); }
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); }
internal HttpListenerWebSocketContext(HttpListenerContext context) { _context = context; _stream = WsStream.CreateServerStream(context); _socket = new WebSocket(this); }
private void cleanupContextRegistry () { lock (_ctxRegistrySync) { if (_ctxRegistry.Count == 0) return; // Need to copy this since closing will call the UnregisterContext method. var keys = _ctxRegistry.Keys; var ctxs = new HttpListenerContext[keys.Count]; keys.CopyTo (ctxs, 0); _ctxRegistry.Clear (); for (var i = ctxs.Length - 1; i >= 0; i--) ctxs[i].Connection.Close (true); } }
private static bool authenticate( HttpListenerContext context, AuthenticationSchemes scheme, string realm, Func<IIdentity, NetworkCredential> credentialsFinder) { if (!(scheme == AuthenticationSchemes.Basic || scheme == AuthenticationSchemes.Digest)) { context.Response.Close (HttpStatusCode.Forbidden); return false; } var req = context.Request; var user = HttpUtility.CreateUser ( req.Headers["Authorization"], scheme, realm, req.HttpMethod, credentialsFinder); if (user != null && user.Identity.IsAuthenticated) { context.User = user; return true; } if (scheme == AuthenticationSchemes.Basic) context.Response.CloseWithAuthChallenge ( AuthenticationChallenge.CreateBasicChallenge (realm).ToBasicString ()); if (scheme == AuthenticationSchemes.Digest) context.Response.CloseWithAuthChallenge ( AuthenticationChallenge.CreateDigestChallenge (realm).ToDigestString ()); return false; }
internal bool Authenticate (HttpListenerContext context) { var schm = SelectAuthenticationScheme (context); if (schm == AuthenticationSchemes.Anonymous) return true; if (schm != AuthenticationSchemes.Basic && schm != AuthenticationSchemes.Digest) { context.Response.Close (HttpStatusCode.Forbidden); return false; } var realm = Realm; var req = context.Request; var user = HttpUtility.CreateUser ( req.Headers["Authorization"], schm, realm, req.HttpMethod, UserCredentialsFinder); if (user != null && user.Identity.IsAuthenticated) { context.User = user; return true; } if (schm == AuthenticationSchemes.Basic) context.Response.CloseWithAuthChallenge ( AuthenticationChallenge.CreateBasicChallenge (realm).ToBasicString ()); if (schm == AuthenticationSchemes.Digest) context.Response.CloseWithAuthChallenge ( AuthenticationChallenge.CreateDigestChallenge (realm).ToDigestString ()); return false; }
internal HttpRequestEventArgs (HttpListenerContext context) { _request = context.Request; _response = context.Response; }
internal void RegisterContext (HttpListenerContext context) { lock (_ctxRegistrySync) _ctxRegistry[context] = context; HttpListenerAsyncResult ares = null; lock (_waitQueueSync) { if (_waitQueue.Count == 0) { lock (_ctxQueueSync) _ctxQueue.Add (context); } else { ares = _waitQueue[0]; _waitQueue.RemoveAt (0); } } if (ares != null) ares.Complete (context); }
internal void Complete (HttpListenerContext context, bool syncCompleted) { var listener = context.Listener; var scheme = listener.SelectAuthenticationScheme (context); if (scheme == AuthenticationSchemes.None) { context.Response.Close (HttpStatusCode.Forbidden); listener.BeginGetContext (this); return; } var header = context.Request.Headers ["Authorization"]; if (scheme == AuthenticationSchemes.Basic && (header == null || !header.StartsWith ("basic", StringComparison.OrdinalIgnoreCase))) { context.Response.CloseWithAuthChallenge ( HttpUtility.CreateBasicAuthChallenge (listener.Realm)); listener.BeginGetContext (this); return; } if (scheme == AuthenticationSchemes.Digest && (header == null || !header.StartsWith ("digest", StringComparison.OrdinalIgnoreCase))) { context.Response.CloseWithAuthChallenge ( HttpUtility.CreateDigestAuthChallenge (listener.Realm)); listener.BeginGetContext (this); return; } _context = context; _syncCompleted = syncCompleted; lock (_sync) { _completed = true; if (_waitHandle != null) _waitHandle.Set (); if (_callback != null) ThreadPool.QueueUserWorkItem(invokeCallback, this); } }
internal AuthenticationSchemes SelectAuthenticationScheme(HttpListenerContext context) { return(AuthenticationSchemeSelector != null ? AuthenticationSchemeSelector(context.Request) : _authSchemes); }