private byte[] SerializeHeader(string method, HttpConnectionRequest request)
{
using (MemoryStream memoryStream = new MemoryStream())
{
this._httpHeaderSerializer.WriteHeader((Stream)memoryStream, method, request);
return(memoryStream.ToArray());
}
}
public void WriteHeader(Stream stream, string method, HttpConnectionRequest request)
{
Uri url = request.Url;
using (StreamWriter streamWriter = new StreamWriter(stream, this._headerEncoding, 1024, true))
{
streamWriter.NewLine = "\r\n";
string requestTarget = HttpHeaderSerializer.GetRequestTarget(request);
string host = HttpHeaderSerializer.GetHost(url);
streamWriter.WriteLine(method.ToUpperInvariant() + " " + requestTarget + " HTTP/1.1");
streamWriter.WriteLine("Host: " + host);
streamWriter.WriteLine(request.KeepAlive ? "Connection: Keep-Alive" : "Connection: Close");
if ((Uri)null != request.Referrer)
{
streamWriter.WriteLine("Referer:" + (object)request.Referrer);
}
long?nullable = request.RangeFrom;
int num;
if (!nullable.HasValue)
{
nullable = request.RangeTo;
num = !nullable.HasValue ? 1 : 0;
}
else
{
num = 0;
}
if (num == 0)
{
streamWriter.WriteLine("Range: bytes={0}-{1}", new object[2]
{
(object)request.RangeFrom,
(object)request.RangeTo
});
}
if (null != this._userAgentLine)
{
streamWriter.WriteLine(this._userAgentLine);
}
if (!string.IsNullOrWhiteSpace(request.Accept))
{
streamWriter.WriteLine("Accept: " + request.Accept.Trim());
}
if (null != request.Headers)
{
foreach (KeyValuePair <string, string> keyValuePair in request.Headers)
{
string str1 = keyValuePair.Value;
string str2 = !string.IsNullOrWhiteSpace(str1) ? str1.Trim() : string.Empty;
streamWriter.WriteLine(keyValuePair.Key.Trim() + ": " + str2);
}
}
streamWriter.WriteLine();
streamWriter.Flush();
}
}
public void WriteHeader(Stream stream, string method, HttpConnectionRequest request)
{
var url = request.Url;
using (var tw = new StreamWriter(stream, _headerEncoding, 1024, true))
{
tw.NewLine = HttpEol;
var requestTarget = GetRequestTarget(request);
var host = GetHost(url);
tw.WriteLine(method.ToUpperInvariant() + " " + requestTarget + " HTTP/1.1");
tw.WriteLine("Host: " + host);
tw.WriteLine(request.KeepAlive ? "Connection: Keep-Alive" : "Connection: Close");
if (null != request.Referrer && request.Referrer.IsAbsoluteUri)
tw.WriteLine("Referer:" + request.Referrer.AbsoluteUri);
if (request.RangeFrom.HasValue || request.RangeTo.HasValue)
tw.WriteLine("Range: bytes={0}-{1}", request.RangeFrom, request.RangeTo);
if (null != _userAgentLine)
tw.WriteLine(_userAgentLine);
if (!string.IsNullOrWhiteSpace(request.Accept))
tw.WriteLine("Accept: " + request.Accept.Trim());
if (null != request.Cookies)
{
var cookieHeader = request.Cookies.GetCookieHeader(url);
if (!string.IsNullOrWhiteSpace(cookieHeader))
tw.WriteLine("Cookies: " + cookieHeader);
}
if (null != request.Headers)
{
foreach (var header in request.Headers)
{
var value = header.Value;
if (string.IsNullOrWhiteSpace(value))
value = string.Empty;
else
value = value.Trim();
tw.WriteLine(header.Key.Trim() + ": " + value);
}
}
tw.WriteLine();
tw.Flush();
}
}
private static string GetRequestTarget(HttpConnectionRequest request)
{
Uri url = request.Url;
if (!((Uri)null != request.Proxy))
{
return(url.PathAndQuery);
}
return(new UriBuilder(url)
{
Fragment = ((string)null)
}.Uri.ToString());
}
public virtual HttpConnectionRequest CreateRequest(Uri url, Uri referrer, ContentType contentType, long? fromBytes, long? toBytes, IEnumerable<KeyValuePair<string, string>> headers)
{
var request = new HttpConnectionRequest
{
Url = url,
Referrer = referrer,
RangeFrom = fromBytes,
RangeTo = toBytes,
Proxy = _parameters.Proxy,
Headers = headers,
Cookies = _parameters.Cookies
};
if (null != contentType)
request.Accept = CreateAcceptHeader(contentType);
return request;
}
public async Task<IHttpConnectionResponse> GetAsync(HttpConnectionRequest request, bool closeConnection, CancellationToken cancellationToken)
{
StartRequest();
// TODO: Fix closeConnection vs KeepAlive hack.
if (closeConnection)
request.KeepAlive = false;
var requestHeader = SerializeHeader("GET", request);
var writeHeaderTask = WriteSocketAsync(requestHeader, 0, requestHeader.Length, cancellationToken);
var httpReader = new HttpReader(ReadSocketAsync, _headerDecoding);
try
{
var statusLine = await httpReader.ReadNonBlankLineAsync(cancellationToken).ConfigureAwait(false);
ParseStatusLine(statusLine);
await ReadHeadersAsync(httpReader, request.Url, request.Cookies, cancellationToken).ConfigureAwait(false);
await writeHeaderTask.ConfigureAwait(false);
writeHeaderTask = null;
var stream = _httpStatus.ChunkedEncoding ? (Stream)new ChunkedStream(httpReader) : new ContentLengthStream(httpReader, _httpStatus.ContentLength);
var response = new HttpConnectionResponse(request.Url, closeConnection ? this : null, httpReader, stream,
_headers.ToLookup(kv => kv.Item1, kv => kv.Item2, StringComparer.OrdinalIgnoreCase), _httpStatus);
httpReader = null;
return response;
}
finally
{
if (null != httpReader)
httpReader.Dispose();
if (null != writeHeaderTask)
TaskCollector.Default.Add(writeHeaderTask, "HttpConnection GetAsync writer");
}
}
public async Task <IHttpConnectionResponse> GetAsync(HttpConnectionRequest request, bool closeConnection, CancellationToken cancellationToken)
{
this.StartRequest();
if (closeConnection)
{
request.KeepAlive = false;
}
byte[] requestHeader = this.SerializeHeader("GET", request);
Task <int> writeHeaderTask = this.WriteSocketAsync(requestHeader, 0, requestHeader.Length, cancellationToken);
HttpReader httpReader = new HttpReader(new HttpReader.ReadAsyncDelegate(this.ReadSocketAsync), this._headerDecoding);
IHttpConnectionResponse connectionResponse;
try
{
string statusLine = await HttpReaderExtensions.ReadNonBlankLineAsync((IHttpReader)httpReader, cancellationToken).ConfigureAwait(false);
this.ParseStatusLine(statusLine);
await this.ReadHeadersAsync(httpReader, cancellationToken).ConfigureAwait(false);
int num = await writeHeaderTask.ConfigureAwait(false);
writeHeaderTask = (Task <int>)null;
Stream stream = this._httpStatus.ChunkedEncoding ? (Stream) new ChunkedStream((IHttpReader)httpReader) : (Stream) new ContentLengthStream((IHttpReader)httpReader, this._httpStatus.ContentLength);
HttpConnectionResponse response = new HttpConnectionResponse(request.Url, closeConnection ? (IHttpConnection)this : (IHttpConnection)null, (IHttpReader)httpReader, stream, Enumerable.ToLookup <Tuple <string, string>, string, string>((IEnumerable <Tuple <string, string> >) this._headers, (Func <Tuple <string, string>, string>)(kv => kv.Item1), (Func <Tuple <string, string>, string>)(kv => kv.Item2), (IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase), (IHttpStatus)this._httpStatus);
httpReader = (HttpReader)null;
connectionResponse = (IHttpConnectionResponse)response;
}
finally
{
if (null != httpReader)
{
httpReader.Dispose();
}
if (null != writeHeaderTask)
{
TaskCollector.Default.Add((Task)writeHeaderTask, "HttpConnection GetAsync writer");
}
}
return(connectionResponse);
}
byte[] SerializeHeader(string method, HttpConnectionRequest request)
{
using (var ms = new MemoryStream())
{
_httpHeaderSerializer.WriteHeader(ms, method, request);
return ms.ToArray();
}
}
internal virtual async Task<IHttpConnectionResponse> GetAsync(HttpConnectionRequest request, CancellationToken cancellationToken)
{
var connection = _httpConnectionFactory.CreateHttpConnection();
var requestUrl = request.Url;
var url = requestUrl;
var retry = 0;
for (;;)
{
await connection.ConnectAsync(request.Proxy ?? url, cancellationToken).ConfigureAwait(false);
request.Url = url; // TODO: Unhack this...
var response = await connection.GetAsync(request, true, cancellationToken).ConfigureAwait(false);
request.Url = requestUrl;
var status = response.Status;
if (HttpStatusCode.Moved != status.StatusCode && HttpStatusCode.Redirect != status.StatusCode)
return response;
if (++retry >= 8)
return response;
connection.Close();
var location = response.Headers["Location"].FirstOrDefault();
if (!Uri.TryCreate(request.Url, location, out url))
return response;
}
}
static string GetRequestTarget(HttpConnectionRequest request)
{
var url = request.Url;
var proxy = request.Proxy;
if (null != proxy)
{
var ub = new UriBuilder(url) { Fragment = null };
return ub.Uri.AbsoluteUri;
}
var target = url.PathAndQuery;
return target;
}
public async Task<IHttpConnectionResponse> SendAsync(HttpConnectionRequest request, bool allowBuffering, CancellationToken cancellationToken, WebResponse webResponse = null)
{
var url = request.Url;
var response = await _webReaderManager.GetAsync(request, cancellationToken).ConfigureAwait(false);
Update(url, response, webResponse);
return response;
}
