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; }