|
private Find ( string httpMethod, char buffer, int len, |
||
| httpMethod | string | |
| buffer | char | |
| len | int | |
| handler | ||
| 리턴 | RouteMatch? | |
private RouteMatch?ReadUrl(int rowEnd, out RouteHandler handler)
{
var httpLen1 = HttpMethod.Length + 1;
var charBuf = TmpCharBuf;
var end = rowEnd - 2 - HttpProtocolVersion.Length;
for (int x = httpLen1; x < end; x++)
{
var tb = InputTemp[x];
if (tb > 250)
{
RawUrl = UTF8.GetString(InputTemp, httpLen1, end - httpLen1);
var askSign = RawUrl.IndexOf('?');
var absolutePath = askSign == -1 ? RawUrl : RawUrl.Substring(0, askSign);
return(Routes.Find(HttpMethod, RawUrl, absolutePath, out handler));
}
charBuf[x - httpLen1] = (char)tb;
}
var match = Routes.Find(HttpMethod, charBuf, end - httpLen1, out handler);
if (match == null)
{
RawUrl = new string(charBuf, 0, end - httpLen1);
}
else
{
RawUrl = match.Value.RawUrl;
}
return(match);
}
private void ProcessMessageThread(object state)
{
var context = (HttpListenerContext)state;
var request = context.Request;
var response = context.Response;
try
{
UriTemplateMatch templateMatch;
var route = Routes.Find(request, out templateMatch);
if (route != null)
{
var auth = Authentication.TryAuthorize(context, route);
if (auth.Principal != null)
{
var ctx = new HttpThreadContex(request, response, templateMatch);
ThreadContext.Request = ctx;
ThreadContext.Response = ctx;
Thread.CurrentPrincipal = auth.Principal;
using (var stream = route.Handle(templateMatch, context))
{
if (stream.CanSeek)
{
response.ContentLength64 = stream.Length;
}
stream.CopyTo(response.OutputStream);
}
}
else
{
ReturnError(response, (int)auth.ResponseCode, auth.Error);
}
}
else
{
var unknownRoute = "Unknown route " + request.RawUrl + " on method " + request.HttpMethod;
ReturnError(response, 404, unknownRoute);
}
}
catch (SecurityException sex)
{
ReturnError(response, (int)HttpStatusCode.Forbidden, sex.Message);
}
catch (WebFaultException <string> wfe)
{
ReturnError(response, (int)wfe.StatusCode, wfe.Detail);
}
catch (Exception ex)
{
ReturnError(response, 500, ex.Message);
}
finally
{
response.Close();
}
}
private void ProcessMessageThread(object state)
{
var context = (HttpListenerContext)state;
var request = context.Request;
var response = context.Response;
try
{
RouteHandler route;
var routeMatch = Routes.Find(request.HttpMethod, request.RawUrl, request.Url.AbsolutePath, out route);
if (routeMatch != null)
{
var match = routeMatch.Value;
var auth = Authentication.TryAuthorize(context.Request.Headers["Authorization"], context.Request.RawUrl, route);
if (auth.Principal != null)
{
var ctx = new HttpListenerContex(request, response, match, auth.Principal);
ThreadContext.Request = ctx;
ThreadContext.Response = ctx;
Thread.CurrentPrincipal = auth.Principal;
using (var stream = route.Handle(match.OrderedArgs, ctx, ctx, context.Request.InputStream, LocalStream.Value))
{
var cms = stream as ChunkedMemoryStream;
if (cms != null)
{
response.ContentLength64 = cms.Length;
cms.CopyTo(response.OutputStream);
}
else if (stream != null)
{
if (stream.CanSeek)
{
response.ContentLength64 = stream.Length;
}
stream.CopyTo(response.OutputStream);
}
else
{
response.ContentType = null;
response.ContentLength64 = 0;
}
}
}
else if (auth.SendAuthenticate)
{
context.Response.AddHeader("WWW-Authenticate", MissingBasicAuth);
ReturnError(response, (int)auth.ResponseCode, auth.Error);
}
else
{
ReturnError(response, (int)auth.ResponseCode, auth.Error);
}
}
else
{
var unknownRoute = "Unknown route " + request.RawUrl + " on method " + request.HttpMethod;
ReturnError(response, 404, unknownRoute);
}
}
catch (SecurityException sex)
{
ReturnError(response, (int)HttpStatusCode.Forbidden, sex.Message);
}
catch (ActionNotSupportedException anse)
{
ReturnError(response, 404, anse.Message);
}
catch (Exception ex)
{
TraceSource.TraceEvent(TraceEventType.Error, 5403, "{0}", ex);
ReturnError(response, 500, ex.Message);
}
finally
{
response.Close();
}
}
private void ProcessSocketThread(object state)
{
var socket = (Socket)state;
socket.Blocking = true;
IPrincipal previousPrincipal = null;
var ctx = Context.Value;
ctx.Reset();
try
{
while (ctx.Parse(socket))
{
RouteMatch match;
var route = Routes.Find(ctx.HttpMethod, ctx.RawUrl, ctx.AbsolutePath, out match);
if (route == null)
{
var unknownRoute = "Unknown route " + ctx.RawUrl + " on method " + ctx.HttpMethod;
ctx.ReturnError(socket, 404, unknownRoute, false);
break;
}
var auth = Authentication.TryAuthorize(ctx.GetRequestHeader("authorization"), ctx.RawUrl, route);
if (auth.Principal != null)
{
ctx.ForRouteWithAuth(match, auth.Principal);
ThreadContext.Request = ctx;
ThreadContext.Response = ctx;
if (previousPrincipal != auth.Principal)
{
Thread.CurrentPrincipal = previousPrincipal = auth.Principal;
}
using (var stream = route.Handle(match.OrderedArgs, ctx.Stream))
{
var keepAlive = ctx.Return(stream, socket);
if (keepAlive)
{
if (ctx.Pipeline)
{
continue;
}
else if (socket.Connected)
{
Thread.Yield();
if (socket.Poll(1000000, SelectMode.SelectRead))
{
continue;
}
}
}
socket.Close();
break;
}
}
else if (auth.SendAuthenticate)
{
ctx.AddHeader("WWW-Authenticate", MissingBasicAuth);
ctx.ReturnError(socket, (int)auth.ResponseCode, auth.Error, true);
break;
}
else
{
ctx.ReturnError(socket, (int)auth.ResponseCode, auth.Error, true);
break;
}
}
}
catch (SecurityException sex)
{
try { ctx.ReturnError(socket, (int)HttpStatusCode.Forbidden, sex.Message, true); }
catch (Exception ex)
{
Console.WriteLine(ex.Message);
TraceSource.TraceEvent(TraceEventType.Error, 5404, "{0}", ex);
}
}
catch (ActionNotSupportedException anse)
{
try { ctx.ReturnError(socket, 404, anse.Message, true); }
catch (Exception ex)
{
Console.WriteLine(ex.Message);
TraceSource.TraceEvent(TraceEventType.Error, 5404, "{0}", ex);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
TraceSource.TraceEvent(TraceEventType.Error, 5403, "{0}", ex);
try { ctx.ReturnError(socket, 500, ex.Message, false); }
catch (Exception ex2)
{
Console.WriteLine(ex2.Message);
TraceSource.TraceEvent(TraceEventType.Error, 5404, "{0}", ex2);
}
}
}
private void ProcessSocket(Socket socket, HttpSocketContext ctx, IPrincipal principal)
{
ctx.Reset();
try
{
while (ctx.Parse(socket))
{
RouteMatch match;
var route = Routes.Find(ctx.HttpMethod, ctx.RawUrl, ctx.AbsolutePath, out match);
if (route == null)
{
var unknownRoute = "Unknown route " + ctx.RawUrl + " on method " + ctx.HttpMethod;
ctx.ReturnError(socket, 404, unknownRoute, false);
break;
}
var auth = Authentication.TryAuthorize(ctx.GetRequestHeader("authorization"), ctx.RawUrl, route);
if (auth.Principal != null)
{
ctx.ForRouteWithAuth(match, auth.Principal);
ThreadContext.Request = ctx;
ThreadContext.Response = ctx;
if (principal != auth.Principal)
{
Thread.CurrentPrincipal = principal = auth.Principal;
}
using (var stream = route.Handle(match.OrderedArgs, ctx, ctx, ctx.InputStream, ctx.OutputStream))
{
var keepAlive = ctx.Return(stream, socket);
if (keepAlive)
{
if (ctx.Pipeline)
{
continue;
}
else if (socket.Connected)
{
if (Requests.TryAdd(new RequestInfo(socket, socket.Available > 0)))
{
return;
}
}
}
socket.Close();
return;
}
}
else if (auth.SendAuthenticate)
{
ctx.AddHeader("WWW-Authenticate", MissingBasicAuth);
ctx.ReturnError(socket, (int)auth.ResponseCode, auth.Error, true);
return;
}
else
{
ctx.ReturnError(socket, (int)auth.ResponseCode, auth.Error, true);
return;
}
}
}
catch (SecurityException sex)
{
try { ctx.ReturnError(socket, (int)HttpStatusCode.Forbidden, sex.Message, true); }
catch (Exception ex)
{
TraceSource.TraceEvent(TraceEventType.Error, 5404, "{0}", ex);
}
}
catch (ActionNotSupportedException anse)
{
try { ctx.ReturnError(socket, 404, anse.Message, true); }
catch (Exception ex)
{
TraceSource.TraceEvent(TraceEventType.Error, 5404, "{0}", ex);
}
}
catch (Exception ex)
{
TraceSource.TraceEvent(TraceEventType.Error, 5403, "{0}", ex);
try { ctx.ReturnError(socket, 500, ex.Message, false); }
catch (Exception ex2)
{
TraceSource.TraceEvent(TraceEventType.Error, 5404, "{0}", ex2);
}
}
}
