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