/// <summary>
/// Check if item is cachable
/// </summary>
/// <param name="request">Incoming request</param>
/// <returns>True when cacheable</returns>
public bool IsCacheable(HttpRequest request)
{
if (FilterContent && request.AsksForImage())
{
return(false);
}
if (!request.RequestLine.Split(' ')[0].ToLower().Contains("get"))
{
return(false);
}
if (request.HasHeader("Authorization"))
{
return(false);
}
if (request.HasHeader("Cache-Control") && request.GetHeader("Cache-Control").Value == "private")
{
return(false);
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
private async void HandleRequest(TcpClient client)
{
try
{
using (client)
using (NetworkStream clientNs = client.GetStream())
using (MemoryStream clienMs = new MemoryStream())
{
var buffer = new byte[BufferSize];
int bytesRead;
Thread.Sleep(5);
if (clientNs.CanRead)
{
if (clientNs.DataAvailable)
{
do
{
bytesRead = clientNs.Read(buffer, 0, buffer.Length);
clienMs.Write(buffer, 0, bytesRead);
} while (clientNs.DataAvailable);
}
}
try
{
HttpRequest request = HttpRequest.Parse(clienMs.GetBuffer());
dispatcher.Invoke(() => AddToLog(request));
HttpResponse response = null;
if (!AccessAuthentication || Authenticated(request))
{
FilterUser(request);
if (FilterContent && request.AsksForImage())
{
response = HttpResponse.GetPlaceholderImageResponse(PlaceholderImage);
clientNs.Write(response.ToBytes, 0, response.ToBytes.Length);
}
if (ProxyCache.Where(x => x.RequestLine == request.RequestLine && x.Valid(CacheTimeOutSec)).Count() > 0 && (CheckChangeContent || HandledMessages.Where(x => x.FirstLine == request.FirstLine).Count() > FrequentUseCount))
{
response = ProxyCache.FirstOrDefault(x => x.RequestLine == request.RequestLine && x.Valid(CacheTimeOutSec)).ToResponse();
clientNs.Write(response.ToBytes, 0, response.ToBytes.Length);
}
if (response == null)
{
try
{
using (TcpClient serverClient = new TcpClient(request.GetRequestedHost(), 80))
using (NetworkStream serverStream = serverClient.GetStream())
{
serverClient.SendTimeout = 500;
serverClient.ReceiveTimeout = 1000;
var serverBuffer = new byte[BufferSize];
using (MemoryStream ms = new MemoryStream())
{
await serverStream.WriteAsync(request.ToBytes, 0, request.ToBytes.Length);
int numBytesRead;
try
{
while ((numBytesRead = serverStream.Read(serverBuffer, 0, serverBuffer.Length)) > 0)
{
clientNs.Write(serverBuffer, 0, numBytesRead);
ms.Write(serverBuffer, 0, numBytesRead);
}
}
catch { }
try
{
response = HttpResponse.Parse(ms.GetBuffer());
if (IsCacheable(request) && (CheckChangeContent || HandledMessages.Where(x => x.FirstLine == request.FirstLine).Count() > FrequentUseCount))
{
ProxyCache.Add(new CacheItem(request, response));
}
}
catch
{
Debug.WriteLine("Response not parsable");
}
}
}
}
catch (SocketException)
{
clientNs.Write(HttpResponse.Get404Response().ToBytes, 0, HttpResponse.Get400Response().ToBytes.Length);
}
}
}
else
{
response = HttpResponse.Get407Response();
clientNs.Write(response.ToBytes, 0, response.ToBytes.Length);
}
dispatcher.Invoke(() => AddToLog(response));
}
catch (FormatException)
{
clientNs.Write(HttpResponse.Get400Response().ToBytes, 0, HttpResponse.Get400Response().ToBytes.Length);
}
catch
{
clientNs.Write(HttpResponse.Get500Response().ToBytes, 0, HttpResponse.Get400Response().ToBytes.Length);
}
}
}
catch { Debug.WriteLine("Error while handling incomming request"); }
}
