| public AddHeader ( string name, string value ) : void | ||
| name | string | |
| value | string | |
| return | void | |
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 void Map(Response response, HttpListenerResponse result)
{
result.StatusCode = response.StatusCode;
response.Headers.ToList().ForEach(pair => result.AddHeader(pair.Key, pair.Value));
if (response.Body != null)
{
var content = Encoding.UTF8.GetBytes(response.Body);
result.OutputStream.Write(content, 0, content.Length);
}
}
/*
* Prepare Output Stream, using gzip if supported */
protected Stream PrepareOutputStream(HttpListenerRequest request, HttpListenerResponse response)
{
string accept = request.Headers.Get("Accept-Encoding");
Stream outputStream = response.OutputStream;
if (accept != null && accept.Contains("gzip"))
{
response.AddHeader("Content-Encoding", "gzip");
outputStream = new GZipStream(response.OutputStream, CompressionMode.Compress);
}
return outputStream;
}
public static async Task ResponseText(HttpListenerResponse response, string localFilePath, string contentType)
{
var text = File.ReadAllText(localFilePath);
response.ContentType = contentType;
response.ContentEncoding = Encoding.UTF8;
response.AddHeader("Charset", Encoding.UTF8.WebName);
var textBytes = Encoding.UTF8.GetBytes(text);
response.ContentLength64 = textBytes.LongLength;
await response.OutputStream.WriteAsync(textBytes, 0, textBytes.Length);
}
public static void deserializeResponse(string response, HttpListenerResponse originalResponse)
{
var headerResponse = JsonConvert.DeserializeObject<HeaderRespons> (response);
if (relayIdSet.Contains (headerResponse.rid))
relayIdSet.Remove (headerResponse.rid);
originalResponse.StatusCode = headerResponse.statusCode;
foreach (var h in headerResponse.headers) {
if (HeaderUtil.isEndToEndHeader (h.Key))
originalResponse.AddHeader (h.Key, h.Value);
}
//originalResponse.OutputStream.Write (headerResponse.body, 0, headerResponse.body.Length);
}
void PrepareContext(HttpListenerResponse tragetRsp, HttpWebResponse sourceRsp)
{
tragetRsp.ContentEncoding = Encoding.GetEncoding(sourceRsp.CharacterSet);
tragetRsp.ContentType = sourceRsp.ContentType;
foreach (string k in sourceRsp.Headers)
foreach (string v in sourceRsp.Headers.GetValues(k))
{
if (string.Equals(k, "Content-Length", StringComparison.OrdinalIgnoreCase))
continue;
tragetRsp.AddHeader(k, v);
}
}
public static void SendResponse(HttpListenerResponse response, string pluginName, string content)
{
CoreManager.ServerCore.GetStandardOut().PrintDebug("WebAdmin Response [" + pluginName + "]: " + content);
byte[] buffer = Encoding.UTF8.GetBytes(content);
response.StatusCode = (int) HttpStatusCode.OK;
response.StatusDescription = "OK";
response.ContentType = "text/html; charset=UTF-8";
response.ContentLength64 = buffer.Length;
response.ContentEncoding = Encoding.UTF8;
response.AddHeader("plugin-name", pluginName);
response.OutputStream.Write(buffer, 0, buffer.Length);
response.OutputStream.Close();
response.Close();
}
public void WriteHeaders()
{
if (HeadersSent)
{
throw new InvalidOperationException("The headers have already been sent.");
}
_nativeResponse.Headers.Clear();
foreach (var header in Headers.Where(h => h.Key != "Content-Length"))
{
try
{
_nativeResponse.AddHeader(header.Key, header.Value);
}
catch (Exception ex)
{
if (_context != null)
{
_context.ServerErrors.Add(new Error {
Message = ex.ToString()
});
}
}
}
HeadersSent = true;
_nativeResponse.ContentLength64 = Headers.ContentLength.GetValueOrDefault();
// TODO: Enable streaming straight back to native response output sting
// Guard against a possible HttpListenerException : The specified network name is no longer available
try
{
_tempStream.WriteTo(_nativeResponse.OutputStream);
}
catch (HttpListenerException ex)
{
if (_context != null)
{
_context.ServerErrors.Add(new Error {
Message = ex.ToString()
});
}
}
}
public void SendResponse(HttpListenerRequest request, HttpListenerResponse response)
{
var stream = new FileLoader(request.Url.AbsolutePath).LoadStream();
response.ContentLength64 = stream.Length;
response.SendChunked = false;
response.ContentType = request.ContentType;
response.AddHeader("Content-disposition", "attachment; filename=" + request.RawUrl.Remove(0, 1));
writeTo(stream, response.OutputStream);
response.StatusCode = (int)HttpStatusCode.OK;
response.StatusDescription = "OK";
stream.Close();
response.Close();
Console.WriteLine("200");
}
private static void ConvertNancyResponseToResponse(Response nancyResponse, HttpListenerResponse response)
{
foreach (var header in nancyResponse.Headers)
{
response.AddHeader(header.Key, header.Value);
}
foreach (var nancyCookie in nancyResponse.Cookies)
{
response.Cookies.Add(ConvertCookie(nancyCookie));
}
response.ContentType = nancyResponse.ContentType;
response.StatusCode = (int)nancyResponse.StatusCode;
using (var output = response.OutputStream)
{
nancyResponse.Contents.Invoke(output);
}
}
public Ansver SaveInfo(HttpListenerRequest request, HttpListenerResponse response)
{
Stream inputStream = request.InputStream;
Console.WriteLine("������ ����������� �����������");
Console.WriteLine("���������� ������ �� ������:");
string result = "";
int last;
string uriPath = request.Url.AbsolutePath.Split('/')[2];
try
{
byte[] ansver = new byte[request.ContentLength64];
request.InputStream.Read(ansver, 0, (int)request.ContentLength64);
result = Encoding.UTF8.GetString(ansver);
Console.WriteLine(result);
Directory.CreateDirectory(path + uriPath);
List<string> allfiles = new List<string>(Directory.GetFiles(path + uriPath, "*.txt"));
allfiles.Sort();
last = this.GetLast(allfiles);
StreamWriter writer = new StreamWriter(path + uriPath + "/" + (last).ToString() + ".txt",false, Encoding.UTF8);
writer.Write(result);
Console.WriteLine("������ ���������.");
writer.Close();
response.AddHeader("id", last.ToString());
response.StatusCode = (int) HttpStatusCode.Created;
return new Ansver(null, response);
}
catch (Exception exception)
{
Console.WriteLine("������ ����������, ��������� ������: " + exception.Message);
response.StatusCode = (int) HttpStatusCode.InternalServerError;
return new Ansver(null, response);
}
}
public void SendZippedResponse(HttpListenerResponse response, ByteResponseData data)
{
response.AddHeader("Content-Encoding", "gzip");
response.ContentType = data.ContentType.GetValue();
byte[] buffer = data.Content;
using (MemoryStream ms = new MemoryStream())
{
using (GZipStream zip = new GZipStream(ms, CompressionMode.Compress))
{
zip.Write(buffer, 0, buffer.Length);
}
buffer = ms.ToArray();
}
WriteAndFlushResponse(response, buffer);
}
public void AddHeader(string name, string value)
{
response.AddHeader(name, value);
}
public void AddLastModifiedAndExpires(HttpListenerResponse response, string lastModified, string expires)
{
response.AddHeader("Last-Modified", lastModified);
response.AddHeader("Expires", expires);
}
/// <summary>
/// Adds a set of HTTP headers to an <see cref="HttpResponse"/> instance,
/// taking care to set some headers to the appropriate properties of
/// <see cref="HttpResponse" />
/// </summary>
/// <param name="headers">The headers to add.</param>
/// <param name="response">The <see cref="HttpListenerResponse"/> instance to set the appropriate values to.</param>
private static void ApplyHeadersToResponse(HttpResponseHeaders headers, HttpListenerResponse response) {
Requires.NotNull(headers, "headers");
Requires.NotNull(response, "response");
foreach (var header in headers) {
switch (header.Key) {
case "Content-Type":
response.ContentType = header.Value.First();
break;
// Add more special cases here as necessary.
default:
response.AddHeader(header.Key, header.Value.First());
break;
}
}
}
static void PleaseAuthenticate(HttpListenerResponse Response)
{
Response.StatusCode = 401;
Response.AddHeader("WWW-Authenticate", "Basic realm=\"Spacecraft Server\"");
string response =
@"<!DOCTYPE HTML PUBLIC {0}-//W3C//DTD HTML 4.01 Transitional//EN{0}
{0}http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd{0}>
<HTML>
<HEAD>
<TITLE>Error</TITLE>
<META HTTP-EQUIV={0}Content-Type{0} CONTENT={0}text/html; charset=ISO-8859-1{0}>
</HEAD>
<BODY><H1>401 Unauthorized.</H1></BODY>
</HTML>";
response = String.Format(response, "\"");
byte[] bytes = ASCIIEncoding.ASCII.GetBytes(response);
Response.OutputStream.Write(bytes, 0, bytes.Length);
}
private static void ConvertNancyResponseToResponse(Response nancyResponse, HttpListenerResponse response)
{
foreach (var header in nancyResponse.Headers)
{
response.AddHeader(header.Key, header.Value);
}
foreach (var nancyCookie in nancyResponse.Cookies)
{
response.Headers.Add(HttpResponseHeader.SetCookie, nancyCookie.ToString());
}
response.ContentType = nancyResponse.ContentType;
response.StatusCode = (int)nancyResponse.StatusCode;
//HACK:This can probably be done nicely with som tweeking.
if (nancyResponse is EventStreamWriterResponse)
{
nancyResponse.Contents.Invoke(response.OutputStream);
}
else
{
using (var output = response.OutputStream)
{
nancyResponse.Contents.Invoke(output);
}
}
}
private void SendJSON(HttpListenerResponse response) {
string JSON = "{\"id\": 0, \"Text\": \"Sensor\", \"Children\": [";
nodeCount = 1;
JSON += GenerateJSON(root);
JSON += "]";
JSON += ", \"Min\": \"Min\"";
JSON += ", \"Value\": \"Value\"";
JSON += ", \"Max\": \"Max\"";
JSON += ", \"ImageURL\": \"\"";
JSON += "}";
var responseContent = JSON;
byte[] buffer = Encoding.UTF8.GetBytes(responseContent);
response.AddHeader("Cache-Control", "no-cache");
response.ContentLength64 = buffer.Length;
response.ContentType = "application/json";
try {
Stream output = response.OutputStream;
output.Write(buffer, 0, buffer.Length);
output.Close();
} catch (HttpListenerException) {
}
response.Close();
}
private void ProcessRequest(HttpListenerRequest request, HttpListenerResponse response)
{
response.AddHeader("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
response.AddHeader("Pragma", "no-cache");
IRequestHandler handler = AssignRequestHandler(request);
if (handler != null)
{
handler.Process(request, response);
}
else
{
FinalizeIgnoredResponse(response, 404, "Resource Not Found");
}
}
/// <summary>
///
/// </summary>
/// <param name="response"></param>
public HttpListentGameResponse(HttpListenerResponse response)
{
_response = response;
response.ContentType = "application/octet-stream";
response.AddHeader("Access-Control-Allow-Origin", "*");
}
private static async Task CopyFrom(HttpListenerResponse response, HttpResponseMessage message,
IReadOnlyDictionary<string, Dictionary<Regex, string>> rules)
{
response.StatusCode = (int)message.StatusCode;
foreach (var httpResponseHeader in message.Headers.Where(header => !ResponseFilter.Contains(header.Key)))
{
foreach (var value in httpResponseHeader.Value)
{
response.AddHeader(httpResponseHeader.Key, value);
}
}
foreach (
var httpResponseHeader in message.Content.Headers.Where(header => !ResponseFilter.Contains(header.Key)))
{
foreach (var value in httpResponseHeader.Value)
{
response.AddHeader(httpResponseHeader.Key, value);
}
}
response.SendChunked = false;
response.KeepAlive = false;
var bytes = await message.Content.ReadAsByteArrayAsync();
if (bytes.Length <= 0) return;
if (message.Content.Headers.ContentType != null && rules.ContainsKey(message.Content.Headers.ContentType.MediaType))
{
var rule = rules[message.Content.Headers.ContentType.MediaType];
var encoding = GetEncoding(message.Content.Headers.ContentType.CharSet);
var content = encoding.GetString(bytes);
content = Replace(content, rule);
bytes = encoding.GetBytes(content);
}
response.ContentLength64 = bytes.Length;
await response.OutputStream.WriteAsync(bytes, 0, bytes.Length);
}
public byte[] GetHTML500(HttpListenerResponse response)
{
try
{
// I know this statuscode is dumb, but the client doesn't respond to 404s and 500s
response.StatusCode = (int)HttpStatusCode.OK;
response.AddHeader("Content-type", "text/html");
string responseString = GetHTTP500();
byte[] buffer = Encoding.UTF8.GetBytes(responseString);
response.ContentEncoding = Encoding.UTF8;
return buffer;
}
catch
{
}
return null;
}
static bool ServeFile(string path, HttpListenerResponse httpResponse)
{
if(!File.Exists(path))
{
return false;
}
// http://stackoverflow.com/a/13386573/4264
using(var fs = File.OpenRead(path))
{
httpResponse.StatusCode = (int)HttpStatusCode.OK;
httpResponse.ContentLength64 = fs.Length;
httpResponse.SendChunked = false;
httpResponse.ContentType = GetContentType(Path.GetExtension(path));
if(httpResponse.ContentType == "application/octet-stream")
{
httpResponse.AddHeader("Content-disposition", "attachment; filename=" +
Path.GetFileName(path));
}
byte[] buffer = new byte[64 * 1024];
int read;
using(BinaryWriter bw = new BinaryWriter(httpResponse.OutputStream))
{
while((read = fs.Read(buffer, 0, buffer.Length)) > 0)
{
bw.Write(buffer, 0, read);
bw.Flush(); //seems to have no effect
}
}
}
return true;
}
/// <summary>
///
/// </summary>
/// <param name="response"></param>
/// <param name="data"></param>
/// <param name="offset"></param>
/// <param name="count"></param>
public void PushSend(HttpListenerResponse response, byte[] data, int offset, int count)
{
response.ContentType = "application/octet-stream";
if (data[offset] == 0x1f && data[offset + 1] == 0x8b && data[offset + 2] == 0x08 && data[offset + 3] == 0x00)
{
response.AddHeader("Content-Encoding", "gzip");
}
response.AddHeader("Access-Control-Allow-Origin", "*");
response.ContentLength64 = count;
Stream output = response.OutputStream;
output.Write(data, offset, count);
output.Close();
}
public void Send(HttpListenerResponse listenerResponse)
{
Headers
.Where(r => r.Key != "Content-Type")
.ForEach(header => listenerResponse.AddHeader(header.Key, header.Value));
listenerResponse.ContentType = Headers["Content-Type"];
listenerResponse.StatusCode = StatusCode;
WriteStream(listenerResponse.OutputStream)
.Do(stream =>
{
try
{
stream.Close(); stream.Dispose();
}
catch
{
}
}, error => { try { listenerResponse.StatusCode = 500; listenerResponse.OutputStream.Close(); } catch { } })
.Retry()
.Subscribe();
}
void Exception (HttpListenerResponse response, Exception exception)
{
var id = CreateExceptionId ();
exceptions [id] = exception;
response.AddHeader (ExceptionHeaderName, id.ToString ());
if (exception == null)
return;
response.StatusCode = 500;
using (var writer = new StreamWriter (response.OutputStream)) {
writer.WriteLine (string.Format ("EXCEPTION: {0}", exception));
}
response.Close ();
}
private static void ConvertNancyResponseToResponse(Response nancyResponse, HttpListenerResponse response)
{
foreach (var header in nancyResponse.Headers)
{
response.AddHeader(header.Key, header.Value);
}
foreach (var nancyCookie in nancyResponse.Cookies)
{
response.Headers.Add(HttpResponseHeader.SetCookie, nancyCookie.ToString());
}
response.ContentType = nancyResponse.ContentType;
response.StatusCode = (int)nancyResponse.StatusCode;
var output = response.OutputStream;
nancyResponse.Contents.Invoke(output);
if (nancyResponse.DisposeStream)
{
output.Dispose();
}
}
private void ConvertNancyResponseToResponse(Response nancyResponse, HttpListenerResponse response)
{
foreach (var header in nancyResponse.Headers)
{
response.AddHeader(header.Key, header.Value);
}
foreach (var nancyCookie in nancyResponse.Cookies)
{
response.Headers.Add(HttpResponseHeader.SetCookie, nancyCookie.ToString());
}
if (nancyResponse.ReasonPhrase != null)
{
response.StatusDescription = nancyResponse.ReasonPhrase;
}
if (nancyResponse.ContentType != null)
{
response.ContentType = nancyResponse.ContentType;
}
response.StatusCode = (int)nancyResponse.StatusCode;
if (configuration.AllowChunkedEncoding)
{
OutputWithDefaultTransferEncoding(nancyResponse, response);
}
else
{
OutputWithContentLength(nancyResponse, response);
}
}
/// <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());
}
private void ConvertResponse(Response response, HttpListenerResponse httpResponse)
{
foreach (var header in response.Headers)
{
if (!IgnoredHeaders.IsIgnored(header.Key))
{
httpResponse.AddHeader(header.Key, header.Value);
}
}
foreach (var cookie in response.Cookies)
{
httpResponse.Headers.Add(HttpResponseHeader.SetCookie, cookie.ToString());
}
if (response.ReasonPhrase != null)
{
httpResponse.StatusDescription = response.ReasonPhrase;
}
if (response.ContentType != null)
{
httpResponse.ContentType = response.ContentType;
}
httpResponse.StatusCode = (int)response.StatusCode;
OutputWithContentLength(response, httpResponse);
}
private static void WriteResponse(string aUrl, HttpWebResponse aProxiedResponse, HttpListenerResponse aResponse)
{
aResponse.StatusCode = (int)aProxiedResponse.StatusCode;
aResponse.StatusDescription = aProxiedResponse.StatusDescription;
int contentLength = 0;
foreach (var key in aProxiedResponse.Headers.AllKeys)
{
switch (key.ToUpper())
{
case "CONTENT-LENGTH":
// don't set aResponse.ContentLength64 yet as we may re-write some content below (if we're serving Node.js)
contentLength = Convert.ToInt32(aProxiedResponse.Headers.GetValues(key)[0]);
break;
case "CONTENT-TYPE":
case "EXT":
case "SERVER":
string[] values = aProxiedResponse.Headers.GetValues(key);
foreach (string val in values)
aResponse.Headers.Add(key, val);
break;
case "TRANSFER-ENCODING":
aResponse.SendChunked = (String.Compare(aProxiedResponse.Headers.GetValues(key)[0], "chunked", true) == 0);
break;
case "CONNECTION":
aResponse.Headers.Add(key, aProxiedResponse.Headers.GetValues(key)[0]);
break;
default:
Logger.InfoFormat("Ignored header in response: {0}", key);
break;
}
}
bool useGzip = false;
if (!aResponse.SendChunked && contentLength > 512 /* no point in zipping tiny responses */ &&
aProxiedResponse.ContentType != null &&
!(aProxiedResponse.ContentType.Contains("image/png") || aProxiedResponse.ContentType.Contains("image/jpeg")))
// no point in wasting time zipping a format that is already compressed
useGzip = true;
Stream clientRespStream = aResponse.OutputStream;
using (Stream respStream = aProxiedResponse.GetResponseStream())
{
if (aUrl.EndsWith("/Node.js"))
{
RewriteNodeJsFile(aResponse, respStream);
}
else if (!useGzip)
{
if (contentLength > 0) // response may be chunked
aResponse.ContentLength64 = contentLength;
respStream.CopyTo(clientRespStream);
}
else
{
aResponse.AddHeader("Content-Encoding", "gzip");
MemoryStream zip = new MemoryStream();
using (var zipper = new GZipStream(zip, CompressionMode.Compress, true))
{
respStream.CopyTo(zipper);
}
zip.Seek(0, SeekOrigin.Begin);
aResponse.ContentLength64 = zip.Length;
//Console.WriteLine("Compressed {0} to {1} bytes", contentLength, zip.Length);
zip.CopyTo(clientRespStream);
}
}
clientRespStream.Close();
}