static void SendAsset(HttpListenerResponse rp, string assetName)
{
rp.AddHeader("Content-Type", Mime.GetType(assetName));
Stream os = rp.OutputStream;
byte[] asset = null;
if (cachedAssets.TryGetValue(assetName, out asset))
{
rp.ContentLength64 = asset.LongLength;
os.Write(asset, 0, asset.Length);
os.Close();
}
}
void SendFriendlyHtmlPage(HttpListenerResponse response)
{
var message = getFriendlyHtmlPageContent();
var headers = getFriendlyHtmlPageHeaders();
response.AddHeader("Content-Type", "text/html; charset=utf-8");
foreach (var header in headers)
{
response.AddHeader(header.Key, header.Value);
}
// This could fail if the client terminates the connection and we attempt to write to it
// Disposing the StreamWriter will close the stream - it owns the stream
using (var writer = new StreamWriter(response.OutputStream, new UTF8Encoding(false))
{
NewLine = "\r\n"
})
{
writer.WriteLine(message);
writer.Flush();
}
}
public static void CreateResponse(this HttpListenerResponse response, HttpStatusCode statusCode,
Stream contentStream, string contentType)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
try
{
var assemblyName = Assembly.GetEntryAssembly().GetName();
string serverName = assemblyName.Name;
string serverVersion = assemblyName.Version.ToString();
response.StatusCode = (int)statusCode;
response.AddHeader("Date", DateTime.UtcNow.ToString("R"));
response.Headers.Remove("Server");
response.AddHeader("Server", $"{serverName}/{serverVersion}");
response.ContentType = contentType;
response.ContentLength64 = contentStream.Length;
var buffer = new byte[1024 * 16];
int nbytes;
while ((nbytes = contentStream.Read(buffer, 0, buffer.Length)) > 0)
{
response.OutputStream.Write(buffer, 0, nbytes);
}
response.OutputStream.Flush();
}
catch
{
response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
finally
{
response.OutputStream.Close();
}
}
/// <summary>
/// リクエスト時の処理を実行する
/// </summary>
/// <param name="result">結果</param>
private static async void OnRequested(IAsyncResult result)
{
HttpListener clsListener = (HttpListener)result.AsyncState;
if (!clsListener.IsListening)
{
return;
}
HttpListenerContext context = clsListener.EndGetContext(result);
HttpListenerRequest req = context.Request;
HttpListenerResponse res = context.Response;
res.AddHeader("Access-Control-Allow-Origin", "*"); // どこからのリクエストでも受け取る
res.AddHeader("Access-Control-Allow-Headers", "*"); // どこからのリクエストでも受け取る
res.AddHeader("Access-Control-Allow-Methods", "*"); // どこからのリクエストでも受け取る
try
{
await mapper.Execute(req, res);
}
catch (Exception ex)
{
// log.Error(ex.ToString());
}
finally
{
try
{
if (null != res)
{
res.Close();
}
}
catch (Exception clsEx)
{
// log.Error(clsEx.ToString());
}
}
}
private void OnHttpResponse(HttpClientConnection connection, byte[] data, int offset, int count)
{
try
{
connection.TimeoutTimer.Dispose();
HttpListenerResponse response = connection.Context.Response;
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();
connection.Close();
}
catch
{
}
}
internal static void JourneysDelete(HttpListenerRequest request, HttpListenerResponse response)
{
// in: CarID, StartPosID, EndPosId
// out: CarID, StartPosID, EndPosId
// action: render really delete HTML
response.AddHeader("Content-Type", "text/html; charset=utf-8");
StringBuilder sb = new StringBuilder();
int journeyID = Convert.ToInt32(GetUrlParameterValue(request, "id"), Tools.ciEnUS);
try
{
using (MySqlConnection con = new MySqlConnection(DBHelper.DBConnectionstring))
{
con.Open();
using (MySqlCommand cmd = new MySqlCommand(@"
SELECT
journeys.name,
cars.display_name,
tripStart.Start_address,
tripEnd.End_address
FROM
journeys,
cars,
trip tripStart,
trip tripEnd
WHERE
journeys.CarID = cars.Id
AND journeys.StartPosID = tripStart.StartPosID
AND journeys.EndPosID = tripEnd.EndPosID
AND journeys.ID = @journeyID", con))
{
cmd.Parameters.AddWithValue("@journeyID", journeyID);
Tools.DebugLog(cmd);
MySqlDataReader dr = SQLTracer.TraceDR(cmd);
if (dr.Read())
{
sb.Append($@"
<tr><td>{WebUtility.HtmlEncode(TEXT_LABEL_REALLY_DELETE)} {WebUtility.HtmlEncode(dr[0].ToString())} ({WebUtility.HtmlEncode(dr[1].ToString())}) - {WebUtility.HtmlEncode(dr[2].ToString())}{WebUtility.HtmlEncode("-->")}{WebUtility.HtmlEncode(dr[3].ToString())}?</td>
<td><form action=""{EndPoints["JourneysDeleteDelete"]}""><input type=""hidden"" name=""id"" value=""{journeyID}""><button type=""submit"">{WebUtility.HtmlEncode(TEXT_BUTTON_DELETE_DELETE)}</button></form></td>
");
}
}
}
}
catch (Exception ex)
{
ex.ToExceptionless().FirstCarUserID().Submit();
Logfile.Log(ex.ToString());
sb.Append(ex.ToString());
}
WriteString(response, html1 + sb.ToString() + html2);
}
private string HandleRequest(HttpListenerRequest request, HttpListenerResponse response, string data)
{
if (request.RawUrl.StartsWith("/FormHttpServer/"))
{
// /FormHttpServer/CheckAccount { "name" : "admin", "password" : "123456" }
return(HttpServer.HandleObjectMethod(request, request.RawUrl, data, this).Result);
}
else
{
if (request.HttpMethod == "GET")
{
if (returnWeb.ContainsKey(request.RawUrl))
{
response.AddHeader("Content-type", $"{comboBox1.SelectedItem.ToString( )}; charset=utf-8");
return(returnWeb[request.RawUrl]);
}
else
{
response.AddHeader("Content-type", $"{comboBox1.SelectedItem.ToString( )}; charset=utf-8");
// return HttpServer.HandleObjectMethod( request, data, this );
return("123456");
}
}
else if (request.HttpMethod == "POST")
{
// POST示例，在data中可以上传复杂的数据，长度不限制的
if (postWeb.ContainsKey(request.RawUrl))
{
response.AddHeader("Content-type", $"{comboBox1.SelectedItem.ToString( )}; charset=utf-8");
return(postWeb[request.RawUrl]);
}
}
else
{
}
return(string.Empty);
}
}
private void SendHeaders()
{
if (_HeadersSent)
{
throw new IOException("Headers already sent.");
}
_Response.ContentLength64 = ContentLength;
_Response.StatusCode = StatusCode;
_Response.StatusDescription = GetStatusDescription(StatusCode);
_Response.SendChunked = ChunkedTransfer;
_Response.ContentType = ContentType;
if (Headers != null && Headers.Count > 0)
{
foreach (KeyValuePair <string, string> header in Headers)
{
if (String.IsNullOrEmpty(header.Key))
{
continue;
}
_Response.AddHeader(header.Key, header.Value);
}
}
if (_Settings.Headers != null)
{
foreach (KeyValuePair <string, string> header in _Settings.Headers)
{
if (!Headers.Any(h => h.Key.ToLower().Equals(header.Key.ToLower())))
{
_Response.AddHeader(header.Key, header.Value);
}
}
}
_HeadersSent = true;
}
private void ProcessContext(HttpListenerContext context)
{
HttpListenerRequest request = context.Request;
string httpMethod = request.HttpMethod;
string requestBody = string.Empty;
if (string.Compare(httpMethod, "POST", StringComparison.OrdinalIgnoreCase) == 0)
{
int totalBytesRead = 0;
byte[] bodyData = new byte[request.ContentLength64];
while (totalBytesRead < request.ContentLength64)
{
totalBytesRead += request.InputStream.Read(bodyData, totalBytesRead, (int)request.ContentLength64 - totalBytesRead);
}
requestBody = Encoding.UTF8.GetString(bodyData);
}
// Obtain a response object.
HttpListenerResponse response = context.Response;
ServerResponse result = this.DispatchRequest(request.Url, httpMethod, requestBody);
if (result.StatusCode == HttpStatusCode.SeeOther)
{
response.AddHeader("Location", request.Url.AbsoluteUri + "/" + result.ReturnedResponse.Value.ToString());
result.ReturnedResponse.Value = string.Empty;
}
string responseString = result.ReturnedResponse.ToJson();
// Construct a response.
byte[] buffer = Encoding.UTF8.GetBytes(responseString);
response.ContentType = result.ContentType;
response.StatusCode = (int)result.StatusCode;
response.StatusDescription = result.StatusCode.ToString();
// Get a response stream and write the response to it.
response.ContentLength64 = buffer.Length;
Stream output = response.OutputStream;
output.Write(buffer, 0, buffer.Length);
// We must close the output stream.
output.Close();
if (request.Url.AbsolutePath.ToUpperInvariant().Contains(ShutdownUrlFragment))
{
this.OnShutdownRequested(new EventArgs());
}
}
private HttpStatusCode SendOkResponse(FileReadResults fileReadResults)
{
_response.StatusCode = (int)HttpStatusCode.OK;
_response.Headers.Add(HttpResponseHeader.ContentType, GetContentTypeByFileExtension(fileReadResults.FileExtension));
_response.Headers.Add(HttpResponseHeader.Date, DateTime.Now.ToLongDateString());
_response.AddHeader("content-disposition", $"attachment;filename={fileReadResults.FileName}");
var buffer = fileReadResults.FileBytes;
_context.Response.ContentLength64 = buffer.Length;
_context.Response.OutputStream.Write(buffer, 0, buffer.Length);
return(HttpStatusCode.OK);
}
public static void WriteResult(this HttpListenerResponse response, HttpStatusCode statusCode, string text)
{
response.StatusCode = (int)statusCode;
response.AddHeader("Charset", Encoding.UTF8.WebName);
response.ContentEncoding = Encoding.UTF8;
var bytes = Encoding.UTF8.GetBytes(text);
response.ContentLength64 = bytes.LongLength;
response.OutputStream.Write(bytes, 0, bytes.Length);
}
private void Debug_TeslaAPI(string path, HttpListenerRequest request, HttpListenerResponse response)
{
int position = path.LastIndexOf('/');
if (position > -1)
{
path = path.Substring(position + 1);
if (path.Length > 0 && WebHelper.TeslaAPI_Commands.TryGetValue(path, out string TeslaAPIJSON))
{
response.AddHeader("Content-Type", "application/json");
WriteString(response, TeslaAPIJSON);
}
}
}
private void HeyListen(HttpAuthenticationService httpAuth)
{
using (HttpListener listener = new HttpListener())
{
listener.Prefixes.Add(Config.HttpPrefix);
listener.AuthenticationSchemes = AuthenticationSchemes.Basic;
listener.Start();
while (true)
{
HttpListenerContext context = listener.GetContext();
HttpListenerBasicIdentity identity = (HttpListenerBasicIdentity)context.User.Identity;
if (identity == null || !httpAuth.Authenticate(identity.Name, identity.Password))
{
HttpListenerResponse authResponse = context.Response;
authResponse.AddHeader("WWW-Authenticate", "Basic");
authResponse.StatusCode = (int)HttpStatusCode.Unauthorized;
using (StreamWriter writer = new StreamWriter(authResponse.OutputStream))
{
writer.Write("NO!");
writer.Flush();
}
continue;
}
var userId = Helper.GetUserId(identity.Name);
var guildId = Helper.GetGuildId(identity.Name);
HttpListenerRequest request = context.Request;
string command;
using (StreamReader reader = new StreamReader(request.InputStream))
{
command = reader.ReadToEnd();
}
HttpListenerResponse response = context.Response;
string responseString;
try
{
responseString = HandleHttpCommand(command, userId, guildId);
}
catch (Exception ex)
{
responseString = ex.ToString();
response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
using (StreamWriter writer = new StreamWriter(response.OutputStream))
{
writer.Write(responseString);
writer.Flush();
}
}
}
}
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();
}
private void ManageRequests()
{
HttpListenerContext context = listener.GetContext();
HttpListenerRequest request = context.Request;
HttpListenerResponse response = context.Response;
response.AddHeader("Access-Control-Allow-Origin", "*");
HTTPResponse httpResponse = null;
string responseStr = MatchRequest(request, ref httpResponse);
HTTPResponse.AddHTTPResponseToResponse(httpResponse, ref response);
SendResponse(response, responseStr);
}
private static void SendSelectableOptions(HttpListenerResponse Response, string returnOptions)
{
Response.StatusCode = (int)HttpStatusCode.Accepted;
Response.StatusDescription = "OK";
Response.SendChunked = false;
Response.AddHeader("Content-Disposition", "text/plain");
byte[] buffer = Encoding.UTF8.GetBytes(returnOptions);
Response.ContentLength64 = buffer.Length;
Stream output = Response.OutputStream;
output.Write(buffer, 0, buffer.Length);
output.Close();
}
public async void file(string filePath)
{
if (!File.Exists(filePath))
{
send(StaticTemplates.NoFoundTemplate(filePath), 404, "text/html");
return;
}
try
{
HttpListenerResponse response = context.Response;
response.KeepAlive = true;
response.SendChunked = true;
context.Response.StatusCode = (int)HttpStatusCode.OK;
string mime;
var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
response.ContentType = ServerHelpers.mimeTypesMap.TryGetValue(Path.GetExtension(filePath), out mime) ? mime : "undefined";
response.ContentLength64 = stream.Length;
response.AddHeader("Accept-Ranges", "bytes");
response.AddHeader("Date", DateTime.Now.ToString("r"));
response.AddHeader("Last-Modified", System.IO.File.GetLastWriteTime(filePath).ToString("r"));
response.AddHeader("Content-Range", string.Format("bytes {0}-{1}/{2}", 0, Convert.ToInt32(stream.Length) - 1, Convert.ToInt32(stream.Length)));
response.ContentLength64 = stream.Length;
await stream.CopyToAsync(context.Response.OutputStream);
await stream.FlushAsync();
response.Close();
}
catch (Exception ex)
{
if (JintAddons.debug)
{
Log.Error(ex.Message + " " + ex.StackTrace);
}
}
}
public HttpListenerResponse HandleStaticRequest()
{
string filename = Path.Combine(directory, request.Url.Segments[1]);
if (File.Exists(filename))
{
try
{
Stream input = new FileStream(filename, FileMode.Open);
response.ContentType = "text/html";
response.ContentLength64 = input.Length;
response.AddHeader("Date", DateTime.Now.ToString("r"));
response.AddHeader("Last-Modified", File.GetLastWriteTime(filename).ToString("r"));
byte[] buffer = new byte[1024 * 32];
int nbytes;
while ((nbytes = input.Read(buffer, 0, buffer.Length)) > 0)
{
response.OutputStream.Write(buffer, 0, nbytes);
}
input.Close();
response.OutputStream.Flush();
response.StatusCode = (int)HttpStatusCode.OK;
}
catch (Exception ex)
{
response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
}
else
{
response.StatusCode = (int)HttpStatusCode.NotFound;
}
return(response);
}
public static async Task CopyFromAsync(this HttpListenerResponse response, HttpResponseMessage message,
IContentProcessor contentProcessor)
{
response.StatusCode = (int)message.StatusCode;
foreach (var httpResponseHeader in message.Headers.Where(header => !Filter.Contains(header.Key)))
{
foreach (var value in httpResponseHeader.Value)
{
response.AddHeader(httpResponseHeader.Key, value);
}
}
foreach (var httpResponseHeader in message.Content.Headers.Where(header => !Filter.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 (contentProcessor != null)
{
bytes = contentProcessor.Process(bytes, message.Content.Headers.ContentType,
message.RequestMessage.RequestUri);
}
response.ContentLength64 = bytes.Length;
await response.OutputStream.WriteAsync(bytes, 0, bytes.Length);
}
private void ProcessRequest(HttpListenerContext context)
{
var responseString = "";
int statuscode = 200;
try
{
var body = JsonConvert.DeserializeObject <PlayerRequest>(new StreamReader(context.Request.InputStream).ReadToEnd());
switch (context.Request.HttpMethod)
{
case "GET":
responseString = JsonConvert.SerializeObject(ProcessGet(body));
break;
case "POST":
responseString = JsonConvert.SerializeObject(ProcessPost(body));
break;
}
}
catch (Exception ex)
{
responseString = ex.Message;
statuscode = 500;
}
HttpListenerResponse response = context.Response;
response.AddHeader("Access-Control-Allow-Origin", "*");
response.AddHeader("Access-Control-Allow-Headers", "*");
response.AddHeader("Access-Control-Allow-Methods", "*");
response.StatusCode = statuscode;
response.ContentType = "text/plain";
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
response.ContentLength64 = buffer.Length;
System.IO.Stream output = response.OutputStream;
output.Write(buffer, 0, buffer.Length);
}
static async Task Main(string[] args)
{
try
{
if (args.Length > 1)
{
ParseArgs(args);
}
Console.WriteLine(string.Format("Tally Localhost Connector | Version: {0}", version));
HttpListener httpListener = new HttpListener();
httpListener.Prefixes.Add(string.Format("http://localhost:{0}/", port));
httpListener.Start();
Console.WriteLine(string.Format("Listener started on http://localhost:{0}", port));
while (true)
{
HttpListenerContext context = httpListener.GetContext();
HttpListenerRequest req = context.Request;
using (StreamReader sr = new StreamReader(req.InputStream))
{
string payload = sr.ReadToEnd();
HttpListenerResponse res = context.Response;
if (!IsTallyRunning())
{
res.StatusCode = 404;
}
else
{
string content = await FetchTallyData(payload);
res.AddHeader("Access-Control-Allow-Origin", "*");
res.StatusCode = 200;
byte[] buff = Encoding.UTF8.GetBytes(content);
res.ContentLength64 = buff.Length;
res.ContentType = "text/plain";
res.ContentEncoding = Encoding.UTF8;
res.OutputStream.Write(buff, 0, buff.Length);
}
res.Close();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw ex;
}
}
void WriteFile(HttpListenerContext ctx, string path)
{
HttpListenerResponse response = ctx.Response;
httpResponses.Add(response);
using (FileStream fs = File.OpenRead(path))
{
string filename = Path.GetFileName(path);
string mime;
//Set the type of media to play
if (!mimeDic.TryGetValue(Path.GetExtension(filename), out mime))
{
mime = "application/octet-stream";
}
ctx.Response.ContentType = mime;
response.ContentLength64 = fs.Length;
//Stream the File
response.SendChunked = true;
//Enable Media Seek(Rewind/Fastforward)
response.StatusCode = 206;
response.AddHeader("Content-Range", "bytes 0-" + (fs.Length - 1) + "/" + fs.Length);
//According to Content Range
//https://greenbytes.de/tech/webdav/rfc7233.html#header.content-range
//Send data to the connected client
byte[] buffer = new byte[64 * 1024];
int read;
using (BinaryWriter bw = new BinaryWriter(response.OutputStream))
{
while ((read = fs.Read(buffer, 0, buffer.Length)) > 0)
{
bw.Write(buffer, 0, read);
bw.Flush(); //seems to have no effect
}
bw.Close();
}
response.StatusCode = (int)HttpStatusCode.OK;
response.StatusDescription = "OK";
response.OutputStream.Close();
}
}
private void Flush(HttpListenerRequest req, HttpListenerResponse res, byte[] buffer)
{
res.ContentType = "text/plain";
if (buffer == null || buffer.Length == 0)
{
res.Close();
Logger.Info($"Response {res.StatusCode}: Length=0");
return;
}
var statusCode = res.StatusCode;
// 接收 gzip 编码
if (req.Headers != null && req.Headers.Get("Accept-Encoding") != null &&
req.Headers.Get("Accept-Encoding").Contains("gzip"))
{
Logger.Info($"Client accepts GZip encoding");
res.AddHeader("Content-Encoding", "gzip");
MemoryStream memory = null;
try
{
memory = new MemoryStream();
using (var stream = new GZipStream(memory, CompressionMode.Compress, false))
{
stream.Write(buffer, 0, buffer.Length);
}
buffer = memory.ToArray();
}
finally
{
if (memory != null)
{
memory.Dispose();
}
}
Logger.Info("GZip complete");
}
var length = res.ContentLength64 = buffer.LongLength;
res.OutputStream.Write(buffer, 0, (int)length);
res.OutputStream.Flush();
res.Close();
Logger.Info($"Response {statusCode}: Length={length}");
}
private string HandleRequest(HttpListenerRequest request, HttpListenerResponse response, string data)
{
if (request.HttpMethod == "GET")
{
if (returnWeb.ContainsKey(request.RawUrl))
{
response.AddHeader("Content-type", $"Content-Type: {comboBox1.SelectedItem.ToString( )}; charset=utf-8");
return(returnWeb[request.RawUrl]);
}
}
else if (request.HttpMethod == "POST")
{
// POST示例，在data中可以上传复杂的数据，长度不限制的
if (postWeb.ContainsKey(request.RawUrl))
{
response.AddHeader("Content-type", $"Content-Type: {comboBox1.SelectedItem.ToString( )}; charset=utf-8");
return(postWeb[request.RawUrl]);
}
}
else
{
}
return(string.Empty);
}
public void ExportBlockedZones(HttpListenerResponse response)
{
IReadOnlyList <AuthZoneInfo> zoneInfoList = _dnsWebService.DnsServer.BlockedZoneManager.ListZones();
response.ContentType = "text/plain";
response.AddHeader("Content-Disposition", "attachment;filename=BlockedZones.txt");
using (StreamWriter sW = new StreamWriter(new BufferedStream(response.OutputStream)))
{
foreach (AuthZoneInfo zoneInfo in zoneInfoList)
{
sW.WriteLine(zoneInfo.Name);
}
}
}
public void Handle(RequestData data)
{
HttpListenerResponse serverResponse = data.Context.Response;
Log.Info($"Authentication requested from client at {data.Context.Request.RemoteEndPoint}");
serverResponse.StatusCode = (int)HttpStatusCode.OK;
serverResponse.ContentType = "text/plain";
serverResponse.AddHeader("Content-Encoding", "deflate");
EftClient client = data.Client;
byte[] messageBytes = ZlibStream.CompressString(AuthenticationService.Authenticate(ref client, data.Body));
serverResponse.OutputStream.Write(messageBytes, 0, messageBytes.Length);
serverResponse.SetCookie(new Cookie("PHPSESSID", client.UniqueSession));;
serverResponse.Close();
}
private Stream GetOutputStream(HttpListenerRequest request, HttpListenerResponse response)
{
var ostream = response.OutputStream;
if (Compress)
{
string acceptEncoding = request.Headers["Accept-Encoding"];
if (acceptEncoding != null)
{
acceptEncoding = acceptEncoding.ToLowerInvariant();
if (acceptEncoding.Contains("gzip"))
{
response.AddHeader("Content-Encoding", "gzip");
ostream = new GZipStream(ostream, CompressionMode.Compress);
}
else if (acceptEncoding.Contains("deflate"))
{
response.AddHeader("Content-Encoding", "deflate");
ostream = new DeflateStream(ostream, CompressionMode.Compress);
}
}
}
return(ostream);
}
async Task WriteResponse(HttpResponse response, HttpListenerResponse httpListenerResponse)
{
httpListenerResponse.StatusCode = (int)response.StatusCode;
httpListenerResponse.ContentType = response.ContentType;
foreach (var header in response.Headers)
{
httpListenerResponse.AddHeader(header.Key, header.Value);
}
using (var output = httpListenerResponse.OutputStream)
{
await response.Stream(output);
}
}
/// <summary>
/// Write the response to outgoing stream.
/// </summary>
/// <param name="text"></param>
public void write(string text) {
// First request requires syncing headers
if (!this.isHeaderSent) {
response.Headers.Clear();
foreach (string key in headers.Keys)
{
response.AddHeader(key, headers[key].ToString());
}
}
// Write to outgoing stream
byte[] buffer = Encoding.UTF8.GetBytes(text);
response.OutputStream.Write(buffer, 0, buffer.Length);
response.OutputStream.Flush();
this.isHeaderSent = true;
}
private void SendHeader(HttpListenerRequest request, HttpListenerResponse response)
{
response.ContentType = "text/plain";
if (P3P)
{
response.AddHeader("P3P",
"CP=\"CAO DSP COR CUR ADM DEV TAI PSA PSD IVAi IVDi " +
"CONi TELo OTPi OUR DELi SAMi OTRi UNRi PUBi IND PHY ONL " +
"UNI PUR FIN COM NAV INT DEM CNT STA POL HEA PRE GOV\"");
}
if (CrossDomain)
{
string origin = request.Headers["Origin"];
if (string.IsNullOrEmpty(origin) || origin == "null")
{
response.AddHeader("Access-Control-Allow-Origin", "*");
}
else if (origins.Count == 0 || origins.ContainsKey(origin))
{
response.AddHeader("Access-Control-Allow-Origin", origin);
response.AddHeader("Access-Control-Allow-Credentials", "true");
}
}
}
