public static async Task <string> ReadStringAsync(this HttpListenerContext context) { if (!context.Request.HasEntityBody || context.Request.ContentLength64 == 0) { return(null); } //NOTE: Mono breaks keep-alive connection on disponsing HttpRequestStream //using(var stream = request.InputStream) try { //NOTE: Vulnerability #1 part #0: Static pool of request buffers using (var buffer = await RequestBuffersPool.AcquireAsync()) { try { await context.Request.InputStream.ReadToBufferAsync(buffer.Item) .WithTimeout(HttpServerSettings.ReadWriteTimeout) //NOTE: HttpRequestStream is not cancellable with CancellationToken :( .ConfigureAwait(false); } catch (Exception e) { context.Close(408); throw new HttpConnectionClosed(e); } //NOTE: Vulnerability #1 part #1: Do NOT rely on Content-Length field! return(Encoding.UTF8.GetString(buffer.Item, 0, (int)context.Request.ContentLength64)); } } finally { context.Request.InputStream.Close(); } }
private static void HandleRequestThread() { HttpListenerResponse response = null; HttpListenerContext context = null; try { lock (m_responseQueue) { context = (HttpListenerContext)m_responseQueue.Dequeue(); } response = context.Response; HttpListenerRequest request = context.Request; switch (request.HttpMethod.ToUpper()) { case "GET": ProcessClientGetRequest(context); break; case "POST": ProcessClientPostRequest(context); break; } } catch { } finally { if (context != null) { context.Close(); } } }
private static void HandleRequestThread(HttpListenerContext context) { try { foreach (var httpHandlerObj in HttpHandlers) { IHttpHandler httpHandler = httpHandlerObj as IHttpHandler; httpHandler.ProcessRequest(context); } } catch (HttpException exception) { ExceptionHelper.RespondError(context.Response, exception); } catch (Exception exception) { ExceptionHelper.RespondError(context.Response, exception); } finally { if (context != null) { context.Close(); } } }
internal static void RunServer(string prefix) { HttpListener listener = new HttpListener(prefix, -1); // Loads certificate if it is https server. if (prefix == "https") { // // SKU == 3 indicates the device is the emulator. // // The emulator and the device use different certificate types. The emulator requires the use of a .PFX certficate, whereas the device simply // requires a CER certificate with appended private key. In addtion, the .PFX certificate requires a password ("NetMF"). // if (Microsoft.SPOT.Hardware.SystemInfo.SystemID.SKU == 3) { listener.HttpsCert = new X509Certificate(m_emulatorCertData, "NetMF"); } else { string serverCertAsString = HttpServerSample.Resource1.GetString(HttpServerSample.Resource1.StringResources.cert_device_microsoft_com); byte[] serverCertAsArray = Encoding.UTF8.GetBytes(serverCertAsString); listener.HttpsCert = new X509Certificate(serverCertAsArray); } } listener.Start(); while (true) { HttpListenerResponse response = null; HttpListenerContext context = null; try { context = listener.GetContext(); response = context.Response; HttpListenerRequest request = context.Request; switch (request.HttpMethod.ToUpper()) { case "GET": ProcessClientGetRequest(context); break; case "POST": ProcessClientPostRequest(context); break; } if (response != null) { response.Close(); } } catch { if (context != null) { context.Close(); } } } }
public static void Main() { var networkHerlpers = new NetworkHelpers(); networkHerlpers.SetupAndConnectNetwork(true); Console.WriteLine("Waiting for network up and IP address..."); NetworkHelpers.IpAddressAvailable.WaitOne(); Console.WriteLine("Waiting for valid Date & Time..."); NetworkHelpers.DateTimeAvailable.WaitOne(); Thread.Sleep(2000); string prefix = "http"; int port = 80; Console.WriteLine("* Creating Http Listener: " + prefix + " on port " + port); HttpListener listener = new HttpListener(prefix, port); // Start Listener listener.Start(); // After Starting, several exceptions are thrown string ips = $"{NetworkInterface.GetAllNetworkInterfaces()[0].IPv4Address}, {NetworkInterface.GetAllNetworkInterfaces()[1].IPv4Address}, {NetworkInterface.GetAllNetworkInterfaces()[2].IPv4Address}"; Console.WriteLine($"Listening for HTTP requests @ {ips}:{port} ..."); while (true) { try { // now wait on context for a connection HttpListenerContext context = listener.GetContext(); if (context != null) { string url = context.Request.Url.OriginalString; string remoteHost = context.Request.RemoteEndPoint.Address.ToString(); string responseString = $"<HTML><BODY>Hello world! This is nanoFramework.<br/>CurrentTime:{DateTime.UtcNow.ToString()}<br/>Requested URL:{url}<br/>RemoteHost: {remoteHost}<br/>Server IPs:{ips}</BODY></HTML>"; Console.WriteLine($"Request received: {responseString}"); byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString); // Get the response stream and write the response content to it context.Response.ContentLength64 = buffer.Length; context.Response.OutputStream.Write(buffer, 0, buffer.Length); // output stream must be closed context.Response.Close(); // context must be closed context.Close(); } } catch (Exception ex) { Console.WriteLine("* Error getting context: " + ex.Message + "\r\nSack = " + ex.StackTrace); } } }
public static void Main() { X509Certificate _myWebServerCertificate509 = new X509Certificate2(_myWebServerCrt, _myWebServerPrivateKey, ""); var networkHerlpers = new NetworkHelpers(); networkHerlpers.SetupAndConnectNetwork(true); Debug.WriteLine("Waiting for network up and IP address..."); NetworkHelpers.IpAddressAvailable.WaitOne(); Debug.WriteLine("Waiting for valid Date & Time..."); NetworkHelpers.DateTimeAvailable.WaitOne(); // setup HTTP response string responseString = "<HTML><BODY>Hello world! This is nanoFramework.</BODY></HTML>"; byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString); // Create a listener. string prefix = "https"; int port = prefix == "http" ? 80 : 443; Debug.WriteLine("* Creating Http Listener: " + prefix + " on port " + port); HttpListener listener = new HttpListener(prefix, port); // assign server certificate listener.HttpsCert = _myWebServerCertificate509; listener.SslProtocols = System.Net.Security.SslProtocols.Tls | System.Net.Security.SslProtocols.Tls11 | System.Net.Security.SslProtocols.Tls12; Debug.WriteLine($"Listening for HTTP requests @ {NetworkInterface.GetAllNetworkInterfaces()[0].IPv4Address}:{port} ..."); listener.Start(); while (true) { try { // now wait on context for a connection HttpListenerContext context = listener.GetContext(); // Get the response stream and write the response content to it context.Response.ContentLength64 = buffer.Length; context.Response.OutputStream.Write(buffer, 0, buffer.Length); // output stream must be closed context.Response.Close(); // context must be closed context.Close(); } catch (Exception ex) { Debug.WriteLine("* Error getting context: " + ex.Message + "\r\nSack = " + ex.StackTrace); } } }
private void StartWebServer() { // izvietot HttpListener objektu uz 80. porta HttpListener httpListener = new HttpListener("http", 80); // sakt klausities httpListener.Start(); HttpListenerContext httpContext = null; while (true) { try { // wait for incoming request // iegut context'u kas satur pieprasijumu // wait for the incoming request httpContext = httpListener.GetContext(); if (httpContext == null) { continue; } // sagatabot atbildi byte[] response = this.PrepareResponseV3LED(httpContext); // nosutit atbildi this.SendResponse(httpContext, response, 202); // 202 - ACCEPTED } catch (Exception e) { Debug.Print("Error processing listener context: " + e.Message); } finally { if (httpContext != null) { httpContext.Close(); } } } }
public static void Main() { X509Certificate _myWebServerCertificate509 = new X509Certificate2(_myWebServerCrt, _myWebServerPrivateKey, ""); Debug.WriteLine("Waiting for network up and IP address..."); bool success; CancellationTokenSource cs = new(60000); #if BUILD_FOR_ESP32 success = NetworkHelper.ConnectWifiDhcp(MySsid, MyPassword, setDateTime: true, token: cs.Token); #else success = NetworkHelper.WaitForValidIPAndDate(true, System.Net.NetworkInformation.NetworkInterfaceType.Ethernet, cs.Token); #endif if (!success) { Debug.WriteLine($"Can't get a proper IP address and DateTime, error: {NetworkHelper.ConnectionError.Error}."); if (NetworkHelper.ConnectionError.Exception != null) { Debug.WriteLine($"Exception: {NetworkHelper.ConnectionError.Exception}"); } return; } // setup HTTP response string responseString = "<HTML><BODY>Hello world! This is nanoFramework.</BODY></HTML>"; byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString); // Create a listener. string prefix = "https"; int port = prefix == "http" ? 80 : 443; Debug.WriteLine("* Creating Http Listener: " + prefix + " on port " + port); HttpListener listener = new HttpListener(prefix, port); // assign server certificate listener.HttpsCert = _myWebServerCertificate509; listener.SslProtocols = System.Net.Security.SslProtocols.Tls | System.Net.Security.SslProtocols.Tls11 | System.Net.Security.SslProtocols.Tls12; Debug.WriteLine($"Listening for HTTP requests @ {NetworkInterface.GetAllNetworkInterfaces()[0].IPv4Address}:{port} ..."); listener.Start(); while (true) { try { // now wait on context for a connection HttpListenerContext context = listener.GetContext(); // Get the response stream and write the response content to it context.Response.ContentLength64 = buffer.Length; context.Response.OutputStream.Write(buffer, 0, buffer.Length); // output stream must be closed context.Response.Close(); // context must be closed context.Close(); } catch (Exception ex) { Debug.WriteLine("* Error getting context: " + ex.Message + "\r\nSack = " + ex.StackTrace); } } }
private async Task ProcessClient(HttpListenerContext httpContext) { string ip = httpContext.GetIP(); // Check authentication var authResult = auth.Authenticate(httpContext.Request); if (false == authResult.Success || authResult.ClientID == null) { Log.Debug($"Connection from {ip} denied" + (authResult.ClientID != null ? $" (client ID {authResult.ClientID})" : "")); httpContext.Close(HttpStatusCode.Unauthorized); return; } string clientID = authResult.ClientID; // Accept web socket var clientInfo = RpcPeerInfo.Client(clientID, ip); WebSocketContext context; try { context = await httpContext.AcceptWebSocketAsync(subProtocol : null); Log.Debug($"Connected {clientInfo}"); } catch (Exception ex) { Log.Debug($"Could not accept WebSocket to {clientInfo}: {ex.Message}"); httpContext.Close(HttpStatusCode.InternalServerError); return; } // WebSocket loop WebSocket webSocket = context.WebSocket; try { var connection = new WebSocketRpcConnection(clientInfo, webSocket); var channel = await RpcChannel.Create(clientInfo, connection, this, Settings.Backlog); if (channelsByClientID.TryGetValue(clientID, out var oldChannel)) { Log.Debug($"Channel for client {clientID} was already open; close it and open a new one after 3 seconds."); oldChannel.Stop(); await Task.Delay(3000); } channelsByClientID[clientID] = channel; await channel.Start(); Log.Debug($"Connection to {clientInfo} closed"); } catch (Exception ex) { if (ex is WebSocketException wsEx) { Log.Debug($"Connection to {clientInfo} unexpectedly closed: " + wsEx.WebSocketErrorCode); } else { Log.Debug($"Connection to {clientInfo} unexpectedly closed: " + ex.Message); } } finally { webSocket?.Dispose(); } channelsByClientID.Remove(clientID); }
public void Start(string prefix, int port) { if (listener != null) { return; } listener = new HttpListener(prefix, port); // Loads certificate if it is https server. if (prefix == "https") { // SKU == 3 indicates the device is the emulator. // The emulator and the device use different certificate types. The emulator requires the use of a .PFX certficate, whereas the device simply // requires a CER certificate with appended private key. In addtion, the .PFX certificate requires a password ("NetMF"). if (Utils.IsEmulator) { listener.HttpsCert = new X509Certificate(m_emulatorCertData, "NetMF"); } else { string serverCertAsString = Resource1.GetString(Resource1.StringResources.cert_device_microsoft_com); listener.HttpsCert = new X509Certificate(Encoding.UTF8.GetBytes(serverCertAsString)); } } listener.Start(); isStopped = false; new Thread(() => { while (!isStopped) { try { if (!listener.IsListening) { listener.Start(); } HttpListenerContext context = listener.GetContext(); // see http://netmf.codeplex.com/workitem/2157 //new Thread(() => { try { if (OnRequest != null) { OnRequest(context.Request); } switch (context.Request.HttpMethod.ToUpper()) { case "GET": ProcessClientGetRequest(context); break; case "POST": ProcessClientPostRequest(context); break; } // for test: //SendStream(Encoding.UTF8.GetBytes("<html><body>" + DateTime.Now + "</body></html>"), "text/html", context.Response); context.Close(); } catch (Exception e) { Debug.Print(e.Message); } } //).Start(); } //catch (InvalidOperationException ex) //{ // listener.Stop(); // Thread.Sleep(1000); //} //catch (ObjectDisposedException ex) //{ // listener.Start(); //} //catch (SocketException ex) //{ // if (ex.ErrorCode == 10053) // listener.Stop(); //} catch (Exception ex) { //Thread.Sleep(1000); //if (context != null) // context.Close(); } } // stopped listener.Close(); listener = null; }) { Priority = ThreadPriority.Normal }.Start(); }
#pragma warning restore 0649 private static void AddComment(HttpListenerContext client, int categoryIndex) { var r = client.Request; string name = null, email = null, text = null; int replyTo = -1; var buf = new byte[r.ContentLength64]; var query = Encoding.UTF8.GetString(buf, 0, r.InputStream.Read(buf, 0, buf.Length)); var param = query.Split('&'); foreach (var p in param) { var segments = p.Split(new[] { '=' }, 2); if (segments.Length < 2) { client.Error(HttpStatusCode.BadRequest); return; } var value = Uri.UnescapeDataString(segments[1]).Replace('+', ' '); if (segments[0] == "name") { name = value; } else if (segments[0] == "email") { email = value; } else if (segments[0] == "comment") { text = value; } else if (segments[0] == "replyTo") { replyTo = int.Parse(segments[1]); } } if (name == null || text == null) { client.Error(HttpStatusCode.BadRequest); return; } var article = articles[categoryIndex][r.Url.Segments[2]]; var comment = new Comment(name, text, article.CommentCount, replyTo); if (!Validate(comment, article)) { client.Error(HttpStatusCode.BadRequest); return; } article.AddComment(comment); if (client.Request.Url.Query.Contains("returnSelf")) { client.WriteAndClose(GenerateCommentHtml(comment, ""), "html", HttpStatusCode.Created); } else { // This should prevent accidently submitting a form multiple times client.SetHeader("Location", client.Request.Url); client.Close(HttpStatusCode.SeeOther); } }
/// <summary> /// Processes a message /// </summary> /// <param name="msg">The message being processed.</param> /// <param name="ctx">The context associated with the message.</param> /// <returns>The handling status for this operation.</returns> protected override ChainResult OnProcessOutputMessage(ref WsMessage msg, BindingContext ctx) { ArrayList props = ctx.BindingProperties; byte[] message = null; string contentType = "text/plain"; if (msg != null) { message = msg.Body as byte[]; if (msg.BodyParts != null) { contentType = "Multipart/Related;boundary=" + msg.MtomPropeties.boundary + ";type=\"application/xop+xml\";start=\"" + msg.MtomPropeties.start + "\";start-info=\"application/soap+xml\""; ctx.BindingProperties.Add(new BindingProperty("header", HttpKnownHeaderNames.Server, "Microsoft-MF HTTP 1.0")); ctx.BindingProperties.Add(new BindingProperty("header", HttpKnownHeaderNames.MimeVersion, "1.0")); ctx.BindingProperties.Add(new BindingProperty("header", HttpKnownHeaderNames.Date, DateTime.Now.ToString())); } else { contentType = "application/soap+xml; charset=utf-8"; } } if (ctx is ClientBindingContext) { if (message == null) { return(ChainResult.Abort); } HttpWebRequest request; try { if (!m_persistConn || ctx.ContextObject == null) { request = HttpWebRequest.Create(new Uri(m_transportUri.AbsoluteUri)) as HttpWebRequest; request.Timeout = (int)(ctx.OpenTimeout.Ticks / TimeSpan.TicksPerMillisecond); request.ReadWriteTimeout = (int)(ctx.ReceiveTimeout.Ticks / TimeSpan.TicksPerMillisecond); ctx.ContextObject = request; } else { request = (HttpWebRequest)ctx.ContextObject; request.Reset(); } // Post method request.Method = "POST"; WebHeaderCollection headers = request.Headers; request.ContentType = contentType; request.UserAgent = "MFWsAPI"; request.Headers.Add(HttpKnownHeaderNames.CacheControl, "no-cache"); request.Headers.Add(HttpKnownHeaderNames.Pragma, "no-cache"); if (props != null) { int len = props.Count; for (int i = 0; i < len; i++) { BindingProperty prop = (BindingProperty)props[i]; string container = prop.Container; if (container == "header") { headers.Add(prop.Name, (string)prop.Value); } else if (container == null || container == "") { string name = prop.Name; if (name == HttpKnownHeaderNames.ContentType) { request.ContentType = (string)prop.Value; } else if (name == HttpKnownHeaderNames.UserAgent) { request.UserAgent = (string)prop.Value; } } } } if (message != null) { System.Ext.Console.Write("Http message sent: "); System.Ext.Console.Write(message); request.ContentLength = message.Length; using (Stream stream = request.GetRequestStream()) { // Write soap message stream.Write(message, 0, message.Length); // Flush the stream and force a write stream.Flush(); } } } catch { ctx.ContextObject = null; throw; } } else { HttpListenerContext listenerContext = ctx.ContextObject as HttpListenerContext; if (listenerContext == null) { return(ChainResult.Abort); } HttpListenerResponse listenerResponse = listenerContext.Response; if (listenerResponse == null || listenerResponse.OutputStream == null) { ctx.ContextObject = null; return(ChainResult.Abort); } try { StreamWriter streamWriter = new StreamWriter(listenerResponse.OutputStream); // Write Header, if message is null write accepted if (message == null || (msg != null && msg.Header != null && msg.Header.IsFaultMessage)) { listenerResponse.StatusCode = 202; } else { listenerResponse.StatusCode = 200; } // Check to see it the hosted service is sending mtom WebHeaderCollection headers = listenerResponse.Headers; listenerResponse.ContentType = contentType; bool isChunked = false; if (props != null) { int len = props.Count; for (int i = 0; i < len; i++) { BindingProperty prop = (BindingProperty)props[i]; string container = prop.Container; string name = prop.Name; string value = (string)prop.Value; if (container == "header") { if (!isChunked && name == HttpKnownHeaderNames.TransferEncoding && value.ToLower() == "chunked") { isChunked = true; } headers.Add(name, (string)prop.Value); } else if (container == null || container == "") { if (name == HttpKnownHeaderNames.ContentType) { listenerResponse.ContentType = (string)prop.Value; System.Ext.Console.Write(HttpKnownHeaderNames.ContentType + ": " + listenerResponse.ContentType); } } } } // If chunked encoding is enabled write chunked message else write Content-Length if (isChunked) { // Chunk message int bufferIndex = 0; int chunkSize = 0; int defaultChunkSize = 0xff; #if DEBUG byte[] displayBuffer = new byte[defaultChunkSize]; #endif while (bufferIndex < message.Length) { // Calculate chunk size and write to stream chunkSize = message.Length - bufferIndex < defaultChunkSize ? message.Length - bufferIndex : defaultChunkSize; streamWriter.WriteLine(chunkSize.ToString("{0:X}")); System.Ext.Console.Write(chunkSize.ToString("{0:X}")); // Write chunk streamWriter.WriteBytes(message, bufferIndex, chunkSize); streamWriter.WriteLine(); #if DEBUG Array.Copy(message, bufferIndex, displayBuffer, 0, chunkSize); System.Ext.Console.Write(displayBuffer, bufferIndex, chunkSize); #endif // Adjust buffer index bufferIndex = bufferIndex + chunkSize; } // Write 0 length and blank line streamWriter.WriteLine("0"); streamWriter.WriteLine(); System.Ext.Console.Write("0"); System.Ext.Console.Write(""); } else { if (message == null) { listenerResponse.ContentLength64 = 0; } else { listenerResponse.ContentLength64 = message.Length; } System.Ext.Console.Write("Content Length: " + listenerResponse.ContentLength64); // If an empty message is returned (i.e. oneway request response) don't send if (message != null && message.Length > 0) { System.Ext.Console.Write(message); // Write soap message streamWriter.WriteBytes(message, 0, message.Length); } } // Flush the stream and return streamWriter.Flush(); } catch { return(ChainResult.Abort); } finally { if (m_persistConn) { listenerResponse.Detach(); } else { listenerContext.Close(ctx.CloseTimeout.Seconds); ctx.ContextObject = null; } } } return(ChainResult.Handled); }