private static void FormatJsonResponse(HttpListenerResponse response, string version, string status, string timestamp) { try { response.StatusCode = 200; response.StatusDescription = "OK"; response.ContentType = "application/json"; var messageBuffer = new StringBuilder(); messageBuffer.Append("{ \"version\": \""); messageBuffer.Append(version); messageBuffer.Append("\", \"status\": \""); messageBuffer.Append(status); messageBuffer.Append("\", \"timestamp\": \""); messageBuffer.Append(timestamp); messageBuffer.Append("\" }"); byte[] binaryPayload = Encoding.UTF8.GetBytes(messageBuffer.ToString()); response.ContentLength64 = binaryPayload.LongLength; response.OutputStream.Write(binaryPayload, 0, binaryPayload.Length); } finally { response.Close(); } }
private static async Task ServeDirectoryListingAsync(DirectoryInfo root, DirectoryInfo directory, HttpListenerResponse response) { StringBuilder listBuilder = new StringBuilder(); foreach (FileInfo file in directory.EnumerateFiles()) { String target = directory.IsSameDirectory(root) ? file.Name : Path.Combine(directory.Name, file.Name); listBuilder.AppendFormat("<li><a href=\"{0}\">{1}</a></li>", target, file.Name); } foreach (DirectoryInfo subDirectory in directory.EnumerateDirectories()) { String target = directory.IsSameDirectory(root) ? subDirectory.Name : Path.Combine(directory.Name, subDirectory.Name); listBuilder.AppendFormat("<li><a href=\"{0}\">{1}</a></li>", target, subDirectory.Name); } String htmlResponse = String.Format("<ul>{0}</ul>", listBuilder.ToString()); response.ContentType = "text/html"; response.ContentLength64 = htmlResponse.Length; response.AddHeader("Date", DateTime.Now.ToString("r")); response.StatusCode = (Int32)HttpStatusCode.OK; // Must be set before writing to OutputStream. using (StreamWriter writer = new StreamWriter(response.OutputStream)) { await writer.WriteAsync(htmlResponse).ConfigureAwait(false); } }
public Response(HttpListenerResponse response, App app) { _response = response; _writer = new StreamWriter(new BufferedStream(response.OutputStream)); App = app; }
public HttpListenerWebConnection(IWebServer webServer, HttpListenerContext context) : base(webServer, CallingFrom.Web) { Context = context; Request = Context.Request; Response = Context.Response; }
public ListenerResponse(HttpListenerResponse response, IRequest request = null) { this.response = response; this.Request = request; this.Cookies = new Cookies(this); this.Items = new Dictionary <string, object>(); }
private void RespondWithNotFound(HttpListenerRequest request, HttpListenerResponse response) { _log.DebugFormat("Responded with 404 Not Found for url {0}", request.Url); response.StatusCode = 404; response.StatusDescription = "Not Found"; response.OutputStream.Close(); }
public API(ref HttpListenerContext context, Server myServer) { this.QS = context.Request.QueryString; this.Request = context.Request; this.Response = context.Response; this.Method = new APIMethod(ref this.QS); }
/// <summary> /// Initializes a new instance of the <see cref="HttpListenerResponseAdapter" /> class. /// </summary> /// <param name="Response">The <see cref="HttpListenerResponse" /> to adapt for WebDAV#.</param> /// <exception cref="System.ArgumentNullException">Response</exception> /// <exception cref="ArgumentNullException"><paramref name="Response" /> is <c>null</c>.</exception> public HttpListenerResponseAdapter(HttpListenerResponse Response) { if (Response == null) throw new ArgumentNullException("Response"); _response = Response; }
private void request_handler(HttpListenerResponse handler_response, HttpListenerRequest handler_request) { string document = handler_request.RawUrl; string docpath = root_path + document; byte[] responsebyte; if (File.Exists(docpath)) { handler_response.StatusCode = (int)HttpStatusCode.OK; handler_response.ContentType = "text/html"; responsebyte = File.ReadAllBytes(docpath); } else { if (debug) { handler_response.StatusCode = (int)HttpStatusCode.NotFound; string responsestring = "Server running! "; responsestring += "document: " + document + " "; responsestring += "documentpath: " + docpath + " "; responsestring += "root_path " + root_path + " "; responsebyte = System.Text.Encoding.UTF8.GetBytes(responsestring); } else { handler_response.StatusCode = (int)HttpStatusCode.NotFound; handler_response.ContentType = "text/html"; responsebyte = File.ReadAllBytes(root_path + "//error//error.html"); } } handler_response.ContentLength64 = responsebyte.Length; System.IO.Stream output = handler_response.OutputStream; output.Write(responsebyte, 0, responsebyte.Length); output.Close(); }
private static void WriteResponseDto(HttpListenerResponse response, ISerializer serializer, MyDummyResponse responseDto) { using (var writer = new StreamWriter(response.OutputStream, Encoding.UTF8)) { serializer.Serialize(writer, responseDto); } }
public ResponseInstance(ScriptEngine engine, HttpListenerResponse response) : base(engine) { this.Response = response; this.PopulateFields(); this.PopulateFunctions(); }
/// <summary> /// http响应 /// </summary> /// <param name="msg"></param> /// <param name="response"></param> /// <param name="type"></param> public void ResponseWrite(string msg, System.Net.HttpListenerResponse response, string type = "text/plain") { try { //使用Writer输出http响应代码 if (type == "text/plain") { //using (System.IO.StreamWriter writer = new System.IO.StreamWriter(response.OutputStream, new UTF8Encoding())) //{ // response.ContentType = type + ";charset=utf-8"; // writer.WriteLine(msg); // writer.Close(); // response.Close(); //} } using (StreamWriter writer = new StreamWriter(response.OutputStream)) { response.StatusCode = 200; response.Headers.Add("Access-Control-Allow-Origin", "*"); response.ContentType = "application/json"; response.ContentEncoding = Encoding.UTF8; writer.WriteLine(msg); writer.Close(); response.Close(); } } catch (Exception exception) { } }
public override void GetNodesInfoHandler(GetNodesInfoRequest request, System.Net.HttpListenerResponse response) { var writers = Enumerable.Range(0, Global.CloudStorage.PartitionCount).Select(i => new GetNodesInfoRequestWriter(fields: new List <string> { "type_object_name" })).ToArray(); foreach (var id in request.ids) { writers[Global.CloudStorage.GetPartitionIdByCellId(id)].ids.Add(id); } var readers = writers.Select((writer, server) => _GetNodesInfo_impl(server, writer)).ToArray(); var results = readers.Aggregate( (IEnumerable <NodeInfo>) new List <NodeInfo>(), (_, reader) => Enumerable.Concat(_, reader.infoList.Select(infoAccessor => (NodeInfo)infoAccessor))); string result_string = "[" + string.Join(",", results.Select(_ => string.Format(CultureInfo.InvariantCulture, @"{{""CellID"": {0}, ""type_object_name"": {1}}}", _.id, JsonStringProcessor.escape(_.values.First())))) + "]"; using (var sw = new StreamWriter(response.OutputStream)) { sw.Write(result_string); } }
/// <summary> /// Initializes a new instance of the <see cref="HttpListenerResponseAdapter" /> class. /// </summary> /// <param name="response">The <see cref="HttpListenerResponse" /> to adapt for WebDAV#.</param> /// <exception cref="System.ArgumentNullException">Response</exception> /// <exception cref="ArgumentNullException"><paramref name="response" /> is <c>null</c>.</exception> public HttpListenerResponseAdapter(HttpListenerResponse response) { if (response == null) throw new ArgumentNullException(nameof(response)); _response = response; }
/// <summary> /// Выполняет приложение /// Для запросов GET возвращает все записи. /// Для запросов POST создает и сохраняет новые записи. /// </summary> /// <param name="request">Request.</param> /// <param name="response">Response.</param> public override void Run(HttpListenerRequest request, HttpListenerResponse response) { if (request.HttpMethod == "POST") { if (request.HasEntityBody) { // читаем тело запроса string data = null; using (var reader = new StreamReader(request.InputStream)) { data = reader.ReadToEnd (); } if (!string.IsNullOrWhiteSpace(data)) { // формируем коллекцию параметров и их значений Dictionary<string, string> requestParams = new Dictionary<string, string>(); string[] prms = data.Split('&'); for (int i = 0; i < prms.Length; i++) { string[] pair = prms[i].Split('='); requestParams.Add(pair[0], Uri.UnescapeDataString(pair[1]).Replace('+',' ')); } SaveEntry (GuestbookEntry.FromDictionary(requestParams)); } response.Redirect(request.Url.ToString()); return; } } DisplayGuestbook (response); }
private void ResponseException( string method, string path, Exception ex, ISession session, HttpListenerResponse response) { string body = null; var httpStatus = HttpStatusCode.InternalServerError; string contentType = "application/json"; if (ex is FailedCommandException) { var message = new Dictionary<string, object> { { "sessionId", (session != null ? session.ID : null) }, { "status", ((FailedCommandException)ex).Code }, { "value", new Dictionary<string, object> { { "message", ex.Message } // TODO stack trace } } }; body = JsonConvert.SerializeObject(message); } else { httpStatus = HttpStatusCode.BadRequest; contentType = "text/plain"; body = ex.ToString(); } this.WriteResponse(response, httpStatus, contentType, body); }
public static void ResponseWrite(HttpListenerResponse response, string content) { using (StreamWriter sw = new StreamWriter(response.OutputStream)) { sw.Write(content); } }
private void SendHttpResponse(TcpClient client, Stream stream, HttpListenerResponse response, byte[] body) { // Status line var statusLine = $"HTTP/1.1 {response.StatusCode} {response.StatusDescription}\r\n"; var statusBytes = Encoding.ASCII.GetBytes(statusLine); stream.Write(statusBytes, 0, statusBytes.Length); // Headers foreach (var key in response.Headers.AllKeys) { var value = response.Headers[key]; var line = $"{key}: {value}\r\n"; var lineBytes = Encoding.ASCII.GetBytes(line); stream.Write(lineBytes, 0, lineBytes.Length); } // Content-Type header var contentType = Encoding.ASCII.GetBytes($"Content-Type: {response.ContentType}\r\n"); stream.Write(contentType, 0, contentType.Length); // Content-Length header var contentLength = Encoding.ASCII.GetBytes($"Content-Length: {body.Length}\r\n"); stream.Write(contentLength, 0, contentLength.Length); // "Connection: close", to tell the client we can't handle persistent TCP connections var connection = Encoding.ASCII.GetBytes("Connection: close\r\n"); stream.Write(connection, 0, connection.Length); // Blank line to indicate end of headers stream.Write(new[] { (byte)'\r', (byte)'\n' }, 0, 2); // Body stream.Write(body, 0, body.Length); stream.Flush(); // Graceful socket shutdown client.Client.Shutdown(SocketShutdown.Both); client.Dispose(); }
public BrowserSender(HttpListenerContext context) { Context = context; Request = context.Request; Response = context.Response; User = context.User; }
public void HandleGet(HttpListenerRequest request, HttpListenerResponse response) { string queryString = request.Url.Query; var queryParts = Server.ParseQueryString(queryString); string presetName = queryParts.GetFirstValue("preset"); if (string.IsNullOrEmpty(presetName)) { response.StatusCode = 200; response.WriteResponse(presets.GetAll()); } else { string result = presets.Get(presetName); if (result == null) { response.StatusCode = 404; response.WriteResponse("No such preset has been registered"); } else { response.StatusCode = 200; response.WriteResponse(result); } } }
public override object Handle(Project project, object body, HttpListenerResponse response) { return project .GetVersions() .OrderByDescending(v => v) .FirstOrDefault(); }
/// <summary> /// Construct new ServerThread, using HttpListenerContext to populate request and response objects /// </summary> /// <param name="context">The HttpListenerContext of the current request</param> public HttpServerThread(HttpListenerContext context) { _request = context.Request; _response = context.Response; Output.Write(Name + " initialised"); }
private static bool PuppetProcessor(HttpListenerRequest request, HttpListenerResponse response) { string content = null; if (request.HttpMethod == "GET") { var contentId = request.QueryString.Count > 0 ? request.QueryString[0] : null; if (string.IsNullOrEmpty(contentId) || !_contentStore.ContainsKey(contentId)) { response.StatusCode = (int)HttpStatusCode.NotFound; return false; } content = _contentStore[contentId]??""; } else { if (request.HasEntityBody) { using (var sr = new StreamReader(request.InputStream)) { content = sr.ReadToEnd(); } } //response.ContentType = "application/json"; } byte[] buf = Encoding.UTF8.GetBytes(content); response.ContentLength64 = buf.Length; response.OutputStream.Write(buf, 0, buf.Length); return true; }
public HttpListenerResponse(HttpListenerCommunicationContext context, System.Net.HttpListenerResponse response) { _context = context; _nativeResponse = response; Headers = new HttpHeaderDictionary(); Entity = new HttpEntity(Headers, response.OutputStream); }
static void GetFileHandler(HttpListenerRequest request, HttpListenerResponse response) { var query = request.QueryString; string targetLocation = query["target"]; Log ("GetFile: " + targetLocation + "..."); if(File.Exists(targetLocation)) { try { using(var inStream = File.OpenRead(targetLocation)) { response.StatusCode = 200; response.ContentType = "application/octet-stream"; CopyStream(inStream, response.OutputStream); } } catch(Exception e) { Log (e.Message); response.StatusCode = 501; } } else { response.StatusCode = 501; Log ("File doesn't exist"); } }
public override void Process(HttpListenerRequest request, HttpListenerResponse response) { using (var stream = typeof(StaticHandler).Assembly.GetManifestResourceStream("SongRequest.Static.favicon.ico")) { stream.CopyTo(response.OutputStream); } }
/** * Respond with current JSON data. */ void SendResponse(HttpListenerResponse response, string message) { byte[] buffer = Encoding.UTF8.GetBytes(message); response.ContentLength64 = buffer.Length; using (Stream output = response.OutputStream) output.Write(buffer, 0, buffer.Length); }
public HttpEntity(DateTime timeStamp, ICodec requestCodec, ICodec responseCodec, HttpListenerContext context, string[] allowedMethods, Action<HttpEntity> onRequestSatisfied) { Ensure.NotNull(requestCodec, "requestCodec"); Ensure.NotNull(responseCodec, "responseCodec"); Ensure.NotNull(context, "context"); Ensure.NotNull(allowedMethods, "allowedMethods"); Ensure.NotNull(onRequestSatisfied, "onRequestSatisfied"); TimeStamp = timeStamp; UserHostName = context.Request.UserHostName; RequestCodec = requestCodec; ResponseCodec = responseCodec; _context = context; Request = context.Request; Response = context.Response; Manager = new HttpEntityManager(this, allowedMethods, onRequestSatisfied); }
public void Process(HttpListenerRequest request, HttpListenerResponse response) { try { if (request.HttpMethod != "GET") { response.StatusCode = 405; response.StatusDescription = "Method Not Supported"; response.Close(); return; } string version = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion; string status = GetStatusDescription(); string timestamp = DateTime.UtcNow.ToString("s", CultureInfo.InvariantCulture) + "Z"; FormatJsonResponse(response, version, status, timestamp); } catch (HttpListenerException hlex) { Supervisor.LogException(hlex, TraceEventType.Error, request.RawUrl); response.StatusCode = 500; response.StatusDescription = "Error Occurred"; response.Close(); } }
void RequestHandler(HttpListenerRequest req, HttpListenerResponse res) { Console.WriteLine("[RequestHandler: req.url=" + req.Url.ToString()); if (req.Url.AbsolutePath == "/cmd/record/start") { Record.Start(req, res); } else if (req.Url.AbsolutePath == "/cmd/record/stop") { Record.Stop(req, res); } else if (req.Url.AbsolutePath == "/cmd/livingcast/start") { LivingCast.Start(req, res); } else if (req.Url.AbsolutePath == "/cmd/livingcast/stop") { LivingCast.Stop(req, res); } else { res.StatusCode = 404; res.ContentType = "text/plain"; try { StreamWriter sw = new StreamWriter(res.OutputStream); sw.WriteLine("NOT supported command: " + req.Url.AbsolutePath); sw.Close(); } catch { } } }
public override void WriteTo(HttpListenerResponse resp) { base.WriteTo(resp); FileStream fs = new FileStream(_file, FileMode.Open); fs.CopyTo(resp.OutputStream); fs.Close(); }
/// <summary> /// handle left clicks from client /// </summary> /// <param name="response"></param> /// <param name="uri"></param> /// <returns></returns> public override byte[] HandleRequest(HttpListenerResponse response, string[] uri) { // must have 5 tokens if (uri.Length != 7) { response.StatusCode = 400; return BuildHTML("Error..."); } int screen = GetRequestedScreenDevice(uri, screens); bool error = handleMouseDown(uri, screen); if (error) { // parameter error response.StatusCode = 400; return BuildHTML("Error..."); } error = handleMouseUp(uri, screen); if (error) { // parameter error response.StatusCode = 400; return BuildHTML("Error..."); } return BuildHTML("Updating..."); }
/// <summary> /// Get a copy of the requested device screen image from cache /// </summary> /// <param name="response"></param> /// <param name="uri"></param> /// <returns></returns> public override byte[] HandleRequest(HttpListenerResponse response, String[] uri) { int requested = GetRequestedScreenDevice(uri, screens); lastScreenRequested = requested; response.Headers.Set("Content-Type", "image/png"); return caches[requested]; }
public ListenerResponse(HttpListenerResponse response, IRequest request = null) { this.response = response; this.Request = request; this.Cookies = new Cookies(this); this.Items = new Dictionary<string, object>(); }
public HttpListenerResponse(HttpListenerCommunicationContext context, System.Net.HttpListenerResponse response) { _context = context; _nativeResponse = response; Headers = new HttpHeaderDictionary(); Entity = new HttpEntity(Headers, _tempStream); _nativeResponse.SendChunked = false; }
public HttpListenerResponse(HttpListenerCommunicationContext context, System.Net.HttpListenerResponse response) { _context = context; _nativeResponse = response; Headers = new HttpHeaderDictionary(); // TODO: Wrap stream and send chunked when needed if write starts before sending response Entity = new HttpEntity(Headers, _tempStream); _nativeResponse.SendChunked = false; }
static void ResponseWrite(string type, string msg, System.Net.HttpListenerResponse response) { //使用Writer输出http响应代码 using (System.IO.StreamWriter writer = new System.IO.StreamWriter(response.OutputStream, new UTF8Encoding())) { response.ContentType = type + ";charset=utf-8"; writer.WriteLine(msg); writer.Close(); response.Close(); } }
static void httpListenerCallback(IAsyncResult result) { System.Net.HttpListener listener = (System.Net.HttpListener)result.AsyncState; try { if (listener.IsListening) { // continue to listen listener.BeginGetContext(new AsyncCallback(httpListenerCallback), listener); // handle the incoming request System.Net.HttpListenerContext context = listener.EndGetContext(result); System.Net.HttpListenerRequest request = context.Request; string responseString; if (string.Compare("/appletv/us/js/application.js", request.Url.LocalPath, true) == 0) { responseString = System.IO.File.ReadAllText(@"D:\projects\local\atv\com.apple.trailers\application.js"); } else if (string.Compare("/appletv/us/nav.xml", request.Url.LocalPath, true) == 0) { responseString = System.IO.File.ReadAllText(@"D:\projects\local\atv\com.apple.trailers\index.xml"); } else if (string.Compare("/appletv/studios/marvel/ironman3/index-hd.xml", request.Url.LocalPath, true) == 0) { responseString = System.IO.File.ReadAllText(@"D:\projects\local\atv\com.apple.trailers\ironman3.index-hd.xml"); } else if (string.Compare("/appletv/studios/marvel/ironman3/videos/trailer1-hd.xml", request.Url.LocalPath, true) == 0) { responseString = System.IO.File.ReadAllText(@"D:\projects\local\atv\com.apple.trailers\ironman3.videos.trailer1-hd.xml"); } else { responseString = System.IO.File.ReadAllText(@"D:\projects\local\atv\atv\index.xml"); } System.Net.HttpListenerResponse response = context.Response; //string responseString = System.IO.File.ReadAllText(@"D:\projects\local\atv\atv\index.xml"); byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString); response.ContentLength64 = buffer.Length; System.IO.Stream output = response.OutputStream; output.Write(buffer, 0, buffer.Length); output.Close(); } } catch (Exception ex) { } }
/// <summary> /// http响应 /// </summary> /// <param name="msg"></param> /// <param name="response"></param> /// <param name="type"></param> public void ResponseWrite(string msg, System.Net.HttpListenerResponse response, string type = "text/plain") { try { //使用Writer输出http响应代码 using (System.IO.StreamWriter writer = new System.IO.StreamWriter(response.OutputStream, new UTF8Encoding())) { response.ContentType = type + ";charset=utf-8"; writer.WriteLine(msg); writer.Close(); response.Close(); } } catch (Exception exception) { } }
// Send HTTP Response private void sendHTMLResponse(string request) { try { // Get the file content of HTTP Request FileStream fs = new FileStream(request, FileMode.Open, FileAccess.Read, FileShare.None); BinaryReader br = new BinaryReader(fs); // The content Length of HTTP Request byte[] respByte = new byte[(int)fs.Length]; br.Read(respByte, 0, (int)fs.Length); br.Close(); fs.Close(); // 以Response屬性取得HTTP伺服端的輸出串流,則HTTP伺服端之回應 httpResponse = httpContext.Response; // HTTP回應資料內容的大小 httpResponse.ContentLength64 = respByte.Length; // HTTP回應資料內容的MIME格式 httpResponse.ContentType = getContentType(request); // 取得伺服端HTTP回應之資料串流 System.IO.Stream output = httpResponse.OutputStream; // 回應HTML網頁內容至用戶端瀏覽器 output.Write(respByte, 0, respByte.Length); output.Close(); httpResponse.Close(); } catch (Exception ex) { Console.WriteLine("Exception: " + ex.StackTrace.ToString()); if (httpResponse != null) { httpResponse.Close(); } } }
private void OnResponse(System.Net.HttpListenerResponse response, System.Net.HttpListenerRequest request) { String reqStrURlRaw = request.Url.ToString(); if (!LocalResource.LocalFileExist(reqStrURlRaw) && request.UrlReferrer == null) { reqStrURlRaw = "/"; } else { reqStrURlRaw = LocalResource.UrlToLocalRef(reqStrURlRaw, request.UrlReferrer.ToString()); } if (!LocalResource.LocalFileExist(reqStrURlRaw)) { reqStrURlRaw = "/"; } bool bBlockFile = false; FileStream fr = LocalResource.GetFStream(reqStrURlRaw, ref bBlockFile); if (null == fr) { request.InputStream.Close(); return; } BinaryWriter bw = CreateBinaryStreamWriter(response.OutputStream); StreamWriter sw = CreateStringStreamWriter(response.OutputStream); try { byte[] datas = new byte[4096]; int rlen = 0; while ((rlen = fr.Read(datas, 0, datas.Length)) > 0) { if (bBlockFile) { bw.Write(datas); } else { Encoding utf8 = Encoding.UTF8; Encoding unicode = Encoding.Unicode; byte[] dataPtr = datas; if (rlen < 4096) { dataPtr = new byte[rlen]; Array.Copy(datas, dataPtr, rlen); } byte[] uniBytes = Encoding.Convert(utf8, unicode, dataPtr); Char[] uniChars = new Char[unicode.GetCharCount(uniBytes, 0, uniBytes.Length)]; unicode.GetChars(uniBytes, 0, uniBytes.Length, uniChars, 0); sw.Write(new string(uniChars)); dataPtr = null; } } sw.Flush(); bw.Flush(); bw.Close(); sw.Close(); datas = null; } catch { } bw = null; sw = null; fr.Close(); fr = null; }
/// <summary> /// Callback when a HTTP request comes in on the port listener and is handed off /// to a thread for processing. This method /// </summary> /// <param name="result">IAsyncResult containing the HTTPListener</param> public void ListenerCallback(IAsyncResult result) { HttpListener listener = (HttpListener)result.AsyncState; HttpListenerContext context = null; if (listener == null) { return; } try { // The EndGetContext() method, as with all Begin/End asynchronous methods in the .NET Framework, // blocks until there is a request to be processed or some type of data is available. context = listener.EndGetContext(result); } catch (Exception ex) { // You will get an exception when httpListener.Stop() is called // because there will be a thread stopped waiting on the .EndGetContext() // method, and again, that is just the way most Begin/End asynchronous // methods of the .NET Framework work. Console.WriteLine("HttpListener Error", ex); return; } finally { // Once we know we have a request (or exception), we signal the other thread // so that it calls the BeginGetContext() (or possibly exits if we're not // listening any more) method to start handling the next incoming request // while we continue to process this request on a different thread. listenForNextRequest.Set(); } if (context == null) { return; } Console.WriteLine("Start: {0}", DateTime.Now.ToString()); System.Net.HttpListenerRequest request = context.Request; Console.WriteLine("{0}: {1}", PORT, request.RawUrl); if (request.HasEntityBody) { using (System.IO.StreamReader sr = new System.IO.StreamReader(request.InputStream, request.ContentEncoding)) { string requestData = sr.ReadToEnd(); } } // Obtain a response object using (System.Net.HttpListenerResponse response = context.Response) { /* * cmpa --+ * cmpg 4 000000c8 == 0000000000000001 * cmnm 10 648a861f == devicename * cmty 4 648a861f == ipod */ DACPResponse dacpResponse = new PairingClientResponse(); byte[] output = dacpResponse.GetBytes(); Console.WriteLine(new UTF8Encoding(false).GetString(output)); response.StatusCode = (int)HttpStatusCode.OK; response.ContentLength64 = output.LongLength; response.OutputStream.Write(output, 0, output.Length); } Console.WriteLine("End: {0}", DateTime.Now.ToString()); }
public HttpListenerResponse(HttpListenerContext context) { Response = context.Response; }
public SystemHttpResponse(SystemHttpContext context, System.Net.HttpListenerResponse response) { _context = context; _response = response; }
private void WxHttpServer_OnDataReceived(System.Net.HttpListenerRequest reqeust, System.Net.HttpListenerResponse response) { String dataString = ""; if (reqeust.HttpMethod == "POST") { Console.WriteLine("POST"); Stream stream = reqeust.InputStream; BinaryReader binaryReader = new BinaryReader(stream); byte[] data = new byte[reqeust.ContentLength64]; binaryReader.Read(data, 0, (int)reqeust.ContentLength64); dataString = Encoding.UTF8.GetString(data); lock (locker) { foreach (String keyWords in keyWordList) { if (dataString == "") { return; } if (dataString.IndexOf(keyWords) > -1) { DeleteUser(dataString, keyWords); break; } } } } string responseString = ""; byte[] buffer = Encoding.UTF8.GetBytes(responseString); response.ContentLength64 = buffer.Length; Stream output = response.OutputStream; output.Write(buffer, 0, buffer.Length); output.Close(); }
public virtual void onPost(System.Net.HttpListenerRequest request, System.Net.HttpListenerResponse response) { }
public ListenerResponse(System.Net.HttpListenerResponse response) { this.response = response; this.Cookies = new Cookies(this); this.Items = new Dictionary <string, object>(); }
/// <summary> /// Callback when a HTTP request comes in on the port listener and is handed off /// to a thread for processing. This method /// </summary> /// <param name="result">IAsyncResult containing the HTTPListener</param> protected void ListenerCallback(IAsyncResult result) { try { HttpListener listener = (HttpListener)result.AsyncState; HttpListenerContext context = null; if (listener == null) { Console.WriteLine("Listener null so returning..."); return; } try { // The EndGetContext() method, as with all Begin/End asynchronous methods in the .NET Framework, // blocks until there is a request to be processed or some type of data is available. context = listener.EndGetContext(result); } catch (Exception ex) { // You will get an exception when httpListener.Stop() is called // because there will be a thread stopped waiting on the .EndGetContext() // method, and again, that is just the way most Begin/End asynchronous // methods of the .NET Framework work. Console.WriteLine("HttpListener Stopped: {0}", ex.Message); ReleaseAllLatches(); return; } finally { // Once we know we have a request (or exception), we signal the other thread // so that it calls the BeginGetContext() (or possibly exits if we're not // listening any more) method to start handling the next incoming request // while we continue to process this request on a different thread. listenForNextRequest.Set(); } if (context == null) { return; } Console.WriteLine("HTTP START: {0}", DateTime.Now.ToString()); System.Net.HttpListenerRequest request = context.Request; Console.WriteLine("{0}: {1}", PORT, request.RawUrl); if (request.HasEntityBody) { using (System.IO.StreamReader sr = new System.IO.StreamReader(request.InputStream, request.ContentEncoding)) { string requestData = sr.ReadToEnd(); } } bool debug_enabled = true; if (debug_enabled) { Console.WriteLine(" HTTP User-Agent: {0}", request.UserAgent); foreach (String s in request.Headers.AllKeys) { Console.WriteLine(" Header {0,-10} {1}", s, request.Headers[s]); } } // determine if the client is requesting a compressed response string acceptEncoding = request.Headers["Accept-Encoding"]; bool isCompressed = (!string.IsNullOrEmpty(acceptEncoding) && (acceptEncoding.Contains("gzip") || acceptEncoding.Contains("deflate"))); Console.WriteLine("Accept-Encoding: {0} Compressed: {1}", acceptEncoding, isCompressed); // Obtain a response object using (System.Net.HttpListenerResponse response = context.Response) { try { response.ContentType = "application/x-dmap-tagged"; response.AddHeader("DAAP-Server", this.GetApplicationName() + " " + this.Version); this.DispatchRequest(request, response, isCompressed); } catch (DACPSecurityException ex) { Console.WriteLine("DACP Security Error: " + ex.Message); response.StatusCode = (int)HttpStatusCode.Forbidden; response.OutputStream.WriteByte(0); } catch (Exception ex) { Console.WriteLine("DACP Server Error: " + ex.Message); response.StatusCode = DACPResponse.MSTT_NO_CONTENT; response.OutputStream.WriteByte(0); } } } catch (Exception httpEx) { Console.WriteLine("DACP Server Error: " + httpEx.Message, httpEx); } Console.WriteLine("HTTP END: {0}", DateTime.Now.ToString()); }
/// <summary> /// Initializes a new instance of the <see cref="SystemHttpResponse"/> class. /// </summary> /// <param name="context">The context.</param> public SystemHttpResponse(System.Net.HttpListenerContext context) { _response = context.Response; Cookies = new SystemCookieCollection(_response.Cookies); }
internal HttpResponseStream(Stream stream, HttpListenerResponse response, bool ignore_errors) { _response = response; _ignore_errors = ignore_errors; _stream = stream; }
public HttpListenerContext(HttpListenerRequest request, HttpListenerResponse response) { Request = request; Response = response; }
private void WxHttpServer_OnDataReceived(System.Net.HttpListenerRequest reqeust, System.Net.HttpListenerResponse response) { String dataString = ""; string responseString = ""; if (reqeust.HttpMethod == "POST") { Console.WriteLine("POST"); Stream stream = reqeust.InputStream; BinaryReader binaryReader = new BinaryReader(stream); byte[] data = new byte[reqeust.ContentLength64]; binaryReader.Read(data, 0, (int)reqeust.ContentLength64); dataString = Encoding.UTF8.GetString(data); JavaScriptSerializer js = new JavaScriptSerializer(); ClientCmd clientCmd = js.Deserialize <ClientCmd>(dataString); StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append(clientCmd.Wxid); Boolean result = DeleteWxUser(stringBuilder); responseString = ( new { cmd = clientCmd.Cmd, result = result.ToString() } ).ToString(); } byte[] buffer = Encoding.UTF8.GetBytes(responseString); response.ContentLength64 = buffer.Length; Stream output = response.OutputStream; output.Write(buffer, 0, buffer.Length); output.Close(); }
internal HttpListenerContext(HttpConnection cnc) { this.cnc = cnc; request = new HttpListenerRequest(this); response = new HttpListenerResponse(this); }
internal ResponseStream(Stream stream, HttpListenerResponse response, bool ignore_errors) { this.response = response; this.ignore_errors = ignore_errors; this.stream = stream; }
public ListenerResponse(System.Net.HttpListenerResponse response) { this.response = response; this.Cookies = new Cookies(this); }