public HttpProxyServerAdapter(DataAdapterToStream stm, HttpRequestHeader initialRequest, Logger logger)
{
_stm = stm;
_writer = new DataWriter(_stm);
_request = initialRequest;
_config = new HttpParserConfig();
_config.StreamBody = true;
_logger = logger;
Description = stm.Description;
}
private void FlushRequest(HttpRequestHeader request)
{
if (!request.IsConnect)
{
HttpParserConfig config = new HttpParserConfig();
config.StreamBody = true;
IEnumerator <HttpRequestDataChunk> e = request.ReadChunks(config).GetEnumerator();
while (e.MoveNext())
{
}
}
}
public HttpProxyServerAdapter(FullHttpProxyServer server, DataAdapterToStream stm, HttpRequestHeader initialRequest, Logger logger)
{
_server = server;
_stm = stm;
_writer = new DataWriter(_stm);
_request = initialRequest;
ProcessProxyRequestHeaders(_request);
_config = new HttpParserConfig();
_config.StreamBody = true;
_logger = logger;
_requestQueue = new Queue <HttpRequestHeader>();
_requestQueue.Enqueue(_request);
Description = stm.Description;
}
private HttpParserConfig CreateConfig(HttpRequestHeader header)
{
HttpParserConfig config = new HttpParserConfig();
HttpLayerConfigEntry entry = _layer._config.GetEntry(header);
config.StreamBody = entry.RequestStreamBody;
config.StreamChunkSize = _layer._config.RequestStreamChunkSize;
config.StrictParsing = _layer._config.RequestStrictParsing;
if (_layer._config.BufferedRequestMaxLength != 0 && (header.ContentLength > _layer._config.BufferedRequestMaxLength))
{
config.StreamBody = true;
}
return(config);
}
private HttpParserConfig CreateConfig(HttpResponseHeader response, HttpRequestHeader request)
{
HttpParserConfig config = new HttpParserConfig();
HttpLayerConfigEntry entry = _layer._config.GetEntry(request, response);
config.ConvertToChunked = entry.ConvertToChunked;
config.StreamBody = entry.ResponseStreamBody;
config.StreamChunkSize = _layer._config.ResponseStreamChunkSize;
config.StrictParsing = _layer._config.ResponseStrictParsing;
if (_layer._config.BufferedResponseMaxLength != 0 && (response.ContentLength > _layer._config.BufferedResponseMaxLength))
{
config.StreamBody = true;
}
return(config);
}
private IEnumerable <HttpResponseDataChunk> GetResponse(ProxyConnection conn, Uri url, bool headRequest)
{
try
{
DataReader reader = new DataReader(conn.DataAdapter.Coupling);
HttpParserConfig config = new HttpParserConfig();
config.StreamBody = true;
if (_server._config.Version10Proxy)
{
config.DowngradeChunkedToHttp10 = true;
}
_logger.LogVerbose("Starting processing of {0}", url);
HttpResponseHeader response = HttpParser.ReadResponseHeader(reader, false, _logger);
// If 100 continue then read out just that response then restart read
if (response.Is100Continue)
{
foreach (HttpResponseDataChunk chunk in response.ReadChunks(config))
{
_logger.LogVerbose("Read 100 continue chunk for {0} {1} {2}", url, chunk.Body.Length, chunk.FinalChunk);
yield return(chunk);
}
response = HttpParser.ReadResponseHeader(reader, false, _logger);
}
_logger.LogVerbose("Read response header {0}", response.ResponseCode);
response.SetHeadRequest(headRequest);
foreach (HttpResponseDataChunk newChunk in response.ReadChunks(config))
{
_logger.LogVerbose("Read chunk for {0} {1} {2}", url, newChunk.Body.Length, newChunk.FinalChunk);
yield return(newChunk);
}
}
finally
{
bool closeSuccess = false;
try
{
conn.DataAdapter.Coupling.Dispose();
lock (_graphs)
{
_graphs.Remove(conn.Graph);
}
closeSuccess = true;
}
catch (OperationCanceledException)
{
}
catch (ObjectDisposedException)
{
}
if (!closeSuccess)
{
lock (_graphs)
{
// Force close
_service.CloseConnection(conn.Graph);
_graphs.Remove(conn.Graph);
}
}
}
}
