private void Update(Uri url, IHttpConnectionResponse response, WebResponse webResponse)
{
if (null != webResponse)
{
webResponse.RequestUri = response.ResponseUri;
WebResponse webResponse1 = webResponse;
long? nullable1 = response.Status.ContentLength;
long? nullable2;
if ((nullable1.GetValueOrDefault() < 0L ? 0 : (nullable1.HasValue ? 1 : 0)) == 0)
{
nullable1 = new long?();
nullable2 = nullable1;
}
else
{
nullable2 = response.Status.ContentLength;
}
webResponse1.ContentLength = nullable2;
webResponse.Headers = this.GetHeaders(response.Headers);
webResponse.ContentType = EnumerableExtensions.SingleOrDefaultSafe <ContentType>((IEnumerable <ContentType>) this._contentTypeDetector.GetContentType(response.ResponseUri, Enumerable.FirstOrDefault <string>(response.Headers["Content-Type"]), (string)null));
}
if (url != this.BaseAddress)
{
return;
}
this.RequestUri = response.ResponseUri;
if (!((ContentType)null == this.ContentType))
{
return;
}
this.ContentType = EnumerableExtensions.SingleOrDefaultSafe <ContentType>((IEnumerable <ContentType>) this._contentTypeDetector.GetContentType(this.RequestUri, Enumerable.FirstOrDefault <string>(response.Headers["Content-Type"]), (string)null));
}
public async Task <IHttpConnectionResponse> SendAsync(HttpConnectionRequest request, bool allowBuffering, CancellationToken cancellationToken, WebResponse webResponse = null)
{
Uri url = request.Url;
IHttpConnectionResponse response = await this._webReaderManager.GetAsync(request, cancellationToken);
this.Update(url, response, webResponse);
return(response);
}
public async Task <IWebStreamResponse> GetWebStreamAsync(Uri url, bool waitForContent, CancellationToken cancellationToken, Uri referrer = null, long?from = null, long?to = null, WebResponse webResponse = null)
{
HttpConnectionRequest request = this._webReaderManager.CreateRequest(url, referrer, (IWebReader)this, this.ContentType, (string)null, waitForContent, from, to);
IHttpConnectionResponse response = await this._webReaderManager.GetAsync(request, cancellationToken).ConfigureAwait(false);
this.Update(url, response, webResponse);
return((IWebStreamResponse) new HttpConnectionWebStreamResponse(response));
}
public HttpConnectionWebStreamResponse(IHttpConnectionResponse response)
{
if (null == response)
throw new ArgumentNullException(nameof(response));
if (null == response.Status)
throw new ArgumentException("Not status in response", nameof(response));
_response = response;
_httpStatus = _response.Status;
}
public HttpConnectionWebStreamResponse(IHttpConnectionResponse response)
{
if (null == response)
{
throw new ArgumentNullException("response");
}
if (null == response.Status)
{
throw new ArgumentException("Not status in response", "response");
}
this._response = response;
this._httpStatus = this._response.Status;
}
private async Task <byte[]> FetchObject(IHttpConnectionResponse response, CancellationToken cancellationToken)
{
this._lastModified = Enumerable.FirstOrDefault <string>(response.Headers["Last-Modified"]);
this._etag = Enumerable.FirstOrDefault <string>(response.Headers["ETag"]);
this._cacheControl = Enumerable.FirstOrDefault <string>(response.Headers["CacheControl"]);
byte[] numArray;
using (MemoryStream memoryStream = new MemoryStream())
{
await response.ContentReadStream.CopyToAsync((Stream)memoryStream, 4096, cancellationToken).ConfigureAwait(false);
numArray = memoryStream.ToArray();
}
return(numArray);
}
internal virtual async Task <IHttpConnectionResponse> GetAsync(HttpConnectionRequest request, CancellationToken cancellationToken)
{
IHttpConnection connection = this._httpConnectionFactory.CreateHttpConnection();
Uri requestUrl = request.Url;
Uri url = requestUrl;
int retry = 0;
IHttpConnectionResponse response;
string location;
do
{
await connection.ConnectAsync(request.Proxy ?? url, cancellationToken).ConfigureAwait(false);
request.Url = url;
response = await connection.GetAsync(request, true, cancellationToken).ConfigureAwait(false);
request.Url = requestUrl;
IHttpStatus status = response.Status;
if (HttpStatusCode.Moved == status.StatusCode || HttpStatusCode.Found == status.StatusCode)
{
if (++retry < 8)
{
connection.Close();
location = Enumerable.FirstOrDefault <string>(response.Headers["Location"]);
}
else
{
goto label_5;
}
}
else
{
goto label_3;
}
}while (Uri.TryCreate(request.Url, location, out url));
goto label_7;
label_3:
IHttpConnectionResponse connectionResponse = response;
goto label_9;
label_5:
connectionResponse = response;
goto label_9;
label_7:
connectionResponse = response;
label_9:
return(connectionResponse);
}
public async Task <byte[]> GetByteArrayAsync(Uri url, CancellationToken cancellationToken, WebResponse webResponse = null)
{
if ((Uri)null != this._baseAddress && !url.IsAbsoluteUri)
{
url = new Uri(this._baseAddress, url);
}
byte[] numArray;
using (IHttpConnectionResponse response = await this._webReaderManager.SendAsync(url, (IWebReader)this, cancellationToken, (string)null, (ContentType)null, true, (Uri)null, new long?(), new long?()).ConfigureAwait(false))
{
response.EnsureSuccessStatusCode();
this.Update(url, response, webResponse);
using (MemoryStream memoryStream = new MemoryStream())
{
await response.ContentReadStream.CopyToAsync((Stream)memoryStream, 4096, cancellationToken).ConfigureAwait(false);
numArray = memoryStream.ToArray();
}
}
return(numArray);
}
private async Task Fetch <TCached>(IRetry retry, Func <Uri, byte[], TCached> factory, WebResponse webResponse, CancellationToken cancellationToken) where TCached : class
{
label_12:
HttpConnectionRequest request = this.CreateRequest();
using (IHttpConnectionResponse response = await this._webReader.SendAsync(request, true, cancellationToken, webResponse).ConfigureAwait(false))
{
if (response.IsSuccessStatusCode)
{
this._firstRequestCompleted = true;
Func <Uri, byte[], TCached> func1 = factory;
Uri responseUri = response.ResponseUri;
Func <Uri, byte[], TCached> func2 = func1;
HttpConnectionWebCache connectionWebCache = this;
byte[] numArray = await this.FetchObject(response, cancellationToken).ConfigureAwait(false);
// ISSUE: variable of a boxed type
var local = (object)func2(responseUri, numArray);
connectionWebCache._cachedObject = (object)local;
}
else
{
HttpStatusCode statusCode = response.Status.StatusCode;
if (HttpStatusCode.NotModified != statusCode)
{
if (RetryPolicy.IsRetryable(statusCode))
{
if (await retry.CanRetryAfterDelayAsync(cancellationToken).ConfigureAwait(false))
{
goto label_12;
}
}
this._cachedObject = (object)null;
response.EnsureSuccessStatusCode();
throw new WebException("Unable to fetch " + (object)request.Url);
}
}
}
}
public virtual async Task <ContentType> DetectContentTypeAsync(Uri url, ContentKind contentKind, CancellationToken cancellationToken, IWebReader parent = null)
{
ContentType contentType = EnumerableExtensions.SingleOrDefaultSafe <ContentType>((IEnumerable <ContentType>) this._contentTypeDetector.GetContentType(url, (string)null, (string)null));
ContentType contentType1;
if ((ContentType)null != contentType)
{
Debug.WriteLine("HttpConnectionWebReaderManager.DetectContentTypeAsync() url ext \"{0}\" type {1}", (object)url, (object)contentType);
contentType1 = contentType;
}
else
{
try
{
using (IHttpConnectionResponse connectionResponse = await this.SendAsync(url, parent, cancellationToken, "HEAD", (ContentType)null, false, (Uri)null, new long?(), new long?()).ConfigureAwait(false))
{
contentType = EnumerableExtensions.SingleOrDefaultSafe <ContentType>((IEnumerable <ContentType>) this._contentTypeDetector.GetContentType(connectionResponse.ResponseUri, Enumerable.FirstOrDefault <string>(connectionResponse.Headers["Content-Type"]), (string)null));
if ((ContentType)null != contentType)
{
Debug.WriteLine("HttpConnectionWebReaderManager.DetectContentTypeAsync() url HEAD \"{0}\" type {1}", (object)url, (object)contentType);
contentType1 = contentType;
goto label_29;
}
}
}
catch (WebException ex)
{
}
try
{
using (IHttpConnectionResponse connectionResponse = await this.SendAsync(url, parent, cancellationToken, (string)null, (ContentType)null, false, (Uri)null, new long?(0L), new long?(0L)).ConfigureAwait(false))
{
contentType = EnumerableExtensions.SingleOrDefaultSafe <ContentType>((IEnumerable <ContentType>) this._contentTypeDetector.GetContentType(connectionResponse.ResponseUri, Enumerable.FirstOrDefault <string>(connectionResponse.Headers["Content-Type"]), (string)null));
if ((ContentType)null != contentType)
{
Debug.WriteLine("HttpConnectionWebReaderManager.DetectContentTypeAsync() url range GET \"{0}\" type {1}", (object)url, (object)contentType);
contentType1 = contentType;
goto label_29;
}
}
}
catch (WebException ex)
{
}
try
{
using (IHttpConnectionResponse connectionResponse = await this.SendAsync(url, parent, cancellationToken, (string)null, (ContentType)null, false, (Uri)null, new long?(), new long?()).ConfigureAwait(false))
{
contentType = EnumerableExtensions.SingleOrDefaultSafe <ContentType>((IEnumerable <ContentType>) this._contentTypeDetector.GetContentType(connectionResponse.ResponseUri, Enumerable.FirstOrDefault <string>(connectionResponse.Headers["Content-Type"]), (string)null));
if ((ContentType)null != contentType)
{
Debug.WriteLine("HttpConnectionWebReaderManager.DetectContentTypeAsync() url GET \"{0}\" type {1}", (object)url, (object)contentType);
contentType1 = contentType;
goto label_29;
}
}
}
catch (WebException ex)
{
}
Debug.WriteLine("HttpConnectionWebReaderManager.DetectContentTypeAsync() url header \"{0}\" unknown type", (object)url);
contentType1 = (ContentType)null;
}
label_29:
return(contentType1);
}
void Update(Uri url, IHttpConnectionResponse response, WebResponse webResponse)
{
if (null != webResponse)
{
webResponse.RequestUri = response.ResponseUri;
webResponse.ContentLength = response.Status.ContentLength >= 0 ? response.Status.ContentLength : null;
webResponse.Headers = GetHeaders(response.Headers);
webResponse.ContentType = _contentTypeDetector.GetContentType(response.ResponseUri, ContentKind.Unknown, response.Headers["Content-Type"].FirstOrDefault()).SingleOrDefaultSafe();
}
if (url != BaseAddress)
return;
RequestUri = response.ResponseUri;
if (null == ContentType)
ContentType = _contentTypeDetector.GetContentType(RequestUri, ContentKind.Unknown, response.Headers["Content-Type"].FirstOrDefault()).SingleOrDefaultSafe();
}
