public static void WriteEmptyResponse(this HttpMessageWriter writer, StatusCodes statusCode) { writer.WriteStatusLine(statusCode); writer.WriteAuxiliaryHeaders(); writer.WriteContentLength(0); writer.WriteCRLF(); }
public void ProcessIncomingRequest(Connection c) { if (c.HttpReader.HasUpgarde(Upgrades.Websocket)) { // c.HttpReader.SecWebSocketProtocol var key = c.HttpReader.SecWebSocketKey.ToString(); byte[] accept; lock (sha1) accept = sha1.ComputeHash(Encoding.ASCII.GetBytes(key + guid)); using (var writer = new HttpMessageWriter()) { writer.WriteStatusLine(StatusCodes.SwitchingProtocols); writer.WriteConnectionUpgrade(); writer.WriteUpgradeWebsocket(); writer.WriteSecWebSocketAccept(accept); writer.WriteSecWebSocketProtocol(sip); writer.WriteContentLength(0); writer.WriteCRLF(); SendResponse(c, writer, InvalidAgentIndex); } c.UpgradeToWebsocket(); } else { base.ProcessIncomingRequest(c); } }
public static void WriteOptionsResponse(this HttpMessageWriter writer) { writer.WriteStatusLine(StatusCodes.OK); writer.WriteAuxiliaryHeaders(); writer.WriteAllow(Methods.Get, Methods.Options); writer.WriteContentLength(0); writer.WriteCRLF(); }
public static void WriteAccessControlHeaders(this HttpMessageWriter writer) { writer.WriteAccessControlAllowOrigin(true); writer.WriteAccessControlAllowCredentials(true); writer.WriteAccessControlAllowHeaders(accessControlAllowHeaders); writer.WriteAccessControlExposeHeaders(accessControlExposeHeaders); writer.WriteAccessControlAllowMethods(Methods.Get, Methods.Post, Methods.Options); }
private void SendWriter(ServerAsyncEventArgs r, HttpMessageWriter writer) { r.Count = writer.Count; r.OffsetOffset = writer.OffsetOffset; r.AttachBuffer(writer.Detach()); SendAsync(r, false); }
private void SendWriter(Session session, HttpMessageWriter writer) { var r = EventArgsManager.Get(); session.RestoreAddresses(r); SendWriter(r, writer); }
private void SendWriter(Connection connection, HttpMessageWriter writer) { var r = EventArgsManager.Get(); r.CopyAddressesFrom(connection); SendWriter(r, writer); }
private void SendEmptyMessage(Session session) { using (var writer = new HttpMessageWriter()) { writer.WriteEmptyResponse(StatusCodes.OK); SendWriter(session, writer); } }
public static void WriteResponse(this HttpMessageWriter writer, StatusCodes statusCodes, ContentType contentType, byte[] content) { writer.WriteStatusLine(statusCodes); writer.WriteAuxiliaryHeaders(); writer.WriteContentType(contentType); writer.WriteContentLength(content.Length); writer.WriteCRLF(); writer.Write(content); }
private void SendResponse(Connection connection, StatusCodes statusCode) { using (var writer = new HttpMessageWriter()) { writer.WriteEmptyResponse(statusCode); SendWriter(connection, writer); } }
public String ShouldWriteHttpMessage(HttpMessageHeader header, Stream body, long?bodyLength) { var outputStream = new MemoryStream(); var httpWriter = new HttpMessageWriter(outputStream); httpWriter.Write(header, body, bodyLength); return(Encoding.ASCII.GetString(outputStream.ToArray())); }
protected void SendResponse(BaseConnection c, HttpMessageWriter writer, int agentIndex) { var r = EventArgsManager.Get(); r.CopyAddressesFrom(c); r.Count = writer.Count; r.OffsetOffset = writer.OffsetOffset; r.AttachBuffer(writer.Detach()); SendAsync(r, agentIndex); }
void IHttpServer.SendResponse(BaseConnection c, HttpMessageWriter writer) { var r = EventArgsManager.Get(); r.CopyAddressesFrom(c); r.Count = writer.Count; r.OffsetOffset = writer.OffsetOffset; r.AttachBuffer(writer.Detach()); SendAsync(r); }
//public int CopyTo(Func<int, ArraySegment<byte>> getBuffer) //{ // lock (tuples) // { // int length = CountLength(); // var segment = getBuffer(length); // if (segment.Count >= length) // { // int offset = 0; // BlockCopy(openPresence, segment, ref offset, openPresence.Length); // for (int i = 0; i < tuples.Count; i++) // { // Buffer.BlockCopy(tuples[i].Data.Array, tuples[i].Data.Offset, // segment.Array, segment.Offset + offset, tuples[i].Data.Count); // offset += tuples[i].Data.Count; // } // BlockCopy(closePresence, segment, ref offset, closePresence.Length); // return length; // } // return 0; // } //} public void WriteLenghtAndContent(HttpMessageWriter writer) { lock (tuples) { int length = CountLength(); writer.WriteContentLength(length); writer.WriteCRLF(); WriteContent(writer, length); } }
/// <summary>Creates new instance of DefaultBHttpClientConnection.</summary> /// <remarks>Creates new instance of DefaultBHttpClientConnection.</remarks> /// <param name="buffersize">buffer size. Must be a positive number.</param> /// <param name="fragmentSizeHint">fragment size hint.</param> /// <param name="chardecoder"> /// decoder to be used for decoding HTTP protocol elements. /// If <code>null</code> simple type cast will be used for byte to char conversion. /// </param> /// <param name="charencoder"> /// encoder to be used for encoding HTTP protocol elements. /// If <code>null</code> simple type cast will be used for char to byte conversion. /// </param> /// <param name="constraints"> /// Message constraints. If <code>null</code> /// <see cref="Org.Apache.Http.Config.MessageConstraints.Default">Org.Apache.Http.Config.MessageConstraints.Default /// </see> /// will be used. /// </param> /// <param name="incomingContentStrategy"> /// incoming content length strategy. If <code>null</code> /// <see cref="Org.Apache.Http.Impl.Entity.LaxContentLengthStrategy.Instance">Org.Apache.Http.Impl.Entity.LaxContentLengthStrategy.Instance /// </see> /// will be used. /// </param> /// <param name="outgoingContentStrategy"> /// outgoing content length strategy. If <code>null</code> /// <see cref="Org.Apache.Http.Impl.Entity.StrictContentLengthStrategy.Instance">Org.Apache.Http.Impl.Entity.StrictContentLengthStrategy.Instance /// </see> /// will be used. /// </param> /// <param name="requestWriterFactory"> /// request writer factory. If <code>null</code> /// <see cref="Org.Apache.Http.Impl.IO.DefaultHttpRequestWriterFactory.Instance">Org.Apache.Http.Impl.IO.DefaultHttpRequestWriterFactory.Instance /// </see> /// will be used. /// </param> /// <param name="responseParserFactory"> /// response parser factory. If <code>null</code> /// <see cref="Org.Apache.Http.Impl.IO.DefaultHttpResponseParserFactory.Instance">Org.Apache.Http.Impl.IO.DefaultHttpResponseParserFactory.Instance /// </see> /// will be used. /// </param> internal DefaultBHttpClientConnection(int buffersize, int fragmentSizeHint, CharsetDecoder chardecoder, CharsetEncoder charencoder, MessageConstraints constraints, ContentLengthStrategy incomingContentStrategy, ContentLengthStrategy outgoingContentStrategy, HttpMessageWriterFactory <IHttpRequest> requestWriterFactory, HttpMessageParserFactory <HttpResponse> responseParserFactory ) : base(buffersize, fragmentSizeHint, chardecoder, charencoder, constraints, incomingContentStrategy , outgoingContentStrategy) { this.requestWriter = (requestWriterFactory != null ? requestWriterFactory : DefaultHttpRequestWriterFactory .Instance).Create(GetSessionOutputBuffer()); this.responseParser = (responseParserFactory != null ? responseParserFactory : DefaultHttpResponseParserFactory .Instance).Create(GetSessionInputBuffer(), constraints); }
public static void WriteNotFinishedResponse(this HttpMessageWriter writer, StatusCodes statusCode, ContentType contentType) { writer.WriteStatusLine(statusCode); writer.WriteAuxiliaryHeaders(); if (contentType != ContentType.None) { writer.WriteContentType(contentType); } else { writer.WriteContentLength(0); } }
/// <summary> /// Handles the OnResponseReceived for the proxy, which occurs after the response is /// received from the web server, but before it is forwarded on to the browser. /// </summary> /// <param name="context">A <see cref="BenderProxy.ProcessingContext"/> object.</param> public override void OnResponseReceived(ProcessingContext context) { // These are valid credentials for the Basic case. string userName = "******"; string password = "******"; // Only do any processing on the response if the response is 401, // or "Unauthorized". if (context.ResponseHeader != null && context.ResponseHeader.StatusCode == 401) { // Read the headers from the response and finish reading the response // body, if any. Console.WriteLine("Received 401 - Unauthorized response"); context.ServerStream.ReadTimeout = 5000; context.ServerStream.WriteTimeout = 5000; StreamReader reader = new StreamReader(context.ServerStream); HttpHeaderReader headerReader = new HttpHeaderReader(reader); if (context.ResponseHeader.EntityHeaders.ContentLength != 0) { string drainBody = ReadFromStream(reader); } // We do not want the proxy to do any further processing after // handling this message. context.StopProcessing(); // Read the WWW-Authenticate header. Because of the way the test // web app is configured, it returns multiple headers, with // different schemes. We need to select the correct one. string authHeader = GetAuthenticationHeader(context.ResponseHeader.WWWAuthenticate, BasicGenerator.AuthorizationHeaderMarker); Console.WriteLine("Processing WWW-Authenticate header: {0}", authHeader); // Calculate the value for the Authorization header, and resend // the request (with the Authorization header) to the server // using BenderProxy's HttpMessageWriter. Console.WriteLine("Generating authorization header value for user name '{0}' and password '{1}'", userName, password); BasicGenerator generator = new BasicGenerator(userName, password, authHeader); string authorizationHeaderValue = generator.GenerateAuthorizationHeader(); Console.WriteLine("Resending request with Authorization header: {0}", authorizationHeaderValue); context.RequestHeader.Authorization = authorizationHeaderValue; HttpMessageWriter writer = new HttpMessageWriter(context.ServerStream); writer.Write(context.RequestHeader); // Get the authorized response, and forward it on to the browser, using // BenderProxy's HttpHeaderReader and support classes. HttpResponseHeader header = new HttpResponseHeader(headerReader.ReadHttpMessageHeader()); string body = ReadFromStream(reader); Stream bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(body)); new HttpResponseWriter(context.ClientStream).Write(header, bodyStream, bodyStream.Length); } }
void IHttpServerAgent.HandleRequest(BaseConnection c, HttpMessageReader httpReader, ArraySegment <byte> httpContent) { if (httpReader.Method != Methods.Get) { var writer = new HttpMessageWriter(); writer.WriteResponse(StatusCodes.NotAcceptable); httpServer.SendResponse(c, writer); } else { if (httpReader.RequestUri.Equals(uri1)) { var writer = new HttpMessageWriter(); writer.WriteStatusLine(StatusCodes.MovedPermanently); writer.WriteContentLength(0); writer.WriteLocation(c.LocalEndPoint.Protocol == ServerProtocol.Tcp, httpReader.Host.Host, httpReader.Host.Port, uri2); writer.WriteCRLF(); httpServer.SendResponse(c, writer); } else { var rawFile = GetFile(httpReader); if (rawFile.HasValue == false) { var writer = new HttpMessageWriter(); writer.WriteResponse(StatusCodes.NotFound); httpServer.SendResponse(c, writer); } else { var file = rawFile.Value; var writer = new HttpMessageWriter(); writer.WriteStatusLine(StatusCodes.OK); writer.WriteContentType(file.ContentType); writer.WriteContentLength(file.Content.Length); writer.WriteCRLF(); httpServer.SendResponse(c, writer); httpServer.SendResponse(c, new ArraySegment <byte>(file.Content)); } } } }
private static void WriteHttpHeader(ServerAsyncEventArgs e) { using (var writer = new HttpMessageWriter()) { writer.WriteStatusLine(StatusCodes.OK); writer.WriteContentLength(e.Count); writer.WriteAccessControlHeaders(); writer.WriteCRLF(); e.OffsetOffset -= writer.Count; e.Count += writer.Count; Buffer.BlockCopy(writer.Buffer, writer.Offset, e.Buffer, e.Offset, writer.Count); } }
private void SendJsonMessage(Session session) { using (var writer = new HttpMessageWriter()) { //byte[] json = Encoding.UTF8.GetBytes(string.Format(@"{{id:{0}}}", session.Id)); byte[] json = Encoding.UTF8.GetBytes(string.Format(@"{0}", session.Id)); writer.WriteStatusLine(StatusCodes.OK); //writer.Write(Encoding.UTF8.GetBytes("Content-Type: application/json\r\n")); writer.WriteContentLength(json.Length); writer.WriteAccessControlHeaders(); writer.WriteCRLF(); writer.Write(json); SendWriter(session, writer); } }
public void ProcessIncomingRequest(BaseHttpConnection c) { bool handled = false; for (int i = 0; i < agents.Length; i++) { var result = agents[i].Value.IsHandled(c.HttpReader); if (result.IsHandled) { bool isAuthorized = true; if (agents[i].IsAuthorizationEnabled && result.IsAuthorizationRequred) { var writer = IsAuthorized(c, result.Realm, i); if (writer != null) { isAuthorized = false; SendResponse(c, writer, InvalidAgentIndex); } } if (isAuthorized) { agents[i].Value.HandleRequest(c, c.HttpReader, c.Content); } handled = true; break; } } if (handled == false) { var writer = new HttpMessageWriter(); writer.WriteStatusLine(StatusCodes.TemporaryRedirect); writer.WriteLocation(c.LocalEndPoint.Protocol == ServerProtocol.Tcp, c.HttpReader.Host.Host, c.HttpReader.Host.Port, defaultUri); writer.WriteContentLength(0); writer.WriteCRLF(); SendResponse(c, writer, InvalidAgentIndex); } }
/// <summary> /// Send <see cref="ProcessingContext.RequestHeader" /> to server, /// copy rest of the <see cref="ProcessingContext.ClientStream" /> to <see cref="ProcessingContext.ServerStream" /> /// and read <see cref="ProcessingContext.ResponseHeader" /> from <see cref="ProcessingContext.ServerStream" />. /// Expects <see cref="ProcessingContext.ServerStream" />, <see cref="ProcessingContext.RequestHeader" /> and /// <see cref="ProcessingContext.ClientStream" /> to be defined. /// </summary> /// <param name="context">current request context</param> protected virtual void ReceiveResponse(ProcessingContext context) { ContractUtils.Requires <ArgumentNullException>(context != null, "context"); ContractUtils.Requires <InvalidContextException>(context.ServerStream != null, "ServerStream"); ContractUtils.Requires <InvalidContextException>(context.RequestHeader != null, "RequestHeader"); ContractUtils.Requires <InvalidContextException>(context.ClientStream != null, "ClientStream"); ContractUtils.Requires <InvalidContextException>(context.ClientSocket != null, "ClientSocket"); var requestWriter = new HttpMessageWriter(context.ServerStream); requestWriter.Log += this.OnComponentLog; var responseReader = new HttpHeaderReader(new PlainStreamReader(context.ServerStream)); responseReader.Log += this.OnComponentLog; try { requestWriter.Write(context.RequestHeader, context.ClientStream, context.ClientSocket.Available); context.ResponseHeader = new HttpResponseHeader(responseReader.ReadHttpMessageHeader()); OnLog(LogLevel.Debug, "Response Received: {0}", TraceUtils.GetHttpTrace(context.ResponseHeader)); } catch (IOException ex) { var responseWriter = new HttpResponseWriter(context.ClientStream); if (ex.IsSocketException(SocketError.TimedOut)) { OnLog(LogLevel.Warn, "Request to remote server has timed out. {0}", TraceUtils.GetHttpTrace(context.RequestHeader)); responseWriter.WriteGatewayTimeout(); } else { throw; } context.StopProcessing(); } }
void IHttpServer.SendResponse(BaseConnection connection, HttpMessageWriter writer) { server.SendResponse(connection, writer, index); }
/// <summary> /// Handles the OnResponseReceived for the proxy, which occurs after the response is /// received from the web server, but before it is forwarded on to the browser. /// </summary> /// <param name="context">A <see cref="BenderProxy.ProcessingContext"/> object.</param> public override void OnResponseReceived(ProcessingContext context) { string userName = "******"; string password = "******"; if (context.ResponseHeader != null && context.ResponseHeader.StatusCode == 401) { // Only process requests for localhost or the redirected- // via-hosts-file-entry host, and where NTLM auth is requested. List <string> candidateUrls = new List <string>() { string.Format("localhost:{0}", TestWebAppPort), string.Format("{0}:{1}", TestWebAppHostName, TestWebAppPort) }; if (candidateUrls.Contains(context.RequestHeader.Host) && context.ResponseHeader.WWWAuthenticate != null && context.ResponseHeader.WWWAuthenticate.Contains(NtlmGenerator.AuthorizationHeaderMarker)) { // Read the headers from the response and finish reading the response // body, if any. Console.WriteLine("Received 401 - Unauthorized response"); context.ServerStream.ReadTimeout = 5000; context.ServerStream.WriteTimeout = 5000; StreamReader reader = new StreamReader(context.ServerStream); if (context.ResponseHeader.EntityHeaders.ContentLength != 0) { string drainBody = ReadFromStream(reader); } // We do not want the proxy to do any further processing after // handling this message. context.StopProcessing(); // Read the WWW-Authenticate header. Because of the way the test // web app is configured, it returns multiple headers, with // different schemes. We need to select the correct one. string authHeader = GetAuthenticationHeader(context.ResponseHeader.WWWAuthenticate, NtlmGenerator.AuthorizationHeaderMarker); Console.WriteLine("Processing WWW-Authenticate header: {0}", authHeader); // Generate the initial message (the "type 1" or "Negotiation" message") // and get the response, using BenderProxy's HttpMessageWriter and // HttpHeaderReader and support classes. Console.WriteLine("Generating authorization header value for Negotiate ('Type 1') message"); NtlmNegotiateMessageGenerator type1 = new NtlmNegotiateMessageGenerator(); string type1HeaderValue = type1.GenerateAuthorizationHeader(); context.RequestHeader.Authorization = type1HeaderValue; Console.WriteLine("Resending request with Authorization header: {0}", type1HeaderValue); HttpMessageWriter writer = new HttpMessageWriter(context.ServerStream); writer.Write(context.RequestHeader); HttpHeaderReader headerReader = new HttpHeaderReader(reader); HttpResponseHeader challengeHeader = new HttpResponseHeader(headerReader.ReadHttpMessageHeader()); string challengeAuthHeader = challengeHeader.WWWAuthenticate; string challengeBody = ReadFromStream(reader); if (!string.IsNullOrEmpty(challengeAuthHeader) && challengeAuthHeader.StartsWith(NtlmGenerator.AuthorizationHeaderMarker)) { // If a proper message was received (the "type 2" or "Challenge" message), // parse it, and generate the proper authentication header (the "type 3" // or "Authorization" message). Console.WriteLine("Received 401 response with Challenge ('Type 2') message: {0}", challengeAuthHeader); NtlmChallengeMessageGenerator type2 = new NtlmChallengeMessageGenerator(challengeAuthHeader); Console.WriteLine("Generating Authorization ('Type 3') message for user name '{0}' and password '{1}'", userName, password); NtlmAuthenticateMessageGenerator type3 = new NtlmAuthenticateMessageGenerator(null, null, userName, password, type2); string type3HeaderValue = type3.GenerateAuthorizationHeader(); Console.WriteLine("Resending request with Authorization header: {0}", type3HeaderValue); context.RequestHeader.Authorization = type3HeaderValue; writer.Write(context.RequestHeader); // Get the authorized response from the server, and forward it on to // the browser. HttpResponseHeader header = new HttpResponseHeader(headerReader.ReadHttpMessageHeader()); string body = ReadFromStream(reader); Stream bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(body)); new HttpResponseWriter(context.ClientStream).Write(header, bodyStream, bodyStream.Length); context.ClientStream.Flush(); } } } }
private void ProcessResponse(ProcessingContext context) { // Only do any processing on the response if the response is 401, // or "Unauthorized". if (context.ResponseHeader != null && context.ResponseHeader.StatusCode == 401) { //context.ServerStream.ReadTimeout = 5000; //context.ServerStream.WriteTimeout = 5000; var reader = new StreamReader(context.ServerStream); if (context.ResponseHeader.EntityHeaders.ContentLength != 0) { ReadFromStream(reader); } // We do not want the proxy to do any further processing after // handling this message. context.StopProcessing(); if (context.ResponseHeader.WWWAuthenticate.Contains(BasicGenerator.AuthorizationHeaderMarker)) { // This is the generation of the HTTP Basic authorization header value. var basicAuthHeaderValue = $"user:pass"; var encodedHeaderValue = Convert.ToBase64String(Encoding.ASCII.GetBytes(basicAuthHeaderValue)); context.RequestHeader.Authorization = "Basic " + encodedHeaderValue; // Resend the request (with the Authorization header) to the server // using BenderProxy's HttpMessageWriter. var writer = new HttpMessageWriter(context.ServerStream); writer.Write(context.RequestHeader); // Get the authorized response, and forward it on to the browser, using // BenderProxy's HttpHeaderReader and support classes. var headerReader = new HttpHeaderReader(reader); var header = new HttpResponseHeader(headerReader.ReadHttpMessageHeader()); var body = ReadFromStream(reader); Stream bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(body)); new HttpResponseWriter(context.ClientStream).Write(header, bodyStream, bodyStream.Length); } else if (context.ResponseHeader.WWWAuthenticate.Contains(NtlmGenerator.AuthorizationHeaderMarker)) { // Read the WWW-Authenticate header. Because of the way the test // web app is configured, it returns multiple headers, with // different schemes. We need to select the correct one. var authHeader = GetAuthenticationHeader(context.ResponseHeader.WWWAuthenticate, NtlmGenerator.AuthorizationHeaderMarker); var type1 = new NtlmNegotiateMessageGenerator(); var type1HeaderValue = type1.GenerateAuthorizationHeader(); context.RequestHeader.Authorization = type1HeaderValue; var writer = new HttpMessageWriter(context.ServerStream); writer.Write(context.RequestHeader); var headerReader = new HttpHeaderReader(reader); var challengeHeader = new HttpResponseHeader(headerReader.ReadHttpMessageHeader()); var challengeAuthHeader = challengeHeader.WWWAuthenticate; var challengeBody = ReadFromStream(reader); if (!string.IsNullOrEmpty(challengeAuthHeader) && challengeAuthHeader.StartsWith(NtlmGenerator.AuthorizationHeaderMarker)) { // If a proper message was received (the "type 2" or "Challenge" message), // parse it, and generate the proper authentication header (the "type 3" // or "Authorization" message). var type2 = new NtlmChallengeMessageGenerator(challengeAuthHeader); var type3 = new NtlmAuthenticateMessageGenerator(null, null, "user", "pass", type2); var type3HeaderValue = type3.GenerateAuthorizationHeader(); context.RequestHeader.Authorization = type3HeaderValue; writer.Write(context.RequestHeader); // Get the authorized response from the server, and forward it on to // the browser. var header = new HttpResponseHeader(headerReader.ReadHttpMessageHeader()); var body = ReadFromStream(reader); Stream bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(body)); new HttpResponseWriter(context.ClientStream).Write(header, bodyStream, bodyStream.Length); context.ClientStream.Flush(); } } } }
/// <summary> /// Send <see cref="ProcessingContext.RequestHeader" /> to server, /// copy rest of the <see cref="ProcessingContext.ClientStream" /> to <see cref="ProcessingContext.ServerStream" /> /// and read <see cref="ProcessingContext.ResponseHeader" /> from <see cref="ProcessingContext.ServerStream" />. /// Expects <see cref="ProcessingContext.ServerStream" />, <see cref="ProcessingContext.RequestHeader" /> and /// <see cref="ProcessingContext.ClientStream" /> to be defined. /// </summary> /// <param name="context">current request context</param> protected virtual void ReceiveResponse(ProcessingContext context) { Contract.Requires<ArgumentNullException>(context != null, "context"); Contract.Requires<InvalidContextException>(context.ServerStream != null, "ServerStream"); Contract.Requires<InvalidContextException>(context.RequestHeader != null, "RequestHeader"); Contract.Requires<InvalidContextException>(context.ClientStream != null, "ClientStream"); Contract.Requires<InvalidContextException>(context.ClientSocket != null, "ClientSocket"); var requestWriter = new HttpMessageWriter(context.ServerStream); var responseReader = new HttpHeaderReader(new PlainStreamReader(context.ServerStream)); try { requestWriter.Write(context.RequestHeader, context.ClientStream, context.ClientSocket.Available); context.ResponseHeader = new HttpResponseHeader(responseReader.ReadHttpMessageHeader()); if (Logger.IsDebugEnabled) { Logger.DebugFormat("Response Received: {0}", TraceUtils.GetHttpTrace(context.ResponseHeader)); } } catch (IOException ex) { var responseWriter = new HttpResponseWriter(context.ClientStream); if (ex.IsSocketException(SocketError.TimedOut)) { Logger.WarnFormat("Request to remote server has timed out. {0}", TraceUtils.GetHttpTrace(context.RequestHeader)); responseWriter.WriteGatewayTimeout(); } else { throw; } context.StopProcessing(); } }
void IHttpServerAgent.HandleRequest(BaseConnection c, HttpMessageReader httpReader, ArraySegment <byte> httpContent) { Console.WriteLine("{0} :: {1}", httpReader.Method.ToString(), httpReader.RequestUri.ToString()); HttpMessageWriter response = null; InitializeXcapPathParser(); int parsed; if (pathParser.ParseAll(httpReader.RequestUri.ToArraySegment(), out parsed) == false) { Console.WriteLine("Failed to parse requesr uri."); Console.WriteLine(" " + httpReader.RequestUri.ToString()); Console.WriteLine(" " + "^".PadLeft(parsed + 1, '-')); } else { pathParser.SetArray(httpReader.RequestUri.Bytes); if (httpReader.Method == Methods.Options) { response = GetWriter(); response.WriteOptionsResponse(); } else { if (pathParser.Username.IsValid && pathParser.Domain.IsValid) { var handler = usersHandlers.Get(pathParser.Auid.ToString()); switch (httpReader.Method) { case Methods.Get: response = handler.ProcessGetItem(pathParser.Username, pathParser.Domain); break; case Methods.Put: response = handler.ProcessPutItem(pathParser.Username, pathParser.Domain, httpReader, httpContent); break; case Methods.Delete: response = handler.ProcessDeleteItem(pathParser.Username, pathParser.Domain); break; default: response = null; break; } } else { var handler = genericHandlers.Get(pathParser.Auid.ToString()); if (handler == xcapCapsHander && xcapCapsHander.IsValid == false) { xcapCapsHander.Update(Handlers); } if (handler != null) { if (pathParser.IsGlobal) { response = handler.ProcessGlobal(); } else { switch (httpReader.Method) { case Methods.Get: response = handler.ProcessGetItem(pathParser.Item); break; case Methods.Put: response = handler.ProcessPutItem(pathParser.Item, httpContent); break; case Methods.Delete: response = handler.ProcessDeleteItem(pathParser.Item); break; default: response = null; break; } } } } } } if (response == null) { response = GetWriter(); response.WriteEmptyResponse(StatusCodes.NotFound); } httpServer.SendResponse(c, response); }
public String ShouldWriteHttpMessage(HttpMessageHeader header, Stream body, long? bodyLength) { var outputStream = new MemoryStream(); var httpWriter = new HttpMessageWriter(outputStream); httpWriter.Write(header, body, bodyLength); return Encoding.ASCII.GetString(outputStream.ToArray()); }