protected void WriteUTF8ResourceString(HtmlTextWriter output, int offset, int size, bool fAsciiOnly)
{
if (resource_data == null)
{
return; // throw?
}
if (output == null)
{
throw new ArgumentNullException("output");
}
if (offset > resource_data.MaxOffset - size)
{
throw new ArgumentOutOfRangeException("size");
}
//TODO: fAsciiOnly?
IntPtr ptr = AddOffset(resource_data.Ptr, offset);
HttpWriter writer = output.GetHttpWriter();
if (writer == null || writer.Response.ContentEncoding.CodePage != 65001)
{
byte [] bytes = new byte [size];
Marshal.Copy(ptr, bytes, 0, size);
output.Write(Encoding.UTF8.GetString(bytes));
bytes = null;
return;
}
writer.WriteUTF8Ptr(ptr, size);
}
public static void AddressingLevelCompleted(uint levelNum, Transform measure, AddressingController lm)
{
//measure.parent = Instance.gameObject.transform;
//measure.position = new Vector3(measure.position.x, measure.position.y, -6f);
HttpWriter.Flush();
Logger.Instance.LogAction("LevelSelection", "Level Completed", (LevelsCompleted + 1).ToString());
LevelHasStarted = false;
bool needsNewAudio = MeasureIsLocked(levelNum - 1);
bool isBonusLevel = (levelNum % 3) == 0 || Instance.DebugBonus;
LevelsCompleted = levelNum;
UpdateHeader(levelNum);
UpdateHeader(levelNum + 1);
if (needsNewAudio)
{
Instance.StartCoroutine(LoadNewAudio(levelNum - 1));
}
Instance.StartCoroutine(DropLevelSelectionGrid(measure, lm, null));
Instance.StartCoroutine(ReplaceMeasure(measure, isBonusLevel));
}
public HttpFilteredWriter(HttpWriter writer, TagFilter Filter)
{
_Encoding = writer.Encoding;
O = new HtmlFilter(writer.OutputStream, new FilterEvent(Filter.DoFilter));
Output = new StreamWriter(O);
InnerWriter = writer;
}
public void OnActionExecuting(ActionExecutingContext filterContext)
{
sb = new StringBuilder();
sw = new StringWriter(sb);
tw = new HtmlTextWriter(sw);
output = (HttpWriter)filterContext.RequestContext.HttpContext.Response.Output;
filterContext.RequestContext.HttpContext.Response.Output = tw;//覆盖原先的输出流
}
internal async Task WriteToStreamAsync(HttpWriter writer)
{
await writer.WriteAsync(Name);
await writer.WriteAsync(": ");
await writer.WriteLineAsync(Value);
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
_stringBuilder = new StringBuilder();
_stringWriter = new StringWriter(_stringBuilder);
_textWriter = new HtmlTextWriter(_stringWriter);
_httpWriter = (HttpWriter)filterContext.RequestContext.HttpContext.Response.Output;
filterContext.RequestContext.HttpContext.Response.Output = _textWriter;
}
/** @brief Play music on the level selection screen */
private static IEnumerator PlayMusic()
{
uint startLevel, endLevel, level;
float waitTime;
if (LevelsCompleted % Instance.LevelsPerLine == 0)
{
startLevel = 0;
endLevel = (uint)Instance.LevelList.Length - 1;
}
else
{
startLevel = (LevelsCompleted / Instance.LevelsPerLine) * Instance.LevelsPerLine;
endLevel = startLevel + Instance.LevelsPerLine - 1;
}
Logger.Instance.LogAction("LevelSelection",
string.Format("Playing music from {0} to {1}", startLevel, endLevel), (LevelsCompleted + 1).ToString());
//ShowPlayButton();
for (level = startLevel; level <= endLevel && !LevelHasStarted; level++)
{
AudioPlayer player = Objects[level].audioPlayer;
if (MeasureIsLocked(level))
{
waitTime = 1.1f;
}
else
{
waitTime = 2.0f;
}
Instance.StartCoroutine(PopoutTile(level, waitTime));
Instance.StartCoroutine(player.PlayBlocking());
yield return(new WaitForSeconds(waitTime));
if (level == LevelsCompleted)
{
ShowPlayButton();
if (IsAutoplaying())
{
Instance.PlayNextLevel();
}
}
}
Logger.Instance.LogAction("LevelSelection", "Done Playing Music", (LevelsCompleted + 1).ToString());
if (LevelsCompleted == Instance.LevelList.Length)
{
// Application.LoadLevel("OutroCutscene1");
HttpWriter.Flush();
Logger.Instance.LogAction("Transitioning to Outro", "", "");
SceneManager.LoadScene("OutroCutscene1");
Destroy(Instance.gameObject);
}
}
private static void HtmlAttributeEncodeInternal(string value, HttpWriter writer)
{
int pos = IndexOfHtmlAttributeEncodingChars(value, 0);
if (pos == -1)
{
writer.Write(value);
return;
}
int cch = value.Length;
int startPos = 0;
for (; ;)
{
if (pos > startPos)
{
writer.WriteString(value, startPos, pos - startPos);
}
char ch = value[pos];
switch (ch)
{
case '"':
writer.Write(""");
break;
case '\'':
writer.Write("'");
break;
case '&':
writer.Write("&");
break;
case '<':
// Whidbey 32404: The character '<' is not valid in an XML attribute value.
// (See the W3C XML rec).
writer.Write("<");
break;
}
startPos = pos + 1;
if (startPos >= cch)
{
break;
}
pos = IndexOfHtmlAttributeEncodingChars(value, startPos);
if (pos == -1)
{
writer.WriteString(value, startPos, cch - startPos);
break;
}
}
}
/// <summary>
/// 在执行操作方法之前由 ASP.NET MVC 框架调用。
/// </summary>
/// <param name="filterContext">筛选器上下文。</param>
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
base.OnActionExecuting(filterContext);
var req = filterContext.HttpContext.Request;
try
{
if (filterContext.ActionDescriptor.GetCustomAttributes(typeof(QuickPermissionAttribute), true).Length <= 0 && req.HttpMethod.Equals("GET", StringComparison.InvariantCultureIgnoreCase) && req.UserAgent != null && !req.UserAgent.Contains(new[] { "DNSPod", "Baidu", "spider", "Python", "bot" }))
{
Guid uid = filterContext.HttpContext.Session.Get <Guid>("currentOnline");
if (uid == Guid.Empty)
{
uid = Guid.NewGuid();
filterContext.HttpContext.Session.Set("currentOnline", uid);
}
// TODO: (未实现) 增加在线人数
//HangfireHelper.CreateJob(typeof(IHangfireBackJob), nameof(HangfireBackJob.InterviewTrace), null, uid, req.Url.ToString().Replace(":80/", "/"));
}
}
catch
{
// ignored
}
#region 禁用浏览器缓存
filterContext.HttpContext.Response.Headers.Add("Pragma", "no-cache");
filterContext.HttpContext.Response.Headers.Add("Expires", "0");
filterContext.HttpContext.Response.Buffer = true;
filterContext.HttpContext.Response.ExpiresAbsolute = DateTime.Now.AddSeconds(-1);
filterContext.HttpContext.Response.Expires = 0;
filterContext.HttpContext.Response.CacheControl = "no-cache";
filterContext.HttpContext.Response.Cache.SetCacheability(HttpCacheability.NoCache);
filterContext.HttpContext.Response.Cache.SetNoStore();
#endregion
#region 启用ETag
filterContext.HttpContext.Response.Filter = new ETagFilter(filterContext.HttpContext.Response, filterContext.RequestContext.HttpContext.Request);
#endregion
#region 压缩HTML
if (EnableViewCompress)
{
_sb = new StringBuilder();
_sw = new StringWriter(_sb);
_tw = new HtmlTextWriter(_sw);
_output = filterContext.RequestContext.HttpContext.Response.Output as HttpWriter;
filterContext.RequestContext.HttpContext.Response.Output = _tw;
}
#endregion
}
// Token: 0x06002FC6 RID: 12230 RVA: 0x00116014 File Offset: 0x00114214
private static void HtmlEncodeAndOutputBody(TextWriter output, Stream bodyStream)
{
HttpWriter httpWriter = output as HttpWriter;
Stream outputStream = httpWriter.OutputStream;
byte[] array = new byte[8192];
int num;
do
{
num = bodyStream.Read(array, 0, array.Length);
int num2 = 0;
int i;
for (i = 0; i < num; i++)
{
byte[] array2 = null;
byte b = array[i];
if (b != 34)
{
if (b != 38)
{
switch (b)
{
case 60:
array2 = BodyConversionUtilities.lessThanHtmlEncodedReplacement;
break;
case 62:
array2 = BodyConversionUtilities.greaterThanHtmlEncodedReplacement;
break;
}
}
else
{
array2 = BodyConversionUtilities.ampersandHtmlEncodedReplacement;
}
}
else
{
array2 = BodyConversionUtilities.quoteHtmlEncodedReplacement;
}
if (array2 != null)
{
outputStream.Write(array, num2, i - num2);
num2 = i + 1;
outputStream.Write(array2, 0, array2.Length);
}
}
if (num > 0 && num2 < i)
{
outputStream.Write(array, num2, i - num2);
}
outputStream.Flush();
}while (num > 0);
}
public void EnableOutputStream()
{
// 为了支持在代码中使用 Response.OutputStream
var ctor = typeof(HttpWriter).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic,
null, new Type[] { typeof(HttpResponse) }, null);
HttpWriter httpWriter = ctor.Invoke(new object[] { Response }) as HttpWriter;
Response.SetValue("_httpWriter", httpWriter);
Response.SetValue("_writer", httpWriter);
}
/// <internalonly/>
/// <devdoc>
/// </devdoc>
protected internal override void RenderChildren(HtmlTextWriter writer)
{
// We need to register the script here since other controls might register
// for focus during PreRender
Page page = Page;
if (page != null)
{
page.OnFormRender();
page.BeginFormRender(writer, UniqueID);
}
// DevDiv Bugs 154630: move custom hidden fields to the begining of the form
HttpWriter httpWriter = writer.InnerWriter as HttpWriter;
if (page != null && httpWriter != null && RuntimeConfig.GetConfig(Context).Pages.RenderAllHiddenFieldsAtTopOfForm)
{
// If the response is flushed or cleared during render, we won't be able
// to move the hidden fields. Set HasBeenClearedRecently to false and
// then check again when we're ready to move the fields.
httpWriter.HasBeenClearedRecently = false;
// Remember the index where the form begins
int formBeginIndex = httpWriter.GetResponseBufferCountAfterFlush();
base.RenderChildren(writer);
// Remember the index where the custom hidden fields begin
int fieldsBeginIndex = httpWriter.GetResponseBufferCountAfterFlush();
page.EndFormRenderHiddenFields(writer, UniqueID);
// we can only move the hidden fields if the response has not been flushed or cleared
if (!httpWriter.HasBeenClearedRecently)
{
int fieldsEndIndex = httpWriter.GetResponseBufferCountAfterFlush();
httpWriter.MoveResponseBufferRangeForward(fieldsBeginIndex, fieldsEndIndex - fieldsBeginIndex, formBeginIndex);
}
page.EndFormRenderArrayAndExpandoAttribute(writer, UniqueID);
page.EndFormRenderPostBackAndWebFormsScript(writer, UniqueID);
page.OnFormPostRender(writer);
}
else
{
base.RenderChildren(writer);
if (page != null)
{
page.EndFormRender(writer, UniqueID);
page.OnFormPostRender(writer);
}
}
}
/// <summary>
/// 在执行Action的时候，就把需要的Writer存起来
/// </summary>
/// <param name="filterContext">上下文</param>
protected override void OnActionExecuting(ActionExecutingContext filterContext)
{
sb = new StringBuilder();
sw = new StringWriter(sb);
tw = new HtmlTextWriter(sw);
output = (HttpWriter)filterContext.RequestContext.HttpContext.Response.Output;
filterContext.RequestContext.HttpContext.Response.Output = tw;
base.OnActionExecuting(filterContext);
}
static void ProcessRequest(TcpClient socket)
{
HttpServer.Listen(socket, (request) => {
if (request.RequestUri.Equals(new Utf8String("/plaintext")))
{
var formatter = new BufferFormatter(1024, FormattingData.InvariantUtf8);
HttpWriter.WriteCommonHeaders(formatter, "HTTP/1.1 200 OK");
formatter.Append("Hello, World!");
socket.Write(formatter);
}
});
}
// Token: 0x06002C67 RID: 11367 RVA: 0x000F76B8 File Offset: 0x000F58B8
private void OutputImage(Stream inputStream, string contentType)
{
HttpWriter httpWriter = this.Writer as HttpWriter;
Stream outputStream = httpWriter.OutputStream;
this.HttpContext.Response.ContentType = contentType;
byte[] array = new byte[32768];
int count;
while ((count = inputStream.Read(array, 0, array.Length)) > 0)
{
outputStream.Write(array, 0, count);
}
}
private async Task handleHttpSessionRequest(TcpServerConnection connection, SessionEventArgs args)
{
var cancellationToken = args.CancellationTokenSource.Token;
var request = args.HttpClient.Request;
request.Locked = true;
var body = request.CompressBodyAndUpdateContentLength();
// set the connection and send request headers
args.HttpClient.SetConnection(connection);
await args.HttpClient.SendRequest(Enable100ContinueBehaviour, args.IsTransparent,
cancellationToken);
// If a successful 100 continue request was made, inform that to the client and reset response
if (request.ExpectationSucceeded)
{
var clientStreamWriter = args.ProxyClient.ClientStreamWriter;
var response = args.HttpClient.Response;
var headerBuilder = new HeaderBuilder();
headerBuilder.WriteResponseLine(response.HttpVersion, response.StatusCode, response.StatusDescription);
headerBuilder.WriteHeaders(response.Headers);
await clientStreamWriter.WriteHeadersAsync(headerBuilder, cancellationToken);
await args.ClearResponse(cancellationToken);
}
// send body to server if available
if (request.HasBody)
{
if (request.IsBodyRead)
{
var writer = args.HttpClient.Connection.StreamWriter;
await writer.WriteBodyAsync(body !, request.IsChunked, cancellationToken);
}
else if (!request.ExpectationFailed)
{
// get the request body unless an unsuccessful 100 continue request was made
HttpWriter writer = args.HttpClient.Connection.StreamWriter !;
await args.CopyRequestBodyAsync(writer, TransformationMode.None, cancellationToken);
}
}
args.TimeLine["Request Sent"] = DateTime.Now;
// parse and send response
await handleHttpSessionResponse(args);
}
/// <summary>
/// Logs the end of the session and disposes of the session and user ids.
/// Resets session state
/// </summary>
public void SessionEnd()
{
if (!this.Enabled || !this.InSession)
{
return;
}
HttpWriter.Flush();
this.write("System", "Session_End", this.SessionID);
this.SessionID = string.Empty;
this.UserID = string.Empty;
this.InSession = false;
this.LoggedLevelName = "";
}
/// <summary>
/// Syphon out any left over data in given request/response from backing tcp connection.
/// When user modifies the response/request we need to do this to reuse tcp connections.
/// </summary>
/// <param name="isRequest"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
internal async Task SyphonOutBodyAsync(bool isRequest, CancellationToken cancellationToken)
{
var requestResponse = isRequest ? (RequestResponseBase)WebSession.Request : WebSession.Response;
if (requestResponse.OriginalIsBodyRead || !requestResponse.OriginalHasBody)
{
return;
}
using (var bodyStream = new MemoryStream())
{
var writer = new HttpWriter(bodyStream, bufferPool, bufferSize);
await copyBodyAsync(isRequest, true, writer, TransformationMode.None, null, cancellationToken);
}
}
private static void HtmlAttributeEncodeInternal(string value, HttpWriter writer)
{
int num = IndexOfHtmlAttributeEncodingChars(value, 0);
if (num == -1)
{
writer.Write(value);
return;
}
int length = value.Length;
int index = 0;
Label_001D:
if (num > index)
{
writer.WriteString(value, index, num - index);
}
switch (value[num])
{
case '&':
writer.Write("&");
break;
case '\'':
writer.Write("'");
break;
case '<':
writer.Write("<");
break;
case '"':
writer.Write(""");
break;
}
index = num + 1;
if (index < length)
{
num = IndexOfHtmlAttributeEncodingChars(value, index);
if (num != -1)
{
goto Label_001D;
}
writer.WriteString(value, index, length - index);
}
}
private async Task <byte[]> readBodyAsync(bool isRequest, CancellationToken cancellationToken)
{
using (var bodyStream = new MemoryStream())
{
var writer = new HttpWriter(bodyStream, bufferPool, bufferSize);
if (isRequest)
{
await CopyRequestBodyAsync(writer, TransformationMode.Uncompress, cancellationToken);
}
else
{
await CopyResponseBodyAsync(writer, TransformationMode.Uncompress, cancellationToken);
}
return(bodyStream.ToArray());
}
}
protected internal virtual void HtmlAttributeEncode(string value, TextWriter output)
{
if (value != null)
{
if (output == null)
{
throw new ArgumentNullException("output");
}
HttpWriter writer = output as HttpWriter;
if (writer != null)
{
HtmlAttributeEncodeInternal(value, writer);
}
else
{
HtmlAttributeEncodeInternal(value, output);
}
}
}
override void Render(HtmlTextWriter writer)
{
if (length == -1)
{
writer.Write(base.Text);
return;
}
HttpWriter hw = writer.GetHttpWriter();
if (hw == null || hw.Response.ContentEncoding.CodePage != 65001)
{
byte [] bytes = new byte [length];
Marshal.Copy(ptr, bytes, 0, length);
writer.Write(Encoding.UTF8.GetString(bytes));
bytes = null;
return;
}
hw.WriteUTF8Ptr(ptr, length);
}
/// <summary>
/// This is called when the request is PUT/POST/PATCH to read the body
/// </summary>
/// <returns></returns>
internal async Task CopyRequestBodyAsync(HttpWriter writer, TransformationMode transformation, CancellationToken cancellationToken)
{
var request = WebSession.Request;
long contentLength = request.ContentLength;
// send the request body bytes to server
if (contentLength > 0 && hasMulipartEventSubscribers && request.IsMultipartFormData)
{
var reader = getStreamReader(true);
string boundary = HttpHelper.GetBoundaryFromContentType(request.ContentType);
using (var copyStream = new CopyStream(reader, writer, bufferPool, bufferSize))
{
while (contentLength > copyStream.ReadBytes)
{
long read = await readUntilBoundaryAsync(copyStream, contentLength, boundary, cancellationToken);
if (read == 0)
{
break;
}
if (contentLength > copyStream.ReadBytes)
{
var headers = new HeaderCollection();
await HeaderParser.ReadHeaders(copyStream, headers, cancellationToken);
OnMultipartRequestPartSent(boundary, headers);
}
}
await copyStream.FlushAsync(cancellationToken);
}
}
else
{
await copyBodyAsync(true, false, writer, transformation, OnDataSent, cancellationToken);
}
}
protected internal virtual void HtmlAttributeEncode(string value, TextWriter output)
{
if (value == null)
{
return;
}
if (output == null)
{
throw new ArgumentNullException("output");
}
// we have a special faster path for HttpWriter
HttpWriter httpWriter = output as HttpWriter;
if (httpWriter != null)
{
HtmlAttributeEncodeInternal(value, httpWriter);
}
else
{
HtmlAttributeEncodeInternal(value, output);
}
}
protected internal override void RenderChildren(HtmlTextWriter writer)
{
Page page = this.Page;
if (page != null)
{
page.OnFormRender();
page.BeginFormRender(writer, this.UniqueID);
}
HttpWriter innerWriter = writer.InnerWriter as HttpWriter;
if (((page != null) && (innerWriter != null)) && RuntimeConfig.GetConfig(this.Context).Pages.RenderAllHiddenFieldsAtTopOfForm)
{
innerWriter.HasBeenClearedRecently = false;
int responseBufferCountAfterFlush = innerWriter.GetResponseBufferCountAfterFlush();
base.RenderChildren(writer);
int srcIndex = innerWriter.GetResponseBufferCountAfterFlush();
page.EndFormRenderHiddenFields(writer, this.UniqueID);
if (!innerWriter.HasBeenClearedRecently)
{
int num3 = innerWriter.GetResponseBufferCountAfterFlush();
innerWriter.MoveResponseBufferRangeForward(srcIndex, num3 - srcIndex, responseBufferCountAfterFlush);
}
page.EndFormRenderArrayAndExpandoAttribute(writer, this.UniqueID);
page.EndFormRenderPostBackAndWebFormsScript(writer, this.UniqueID);
page.OnFormPostRender(writer);
}
else
{
base.RenderChildren(writer);
if (page != null)
{
page.EndFormRender(writer, this.UniqueID);
page.OnFormPostRender(writer);
}
}
}
private async Task copyBodyAsync(bool isRequest, bool useOriginalHeaderValues, HttpWriter writer, TransformationMode transformation, Action <byte[], int, int> onCopy, CancellationToken cancellationToken)
{
var stream = getStreamReader(isRequest);
var requestResponse = isRequest ? (RequestResponseBase)WebSession.Request : WebSession.Response;
bool isChunked = useOriginalHeaderValues? requestResponse.OriginalIsChunked : requestResponse.IsChunked;
long contentLength = useOriginalHeaderValues ? requestResponse.OriginalContentLength : requestResponse.ContentLength;
if (transformation == TransformationMode.None)
{
await writer.CopyBodyAsync(stream, isChunked, contentLength, onCopy, cancellationToken);
return;
}
LimitedStream limitedStream;
Stream decompressStream = null;
string contentEncoding = useOriginalHeaderValues ? requestResponse.OriginalContentEncoding : requestResponse.ContentEncoding;
Stream s = limitedStream = new LimitedStream(stream, bufferPool, isChunked, contentLength);
if (transformation == TransformationMode.Uncompress && contentEncoding != null)
{
s = decompressStream = DecompressionFactory.Create(contentEncoding, s);
}
try
{
using (var bufStream = new CustomBufferedStream(s, bufferPool, bufferSize, true))
{
await writer.CopyBodyAsync(bufStream, false, -1, onCopy, cancellationToken);
}
}
finally
{
decompressStream?.Dispose();
await limitedStream.Finish();
limitedStream.Dispose();
}
}
/// <summary>
/// Handle a specific session (request/response sequence)
/// </summary>
/// <param name="connection"></param>
/// <param name="args"></param>
/// <returns>True if close the connection</returns>
private async Task HandleHttpSessionRequestInternal(TcpConnection connection, SessionEventArgs args)
{
try
{
var request = args.WebSession.Request;
request.RequestLocked = true;
//if expect continue is enabled then send the headers first
//and see if server would return 100 conitinue
if (request.ExpectContinue)
{
args.WebSession.SetConnection(connection);
await args.WebSession.SendRequest(Enable100ContinueBehaviour, args.IsTransparent);
}
//If 100 continue was the response inform that to the client
if (Enable100ContinueBehaviour)
{
var clientStreamWriter = args.ProxyClient.ClientStreamWriter;
if (request.Is100Continue)
{
await clientStreamWriter.WriteResponseStatusAsync(args.WebSession.Response.HttpVersion, (int)HttpStatusCode.Continue, "Continue");
await clientStreamWriter.WriteLineAsync();
}
else if (request.ExpectationFailed)
{
await clientStreamWriter.WriteResponseStatusAsync(args.WebSession.Response.HttpVersion, (int)HttpStatusCode.ExpectationFailed, "Expectation Failed");
await clientStreamWriter.WriteLineAsync();
}
}
//If expect continue is not enabled then set the connectio and send request headers
if (!request.ExpectContinue)
{
args.WebSession.SetConnection(connection);
await args.WebSession.SendRequest(Enable100ContinueBehaviour, args.IsTransparent);
}
//check if content-length is > 0
if (request.ContentLength > 0)
{
//If request was modified by user
if (request.IsBodyRead)
{
if (request.ContentEncoding != null)
{
request.Body = await GetCompressedResponseBody(request.ContentEncoding, request.Body);
}
var body = request.Body;
//chunked send is not supported as of now
request.ContentLength = body.Length;
await args.WebSession.ServerConnection.StreamWriter.WriteAsync(body);
}
else
{
if (!request.ExpectationFailed)
{
//If its a post/put/patch request, then read the client html body and send it to server
if (request.HasBody)
{
HttpWriter writer = args.WebSession.ServerConnection.StreamWriter;
await args.CopyRequestBodyAsync(writer, false);
}
}
}
}
//If not expectation failed response was returned by server then parse response
if (!request.ExpectationFailed)
{
await HandleHttpSessionResponse(args);
}
}
catch (Exception e) when(!(e is ProxyHttpException))
{
throw new ProxyHttpException("Error occured whilst handling session request (internal)", e, args);
}
}
// Update is called once per frame
void Update()
{
string oldPress = press;
if (Input.GetKeyDown(KeyCode.Return))
{
press = "";
}
if (Input.GetKeyDown(KeyCode.A))
{
press += "a";
}
if (Input.GetKeyDown(KeyCode.C))
{
press += "c";
}
if (Input.GetKeyDown(KeyCode.D))
{
press += "d";
}
if (Input.GetKeyDown(KeyCode.E))
{
press += "e";
}
if (Input.GetKeyDown(KeyCode.I))
{
press += "i";
}
if (Input.GetKeyDown(KeyCode.L))
{
press += "l";
}
if (Input.GetKeyDown(KeyCode.N))
{
press += "n";
}
if (Input.GetKeyDown(KeyCode.O))
{
press += "o";
}
if (Input.GetKeyDown(KeyCode.P))
{
press += "p";
}
if (Input.GetKeyDown(KeyCode.S))
{
press += "s";
}
if (Input.GetKeyDown(KeyCode.T))
{
press += "t";
}
if (Input.GetKeyDown(KeyCode.U))
{
press += "u";
}
if (Input.GetKeyDown(KeyCode.Y))
{
press += "y";
}
if (press != oldPress)
{
Debug.Log(press);
}
string message;
switch (press)
{
case "auto":
if (AutoplayReady)
{
message = "Autoplay Beginning at " + System.DateTime.Now.ToUniversalTime();
Logger.Instance.LogAction("Command", message, "");
Debug.Log(message);
LevelSelection.BeginAutoplay();
press = "";
}
break;
case "stop":
message = "Autoplay Ending at " + System.DateTime.Now.ToUniversalTime();
Logger.Instance.LogAction("Command", message, "");
LevelSelection.EndAutoplay();
Debug.Log(message);
press = "";
break;
case "sel":
if (LevelSelection.Instance != null)
{
Destroy(LevelSelection.Instance);
}
SceneManager.LoadScene("LevelSelection");
press = "";
break;
case "inc":
Logger.Instance.LogAction("Session", "Level Incremented by Researcher", "");
LevelSelection.UpOneLevel();
press = "";
break;
case "dec":
Logger.Instance.LogAction("Session", "Level Decremented by Researcher", "");
LevelSelection.DownOneLevel();
press = "";
break;
case "load":
Logger.Instance.LogAction("Session", "Scene reloaded by researcher", SceneManager.GetActiveScene().name);
SceneManager.LoadScene(SceneManager.GetActiveScene().name);
press = "";
break;
case "done":
Logger.Instance.LogAction("Session", "Terminated by researcher", "");
HttpWriter.Flush();
Logger.Instance.SessionEnd();
Logger.Instance.SessionStart();
SceneManager.LoadScene("OutroCutscene3");
press = "";
break;
case "play":
Logger.Instance.LogAction("Session", "Play level triggered by researcher", "");
LevelSelection.Instance.PlayNextLevel();
press = "";
break;
default:
break;
}
}
/// <summary>
/// Private method that handles an incoming request.
/// It sets up a RequestHandlerContext instance with the data from
/// the incoming HTTP request, finds a suitable request handler to
/// produce the response, and then sends the response as an HTTP
/// response back to the client.
/// Preconditions
/// "connection is open"
/// serviceRoot != null
/// serviceRoot.Length > 8
/// "serviceRoot starts with 'http://' and ends with '/'"
/// requestRouting != null
/// </summary>
/// <param name="connection">Open TCP/IP connection</param>
/// <param name="serviceRoot">The absolute URI that is a prefix of
/// all request URIs that this web service supports. It must start
/// with "http://" and must end with "/".</param>
/// <param name="relayDomain">Host name or Internet address of the
/// relay to be used, or null if no relay is used</param>
/// <param name="requestRouting">Collection of
/// { request pattern, request handler}
/// pairs</param>
/// <param name="connectionClose">Return parameter that indicates
/// that the connection should be closed after this call. This may
/// be because the incoming request has a "Connection: close"
/// header, because the request handler has set the
/// ConnectionClose property, or because some error occurred.
/// </param>
internal static void ConsumeRequest(Stream connection,
string serviceRoot, string relayDomain,
RequestRouting requestRouting,
ref bool connectionClose)
{
Contract.Requires(connection != null);
Contract.Requires(serviceRoot != null);
Contract.Requires(serviceRoot.Length > 8);
Contract.Requires(serviceRoot.Substring(0, 7) == "http://");
Contract.Requires(serviceRoot[serviceRoot.Length - 1] != '/');
Contract.Requires(requestRouting != null);
// initialization --------------------------------------------
HttpReader reader = new HttpReader();
HttpWriter writer = new HttpWriter();
var context = new RequestHandlerContext(serviceRoot,
relayDomain);
// Both client and server may request closing the connection.
// Initially, we assume that neither one wants to close the
// connection.
context.ConnectionClose = false;
// receive request -------------------------------------------
reader.Attach(connection);
// request line
string httpMethod;
string requestUri;
string httpVersion;
reader.ReadStringToBlank(out httpMethod);
reader.ReadStringToBlank(out requestUri);
reader.ReadFieldValue(out httpVersion);
if (reader.Status != HttpStatus.BeforeContent) // error
{
reader.Detach();
connectionClose = true;
return;
}
context.RequestMethod = httpMethod;
context.RequestUri = requestUri;
// ignore version
// headers
string fieldName;
string fieldValue;
int requestContentLength = -1;
reader.ReadFieldName(out fieldName);
while (reader.Status == HttpStatus.BeforeContent)
{
reader.ReadFieldValue(out fieldValue);
if (fieldValue != null)
{
Contract.Assert(reader.Status ==
HttpStatus.BeforeContent);
if (fieldName == "Connection")
{
context.ConnectionClose =
((fieldValue == "close") ||
(fieldValue == "Close"));
}
else if (fieldName == "Content-Type")
{
context.RequestContentType = fieldValue;
}
else if (fieldName == "Content-Length")
{
if (Utilities.TryParseUInt32(fieldValue,
out requestContentLength))
{
// content length is now known
}
else
{
reader.Status = HttpStatus.SyntaxError;
reader.Detach();
connectionClose = true;
return;
}
}
}
else
{
// it's ok to skip header whose value is too long
}
Contract.Assert(reader.Status == HttpStatus.BeforeContent);
reader.ReadFieldName(out fieldName);
}
if (reader.Status != HttpStatus.InContent)
{
reader.Detach();
connectionClose = true;
return;
}
// content
if (requestContentLength > 0)
{
// receive content
var requestContent = new byte[requestContentLength];
int toRead = requestContentLength;
var read = 0;
while ((toRead > 0) && (read >= 0))
{
// already read: requestContentLength - toRead
read = reader.ReadContent(requestContent,
requestContentLength - toRead, toRead);
if (read < 0) { break; } // timeout or shutdown
toRead = toRead - read;
}
try
{
char[] chars = Encoding.UTF8.GetChars(requestContent);
context.RequestContent = new string(chars);
}
catch (Exception)
{
context.RequestContentType = "text/plain";
context.RequestContent = "request content is not in UTF8 format";
Debug.Print(context.RequestContent);
// TODO signal wrong content format through HTTP status code 400 (Bad Request)?
}
}
reader.Detach();
if (reader.Status != HttpStatus.InContent)
{
connectionClose = true;
return;
}
// delegate request processing to a request handler ----------
var match = false;
foreach (Element e in requestRouting)
{
if (context.RequestMatch(e))
{
bool connClose = context.ConnectionClose;
context.ResponseStatusCode = -1; // undefined
Contract.Requires(context.ResponseContentType != null);
Contract.Requires(context.ResponseContentType == "text/plain"); // default
try
{
e.Handler(context);
}
catch (Exception h)
{
Debug.Print("exception in request handler: " + h); // TODO how to better handle handler exceptions?
throw; // rethrow, to avoid masking of errors
}
Contract.Ensures(context.ResponseStatusCode >= 100);
Contract.Ensures(context.ResponseStatusCode < 600);
Contract.Ensures(context.ResponseContentType != null);
Contract.Ensures(context.ResponseContentType.Length > 0);
// make sure that handler has not reset connectionClose flag:
Contract.Ensures((!connClose) || (context.ConnectionClose));
match = true;
break;
}
}
if (!match)
{
context.ResponseStatusCode = 404; // Not Found
context.ResponseContentType = "text/plain";
context.ResponseContent = null;
}
uint availableMemory = Debug.GC(true);
Debug.Print(context.RequestMethod + " " +
context.RequestUri + " -> " +
context.ResponseStatusCode + " [" + availableMemory + "]");
// send response ---------------------------------------------
writer.Attach(connection);
// status line
writer.WriteString("HTTP/1.1 ");
writer.WriteString(context.ResponseStatusCode.ToString());
writer.WriteLine(" "); // omit optional reason phrase
// headers
if (connectionClose) // TODO (context.ConnectionClose)
{
writer.WriteLine("Connection: close");
}
byte[] responseBuffer = null;
var responseLength = 0;
if (context.ResponseContent != null)
{
responseBuffer =
Encoding.UTF8.GetBytes(context.ResponseContent);
responseLength = responseBuffer.Length;
writer.WriteString("Content-Type: ");
writer.WriteLine(context.ResponseContentType);
}
else
{
responseLength = 0;
}
writer.WriteString("Content-Length: ");
writer.WriteLine(responseLength.ToString());
if (context.ResponseMaxAge > 0)
{
writer.WriteLine("Cache-Control: max-age=" + context.ResponseMaxAge);
}
else if (context.ResponseMaxAge == 0)
{
writer.WriteLine("Cache-Control: no-cache");
}
// content
writer.WriteBeginOfContent();
if (context.ResponseContent != null) // send content
{
writer.WriteContent(responseBuffer, 0, responseLength);
}
writer.Detach();
connectionClose = context.ConnectionClose;
}
/// <summary>
/// Handle a specific session (request/response sequence)
/// </summary>
/// <param name="serverConnection">The tcp connection.</param>
/// <param name="args">The session event arguments.</param>
/// <returns></returns>
private async Task HandleHttpSessionRequestInternal(TcpServerConnection serverConnection, SessionEventArgs args)
{
try
{
var cancellationToken = args.CancellationTokenSource.Token;
var request = args.WebSession.Request;
request.Locked = true;
var body = request.CompressBodyAndUpdateContentLength();
// if expect continue is enabled then send the headers first
// and see if server would return 100 conitinue
if (request.ExpectContinue)
{
args.WebSession.SetConnection(serverConnection);
await args.WebSession.SendRequest(Enable100ContinueBehaviour, args.IsTransparent,
cancellationToken);
}
// If 100 continue was the response inform that to the client
if (Enable100ContinueBehaviour)
{
var clientStreamWriter = args.ProxyClient.ClientStreamWriter;
if (request.Is100Continue)
{
await clientStreamWriter.WriteResponseStatusAsync(args.WebSession.Response.HttpVersion,
(int)HttpStatusCode.Continue, "Continue", cancellationToken);
await clientStreamWriter.WriteLineAsync(cancellationToken);
}
else if (request.ExpectationFailed)
{
await clientStreamWriter.WriteResponseStatusAsync(args.WebSession.Response.HttpVersion,
(int)HttpStatusCode.ExpectationFailed, "Expectation Failed", cancellationToken);
await clientStreamWriter.WriteLineAsync(cancellationToken);
}
}
// If expect continue is not enabled then set the connectio and send request headers
if (!request.ExpectContinue)
{
args.WebSession.SetConnection(serverConnection);
await args.WebSession.SendRequest(Enable100ContinueBehaviour, args.IsTransparent,
cancellationToken);
}
// check if content-length is > 0
if (request.ContentLength > 0)
{
if (request.IsBodyRead)
{
var writer = args.WebSession.ServerConnection.StreamWriter;
await writer.WriteBodyAsync(body, request.IsChunked, cancellationToken);
}
else
{
if (!request.ExpectationFailed)
{
if (request.HasBody)
{
HttpWriter writer = args.WebSession.ServerConnection.StreamWriter;
await args.CopyRequestBodyAsync(writer, TransformationMode.None, cancellationToken);
}
}
}
}
// If not expectation failed response was returned by server then parse response
if (!request.ExpectationFailed)
{
await HandleHttpSessionResponse(args);
}
}
catch (Exception e) when(!(e is ProxyHttpException))
{
throw new ProxyHttpException("Error occured whilst handling session request (internal)", e, args);
}
}
public void FixtureSetUp()
{
HttpContext context = new HttpContext(null);
writer = (HttpWriter)context.Response.Output;
}
public HtmlTextWriter(TextWriter writer, string tabString) : base(CultureInfo.InvariantCulture) {
this.writer = writer;
this.tabString = tabString;
indentLevel = 0;
tabsPending = false;
// If it's an http writer, save it
_httpWriter = writer as HttpWriter;
_isDescendant = (GetType() != typeof(HtmlTextWriter));
_attrCount = 0;
_styleCount = 0;
_endTagCount = 0;
_inlineCount = 0;
}
