private void ThreadFunc(object param)
{
bool flag = false;
bool flag2 = false;
RetryCauses retryCauses = RetryCauses.None;
object obj = null;
try
{
if (!CurrentRequest.DisableCache)
{
Monitor.Enter(obj = HTTPCacheFileLock.Acquire(CurrentRequest.CurrentUri));
}
CurrentRequest.Processing = true;
if (!TryLoadAllFromCache())
{
if (Client != null && !Client.IsConnected())
{
Close();
}
do
{
if (retryCauses == RetryCauses.Reconnect)
{
Close();
Thread.Sleep(100);
}
retryCauses = RetryCauses.None;
Connect();
if (!CurrentRequest.DisableCache)
{
HTTPCacheService.SetHeaders(CurrentRequest);
}
bool flag3 = CurrentRequest.SendOutTo(Stream);
if (!flag3)
{
Close();
if (!flag)
{
flag = true;
retryCauses = RetryCauses.Reconnect;
}
}
if (flag3)
{
if (!Receive() && !flag)
{
flag = true;
retryCauses = RetryCauses.Reconnect;
}
if (CurrentRequest.Response != null)
{
switch (CurrentRequest.Response.StatusCode)
{
case 401:
{
string firstHeaderValue2 = CurrentRequest.Response.GetFirstHeaderValue("www-authenticate");
if (!string.IsNullOrEmpty(firstHeaderValue2))
{
Digest orCreate = DigestStore.GetOrCreate(CurrentRequest.CurrentUri);
orCreate.ParseChallange(firstHeaderValue2);
if (CurrentRequest.Credentials != null && orCreate.IsUriProtected(CurrentRequest.CurrentUri) && (!CurrentRequest.HasHeader("Authorization") || orCreate.Stale))
{
retryCauses = RetryCauses.Authenticate;
}
}
break;
}
case 301:
case 302:
case 307:
if (CurrentRequest.RedirectCount < CurrentRequest.MaxRedirects)
{
CurrentRequest.RedirectCount++;
string firstHeaderValue = CurrentRequest.Response.GetFirstHeaderValue("location");
if (string.IsNullOrEmpty(firstHeaderValue))
{
throw new MissingFieldException($"Got redirect status({CurrentRequest.Response.StatusCode.ToString()}) without 'location' header!");
}
CurrentRequest.RedirectUri = GetRedirectUri(firstHeaderValue);
CurrentRequest.Response = null;
bool flag4 = true;
CurrentRequest.IsRedirected = flag4;
flag2 = flag4;
}
break;
}
TryStoreInCache();
if (CurrentRequest.Response.HasHeaderWithValue("connection", "close") || CurrentRequest.UseAlternateSSL)
{
Close();
}
}
}
}while (retryCauses != 0);
}
}
catch (Exception exception)
{
if (CurrentRequest.UseStreaming)
{
HTTPCacheService.DeleteEntity(CurrentRequest.CurrentUri);
}
CurrentRequest.Response = null;
CurrentRequest.Exception = exception;
Close();
}
finally
{
if (!CurrentRequest.DisableCache && obj != null)
{
Monitor.Exit(obj);
}
HTTPCacheService.SaveLibrary();
CurrentRequest.Processing = false;
if (CurrentRequest != null && CurrentRequest.Response != null && CurrentRequest.Response.IsUpgraded)
{
State = HTTPConnectionStates.Upgraded;
}
else
{
State = (flag2 ? HTTPConnectionStates.Redirected : ((Client != null) ? HTTPConnectionStates.WaitForRecycle : HTTPConnectionStates.Closed));
}
LastProcessTime = DateTime.UtcNow;
}
}
private void ThreadFunc(object param)
{
bool flag = false;
bool flag2 = false;
HTTPConnection.RetryCauses retryCauses = HTTPConnection.RetryCauses.None;
try
{
if (!this.HasProxy && this.CurrentRequest.HasProxy)
{
this.Proxy = this.CurrentRequest.Proxy;
}
if (!this.TryLoadAllFromCache())
{
if (this.Client != null && !this.Client.IsConnected())
{
this.Close();
}
while (true)
{
if (retryCauses == HTTPConnection.RetryCauses.Reconnect)
{
this.Close();
Thread.Sleep(100);
}
this.LastProcessedUri = this.CurrentRequest.CurrentUri;
retryCauses = HTTPConnection.RetryCauses.None;
this.Connect();
if (this.State == HTTPConnectionStates.AbortRequested)
{
break;
}
if (!this.CurrentRequest.DisableCache)
{
HTTPCacheService.SetHeaders(this.CurrentRequest);
}
bool flag3 = this.CurrentRequest.SendOutTo(this.Stream);
if (!flag3)
{
this.Close();
if (this.State == HTTPConnectionStates.TimedOut)
{
goto Block_13;
}
if (!flag)
{
flag = true;
retryCauses = HTTPConnection.RetryCauses.Reconnect;
}
}
if (flag3)
{
bool flag4 = this.Receive();
if (this.State == HTTPConnectionStates.TimedOut)
{
goto Block_16;
}
if (!flag4 && !flag)
{
flag = true;
retryCauses = HTTPConnection.RetryCauses.Reconnect;
}
if (this.CurrentRequest.Response != null)
{
int statusCode = this.CurrentRequest.Response.StatusCode;
switch (statusCode)
{
case 301:
case 302:
case 307:
case 308:
{
if (this.CurrentRequest.RedirectCount >= this.CurrentRequest.MaxRedirects)
{
goto IL_3F7;
}
this.CurrentRequest.RedirectCount++;
string firstHeaderValue = this.CurrentRequest.Response.GetFirstHeaderValue("location");
if (string.IsNullOrEmpty(firstHeaderValue))
{
goto IL_3C9;
}
Uri redirectUri = this.GetRedirectUri(firstHeaderValue);
if (!this.CurrentRequest.CallOnBeforeRedirection(redirectUri))
{
HTTPManager.Logger.Information("HTTPConnection", "OnBeforeRedirection returned False");
goto IL_3F7;
}
this.CurrentRequest.RemoveHeader("Host");
this.CurrentRequest.SetHeader("Referer", this.CurrentRequest.CurrentUri.ToString());
this.CurrentRequest.RedirectUri = redirectUri;
this.CurrentRequest.Response = null;
bool flag5 = true;
this.CurrentRequest.IsRedirected = flag5;
flag2 = flag5;
goto IL_3F7;
}
case 303:
case 304:
case 305:
case 306:
IL_186:
if (statusCode == 401)
{
string firstHeaderValue2 = this.CurrentRequest.Response.GetFirstHeaderValue("www-authenticate");
if (!string.IsNullOrEmpty(firstHeaderValue2))
{
Digest orCreate = DigestStore.GetOrCreate(this.CurrentRequest.CurrentUri);
orCreate.ParseChallange(firstHeaderValue2);
if (this.CurrentRequest.Credentials != null && orCreate.IsUriProtected(this.CurrentRequest.CurrentUri) && (!this.CurrentRequest.HasHeader("Authorization") || orCreate.Stale))
{
retryCauses = HTTPConnection.RetryCauses.Authenticate;
}
}
goto IL_3F7;
}
if (statusCode != 407)
{
goto IL_3F7;
}
if (this.CurrentRequest.HasProxy)
{
string firstHeaderValue3 = this.CurrentRequest.Response.GetFirstHeaderValue("proxy-authenticate");
if (!string.IsNullOrEmpty(firstHeaderValue3))
{
Digest orCreate2 = DigestStore.GetOrCreate(this.CurrentRequest.Proxy.Address);
orCreate2.ParseChallange(firstHeaderValue3);
if (this.CurrentRequest.Proxy.Credentials != null && orCreate2.IsUriProtected(this.CurrentRequest.Proxy.Address) && (!this.CurrentRequest.HasHeader("Proxy-Authorization") || orCreate2.Stale))
{
retryCauses = HTTPConnection.RetryCauses.ProxyAuthenticate;
}
}
}
goto IL_3F7;
}
goto IL_186;
IL_3F7:
if (this.CurrentRequest.IsCookiesEnabled)
{
CookieJar.Set(this.CurrentRequest.Response);
}
this.TryStoreInCache();
if (this.CurrentRequest.Response == null || this.CurrentRequest.Response.HasHeaderWithValue("connection", "close") || this.CurrentRequest.UseAlternateSSL)
{
this.Close();
}
}
}
if (retryCauses == HTTPConnection.RetryCauses.None)
{
goto Block_37;
}
}
throw new Exception("AbortRequested");
Block_13:
throw new Exception("AbortRequested");
Block_16:
throw new Exception("AbortRequested");
IL_3C9:
throw new MissingFieldException(string.Format("Got redirect status({0}) without 'location' header!", this.CurrentRequest.Response.StatusCode.ToString()));
Block_37 :;
}
}
catch (TimeoutException exception)
{
this.CurrentRequest.Response = null;
this.CurrentRequest.Exception = exception;
this.CurrentRequest.State = HTTPRequestStates.ConnectionTimedOut;
this.Close();
}
catch (Exception exception2)
{
if (this.CurrentRequest != null)
{
if (this.CurrentRequest.UseStreaming)
{
HTTPCacheService.DeleteEntity(this.CurrentRequest.CurrentUri, true);
}
this.CurrentRequest.Response = null;
HTTPConnectionStates state = this.State;
if (state != HTTPConnectionStates.AbortRequested)
{
if (state != HTTPConnectionStates.TimedOut)
{
this.CurrentRequest.Exception = exception2;
this.CurrentRequest.State = HTTPRequestStates.Error;
}
else
{
this.CurrentRequest.State = HTTPRequestStates.TimedOut;
}
}
else
{
this.CurrentRequest.State = HTTPRequestStates.Aborted;
}
}
this.Close();
}
finally
{
if (this.CurrentRequest != null)
{
object locker = HTTPManager.Locker;
lock (locker)
{
if (this.CurrentRequest != null && this.CurrentRequest.Response != null && this.CurrentRequest.Response.IsUpgraded)
{
this.State = HTTPConnectionStates.Upgraded;
}
else
{
this.State = ((!flag2) ? ((this.Client != null) ? HTTPConnectionStates.WaitForRecycle : HTTPConnectionStates.Closed) : HTTPConnectionStates.Redirected);
}
if (this.CurrentRequest.State == HTTPRequestStates.Processing && (this.State == HTTPConnectionStates.Closed || this.State == HTTPConnectionStates.WaitForRecycle))
{
this.CurrentRequest.State = HTTPRequestStates.Finished;
}
if (this.CurrentRequest.State == HTTPRequestStates.ConnectionTimedOut)
{
this.State = HTTPConnectionStates.Closed;
}
this.LastProcessTime = DateTime.UtcNow;
}
HTTPCacheService.SaveLibrary();
CookieJar.Persist();
}
}
}
private void Connect()
{
Uri uri = !base.CurrentRequest.HasProxy ? base.CurrentRequest.CurrentUri : base.CurrentRequest.Proxy.Address;
if (this.Client == null)
{
this.Client = new TcpClient();
}
if (!this.Client.Connected)
{
this.Client.ConnectTimeout = base.CurrentRequest.ConnectTimeout;
if (HTTPManager.Logger.Level == Loglevels.All)
{
HTTPManager.Logger.Verbose("HTTPConnection", $"'{base.CurrentRequest.CurrentUri.ToString()}' - Connecting to {uri.Host}:{uri.Port.ToString()}");
}
this.Client.Connect(uri.Host, uri.Port);
if (HTTPManager.Logger.Level <= Loglevels.Information)
{
HTTPManager.Logger.Information("HTTPConnection", "Connected to " + uri.Host + ":" + uri.Port.ToString());
}
}
else if (HTTPManager.Logger.Level <= Loglevels.Information)
{
HTTPManager.Logger.Information("HTTPConnection", "Already connected to " + uri.Host + ":" + uri.Port.ToString());
}
base.StartTime = DateTime.UtcNow;
if (this.Stream == null)
{
bool flag = HTTPProtocolFactory.IsSecureProtocol(base.CurrentRequest.CurrentUri);
this.Stream = this.Client.GetStream();
if (base.HasProxy && (!base.Proxy.IsTransparent || (flag && base.Proxy.NonTransparentForHTTPS)))
{
bool flag2;
BinaryWriter stream = new BinaryWriter(this.Stream);
do
{
flag2 = false;
string str = $"CONNECT {base.CurrentRequest.CurrentUri.Host}:{base.CurrentRequest.CurrentUri.Port} HTTP/1.1";
HTTPManager.Logger.Information("HTTPConnection", "Sending " + str);
stream.SendAsASCII(str);
stream.Write(HTTPRequest.EOL);
stream.SendAsASCII("Proxy-Connection: Keep-Alive");
stream.Write(HTTPRequest.EOL);
stream.SendAsASCII("Connection: Keep-Alive");
stream.Write(HTTPRequest.EOL);
stream.SendAsASCII($"Host: {base.CurrentRequest.CurrentUri.Host}:{base.CurrentRequest.CurrentUri.Port}");
stream.Write(HTTPRequest.EOL);
if (base.HasProxy && (base.Proxy.Credentials != null))
{
switch (base.Proxy.Credentials.Type)
{
case AuthenticationTypes.Basic:
stream.Write($"Proxy-Authorization: {("Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(base.Proxy.Credentials.UserName + ":" + base.Proxy.Credentials.Password)))}".GetASCIIBytes());
stream.Write(HTTPRequest.EOL);
break;
case AuthenticationTypes.Unknown:
case AuthenticationTypes.Digest:
{
Digest digest = DigestStore.Get(base.Proxy.Address);
if (digest != null)
{
string str2 = digest.GenerateResponseHeader(base.CurrentRequest, base.Proxy.Credentials);
if (!string.IsNullOrEmpty(str2))
{
stream.Write($"Proxy-Authorization: {str2}".GetASCIIBytes());
stream.Write(HTTPRequest.EOL);
}
}
break;
}
}
}
stream.Write(HTTPRequest.EOL);
stream.Flush();
base.CurrentRequest.ProxyResponse = new HTTPResponse(base.CurrentRequest, this.Stream, false, false);
if (!base.CurrentRequest.ProxyResponse.Receive(-1, true))
{
throw new Exception("Connection to the Proxy Server failed!");
}
if (HTTPManager.Logger.Level <= Loglevels.Information)
{
object[] objArray1 = new object[] { "Proxy returned - status code: ", base.CurrentRequest.ProxyResponse.StatusCode, " message: ", base.CurrentRequest.ProxyResponse.Message };
HTTPManager.Logger.Information("HTTPConnection", string.Concat(objArray1));
}
if (base.CurrentRequest.ProxyResponse.StatusCode == 0x197)
{
string str3 = DigestStore.FindBest(base.CurrentRequest.ProxyResponse.GetHeaderValues("proxy-authenticate"));
if (!string.IsNullOrEmpty(str3))
{
Digest orCreate = DigestStore.GetOrCreate(base.Proxy.Address);
orCreate.ParseChallange(str3);
if (((base.Proxy.Credentials != null) && orCreate.IsUriProtected(base.Proxy.Address)) && (!base.CurrentRequest.HasHeader("Proxy-Authorization") || orCreate.Stale))
{
flag2 = true;
}
}
}
else if (!base.CurrentRequest.ProxyResponse.IsSuccess)
{
throw new Exception($"Proxy returned Status Code: " { base.CurrentRequest.ProxyResponse.StatusCode } ", Message: " { base.CurrentRequest.ProxyResponse.Message } " and Response: {base.CurrentRequest.ProxyResponse.DataAsText}");
}
}while (flag2);
}
if (flag)
{
if (base.CurrentRequest.UseAlternateSSL)
{
TlsClientProtocol protocol = new TlsClientProtocol(this.Client.GetStream(), new SecureRandom());
List <string> hostNames = new List <string>(1)
{
base.CurrentRequest.CurrentUri.Host
};
protocol.Connect(new LegacyTlsClient(base.CurrentRequest.CurrentUri, (base.CurrentRequest.CustomCertificateVerifyer != null) ? base.CurrentRequest.CustomCertificateVerifyer : new AlwaysValidVerifyer(), base.CurrentRequest.CustomClientCredentialsProvider, hostNames));
this.Stream = protocol.Stream;
}
else
{
SslStream stream = new SslStream(this.Client.GetStream(), false, (sender, cert, chain, errors) => base.CurrentRequest.CallCustomCertificationValidator(cert, chain));
if (!stream.IsAuthenticated)
{
stream.AuthenticateAsClient(base.CurrentRequest.CurrentUri.Host);
}
this.Stream = stream;
}
}
}
}
protected override void ThreadFunc(object param)
{
bool flag = false;
bool flag2 = false;
RetryCauses none = RetryCauses.None;
try
{
if (!base.HasProxy && base.CurrentRequest.HasProxy)
{
base.Proxy = base.CurrentRequest.Proxy;
}
if (!this.TryLoadAllFromCache())
{
if ((this.Client != null) && !this.Client.IsConnected())
{
this.Close();
}
do
{
if (none == RetryCauses.Reconnect)
{
this.Close();
Thread.Sleep(100);
}
base.LastProcessedUri = base.CurrentRequest.CurrentUri;
none = RetryCauses.None;
this.Connect();
if (base.State == HTTPConnectionStates.AbortRequested)
{
throw new Exception("AbortRequested");
}
if (!base.CurrentRequest.DisableCache)
{
HTTPCacheService.SetHeaders(base.CurrentRequest);
}
bool flag3 = false;
try
{
this.Client.NoDelay = base.CurrentRequest.TryToMinimizeTCPLatency;
base.CurrentRequest.SendOutTo(this.Stream);
flag3 = true;
}
catch (Exception exception)
{
this.Close();
if ((base.State == HTTPConnectionStates.TimedOut) || (base.State == HTTPConnectionStates.AbortRequested))
{
throw new Exception("AbortRequested");
}
if (flag || base.CurrentRequest.DisableRetry)
{
throw exception;
}
flag = true;
none = RetryCauses.Reconnect;
}
if (flag3)
{
bool flag4 = this.Receive();
if ((base.State == HTTPConnectionStates.TimedOut) || (base.State == HTTPConnectionStates.AbortRequested))
{
throw new Exception("AbortRequested");
}
if ((!flag4 && !flag) && !base.CurrentRequest.DisableRetry)
{
flag = true;
none = RetryCauses.Reconnect;
}
if (base.CurrentRequest.Response != null)
{
if (base.CurrentRequest.IsCookiesEnabled)
{
CookieJar.Set(base.CurrentRequest.Response);
}
switch (base.CurrentRequest.Response.StatusCode)
{
case 0x12d:
case 0x12e:
case 0x133:
case 0x134:
if (base.CurrentRequest.RedirectCount < base.CurrentRequest.MaxRedirects)
{
HTTPRequest currentRequest = base.CurrentRequest;
currentRequest.RedirectCount++;
string firstHeaderValue = base.CurrentRequest.Response.GetFirstHeaderValue("location");
if (string.IsNullOrEmpty(firstHeaderValue))
{
throw new MissingFieldException($"Got redirect status({base.CurrentRequest.Response.StatusCode.ToString()}) without 'location' header!");
}
Uri redirectUri = this.GetRedirectUri(firstHeaderValue);
if (HTTPManager.Logger.Level == Loglevels.All)
{
HTTPManager.Logger.Verbose("HTTPConnection", string.Format("{0} - Redirected to Location: '{1}' redirectUri: '{1}'", base.CurrentRequest.CurrentUri.ToString(), firstHeaderValue, redirectUri));
}
if (!base.CurrentRequest.CallOnBeforeRedirection(redirectUri))
{
HTTPManager.Logger.Information("HTTPConnection", "OnBeforeRedirection returned False");
}
else
{
base.CurrentRequest.RemoveHeader("Host");
base.CurrentRequest.SetHeader("Referer", base.CurrentRequest.CurrentUri.ToString());
base.CurrentRequest.RedirectUri = redirectUri;
base.CurrentRequest.Response = null;
bool flag5 = true;
base.CurrentRequest.IsRedirected = flag5;
flag2 = flag5;
}
}
break;
case 0x191:
{
string str = DigestStore.FindBest(base.CurrentRequest.Response.GetHeaderValues("www-authenticate"));
if (!string.IsNullOrEmpty(str))
{
Digest orCreate = DigestStore.GetOrCreate(base.CurrentRequest.CurrentUri);
orCreate.ParseChallange(str);
if (((base.CurrentRequest.Credentials != null) && orCreate.IsUriProtected(base.CurrentRequest.CurrentUri)) && (!base.CurrentRequest.HasHeader("Authorization") || orCreate.Stale))
{
none = RetryCauses.Authenticate;
}
}
break;
}
case 0x197:
if (base.CurrentRequest.HasProxy)
{
string str2 = DigestStore.FindBest(base.CurrentRequest.Response.GetHeaderValues("proxy-authenticate"));
if (!string.IsNullOrEmpty(str2))
{
Digest orCreate = DigestStore.GetOrCreate(base.CurrentRequest.Proxy.Address);
orCreate.ParseChallange(str2);
if (((base.CurrentRequest.Proxy.Credentials != null) && orCreate.IsUriProtected(base.CurrentRequest.Proxy.Address)) && (!base.CurrentRequest.HasHeader("Proxy-Authorization") || orCreate.Stale))
{
none = RetryCauses.ProxyAuthenticate;
}
}
}
break;
}
this.TryStoreInCache();
if ((base.CurrentRequest.Response == null) || !base.CurrentRequest.Response.IsClosedManually)
{
bool flag6 = (base.CurrentRequest.Response == null) || base.CurrentRequest.Response.HasHeaderWithValue("connection", "close");
bool flag7 = !base.CurrentRequest.IsKeepAlive;
if (flag6 || flag7)
{
this.Close();
}
else if (base.CurrentRequest.Response != null)
{
List <string> headerValues = base.CurrentRequest.Response.GetHeaderValues("keep-alive");
if ((headerValues != null) && (headerValues.Count > 0))
{
if (this.KeepAlive == null)
{
this.KeepAlive = new KeepAliveHeader();
}
this.KeepAlive.Parse(headerValues);
}
}
}
}
}
}while (none != RetryCauses.None);
}
}
catch (TimeoutException exception2)
{
base.CurrentRequest.Response = null;
base.CurrentRequest.Exception = exception2;
base.CurrentRequest.State = HTTPRequestStates.ConnectionTimedOut;
this.Close();
}
catch (Exception exception3)
{
if (base.CurrentRequest != null)
{
if (base.CurrentRequest.UseStreaming)
{
HTTPCacheService.DeleteEntity(base.CurrentRequest.CurrentUri, true);
}
base.CurrentRequest.Response = null;
switch (base.State)
{
case HTTPConnectionStates.AbortRequested:
case HTTPConnectionStates.Closed:
base.CurrentRequest.State = HTTPRequestStates.Aborted;
goto Label_0685;
case HTTPConnectionStates.TimedOut:
base.CurrentRequest.State = HTTPRequestStates.TimedOut;
goto Label_0685;
}
base.CurrentRequest.Exception = exception3;
base.CurrentRequest.State = HTTPRequestStates.Error;
}
Label_0685:
this.Close();
}
finally
{
if (base.CurrentRequest != null)
{
object locker = HTTPManager.Locker;
lock (locker)
{
if (((base.CurrentRequest != null) && (base.CurrentRequest.Response != null)) && base.CurrentRequest.Response.IsUpgraded)
{
base.State = HTTPConnectionStates.Upgraded;
}
else
{
base.State = !flag2 ? ((this.Client != null) ? HTTPConnectionStates.WaitForRecycle : HTTPConnectionStates.Closed) : HTTPConnectionStates.Redirected;
}
if ((base.CurrentRequest.State == HTTPRequestStates.Processing) && ((base.State == HTTPConnectionStates.Closed) || (base.State == HTTPConnectionStates.WaitForRecycle)))
{
if (base.CurrentRequest.Response != null)
{
base.CurrentRequest.State = HTTPRequestStates.Finished;
}
else
{
base.CurrentRequest.Exception = new Exception($"Remote server closed the connection before sending response header! Previous request state: {base.CurrentRequest.State.ToString()}. Connection state: {base.State.ToString()}");
base.CurrentRequest.State = HTTPRequestStates.Error;
}
}
if (base.CurrentRequest.State == HTTPRequestStates.ConnectionTimedOut)
{
base.State = HTTPConnectionStates.Closed;
}
base.LastProcessTime = DateTime.UtcNow;
if (base.OnConnectionRecycled != null)
{
base.RecycleNow();
}
}
HTTPCacheService.SaveLibrary();
CookieJar.Persist();
}
}
}
protected override void ThreadFunc(object param)
{
bool flag = false;
bool flag2 = false;
RetryCauses retryCauses = RetryCauses.None;
try
{
if (!base.HasProxy && base.CurrentRequest.HasProxy)
{
base.Proxy = base.CurrentRequest.Proxy;
}
if (!TryLoadAllFromCache())
{
if (Client != null && !Client.IsConnected())
{
Close();
}
while (true)
{
if (retryCauses == RetryCauses.Reconnect)
{
Close();
Thread.Sleep(100);
}
base.LastProcessedUri = base.CurrentRequest.CurrentUri;
retryCauses = RetryCauses.None;
Connect();
if (base.State == HTTPConnectionStates.AbortRequested)
{
throw new Exception("AbortRequested");
}
if (!base.CurrentRequest.DisableCache)
{
HTTPCacheService.SetHeaders(base.CurrentRequest);
}
bool flag3 = false;
try
{
base.CurrentRequest.SendOutTo(Stream);
flag3 = true;
}
catch (Exception ex)
{
Close();
if (base.State == HTTPConnectionStates.TimedOut)
{
throw new Exception("AbortRequested");
}
if (flag || base.CurrentRequest.DisableRetry)
{
throw ex;
}
flag = true;
retryCauses = RetryCauses.Reconnect;
}
if (flag3)
{
bool flag4 = Receive();
if (base.State == HTTPConnectionStates.TimedOut)
{
break;
}
if (!flag4 && !flag && !base.CurrentRequest.DisableRetry)
{
flag = true;
retryCauses = RetryCauses.Reconnect;
}
if (base.CurrentRequest.Response != null)
{
if (base.CurrentRequest.IsCookiesEnabled)
{
CookieJar.Set(base.CurrentRequest.Response);
}
switch (base.CurrentRequest.Response.StatusCode)
{
case 401:
{
string text2 = DigestStore.FindBest(base.CurrentRequest.Response.GetHeaderValues("www-authenticate"));
if (!string.IsNullOrEmpty(text2))
{
Digest orCreate2 = DigestStore.GetOrCreate(base.CurrentRequest.CurrentUri);
orCreate2.ParseChallange(text2);
if (base.CurrentRequest.Credentials != null && orCreate2.IsUriProtected(base.CurrentRequest.CurrentUri) && (!base.CurrentRequest.HasHeader("Authorization") || orCreate2.Stale))
{
retryCauses = RetryCauses.Authenticate;
}
}
break;
}
case 407:
if (base.CurrentRequest.HasProxy)
{
string text = DigestStore.FindBest(base.CurrentRequest.Response.GetHeaderValues("proxy-authenticate"));
if (!string.IsNullOrEmpty(text))
{
Digest orCreate = DigestStore.GetOrCreate(base.CurrentRequest.Proxy.Address);
orCreate.ParseChallange(text);
if (base.CurrentRequest.Proxy.Credentials != null && orCreate.IsUriProtected(base.CurrentRequest.Proxy.Address) && (!base.CurrentRequest.HasHeader("Proxy-Authorization") || orCreate.Stale))
{
retryCauses = RetryCauses.ProxyAuthenticate;
}
}
}
break;
case 301:
case 302:
case 307:
case 308:
if (base.CurrentRequest.RedirectCount < base.CurrentRequest.MaxRedirects)
{
base.CurrentRequest.RedirectCount++;
string firstHeaderValue = base.CurrentRequest.Response.GetFirstHeaderValue("location");
if (string.IsNullOrEmpty(firstHeaderValue))
{
throw new MissingFieldException($"Got redirect status({base.CurrentRequest.Response.StatusCode.ToString()}) without 'location' header!");
}
Uri redirectUri = GetRedirectUri(firstHeaderValue);
if (!base.CurrentRequest.CallOnBeforeRedirection(redirectUri))
{
HTTPManager.Logger.Information("HTTPConnection", "OnBeforeRedirection returned False");
}
else
{
base.CurrentRequest.RemoveHeader("Host");
base.CurrentRequest.SetHeader("Referer", base.CurrentRequest.CurrentUri.ToString());
base.CurrentRequest.RedirectUri = redirectUri;
base.CurrentRequest.Response = null;
bool flag5 = true;
base.CurrentRequest.IsRedirected = flag5;
flag2 = flag5;
}
}
break;
}
TryStoreInCache();
if (base.CurrentRequest.Response == null || (!base.CurrentRequest.Response.IsClosedManually && base.CurrentRequest.Response.HasHeaderWithValue("connection", "close")))
{
Close();
}
}
}
if (retryCauses == RetryCauses.None)
{
return;
}
}
throw new Exception("AbortRequested");
}
}
catch (TimeoutException exception)
{
base.CurrentRequest.Response = null;
base.CurrentRequest.Exception = exception;
base.CurrentRequest.State = HTTPRequestStates.ConnectionTimedOut;
Close();
}
catch (Exception exception2)
{
if (base.CurrentRequest != null)
{
if (base.CurrentRequest.UseStreaming)
{
HTTPCacheService.DeleteEntity(base.CurrentRequest.CurrentUri);
}
base.CurrentRequest.Response = null;
switch (base.State)
{
case HTTPConnectionStates.AbortRequested:
case HTTPConnectionStates.Closed:
base.CurrentRequest.State = HTTPRequestStates.Aborted;
break;
case HTTPConnectionStates.TimedOut:
base.CurrentRequest.State = HTTPRequestStates.TimedOut;
break;
default:
base.CurrentRequest.Exception = exception2;
base.CurrentRequest.State = HTTPRequestStates.Error;
break;
}
}
Close();
}
finally
{
if (base.CurrentRequest != null)
{
lock (HTTPManager.Locker)
{
if (base.CurrentRequest != null && base.CurrentRequest.Response != null && base.CurrentRequest.Response.IsUpgraded)
{
base.State = HTTPConnectionStates.Upgraded;
}
else
{
base.State = (flag2 ? HTTPConnectionStates.Redirected : ((Client != null) ? HTTPConnectionStates.WaitForRecycle : HTTPConnectionStates.Closed));
}
if (base.CurrentRequest.State == HTTPRequestStates.Processing && (base.State == HTTPConnectionStates.Closed || base.State == HTTPConnectionStates.WaitForRecycle))
{
if (base.CurrentRequest.Response != null)
{
base.CurrentRequest.State = HTTPRequestStates.Finished;
}
else
{
base.CurrentRequest.State = HTTPRequestStates.Error;
}
}
if (base.CurrentRequest.State == HTTPRequestStates.ConnectionTimedOut)
{
base.State = HTTPConnectionStates.Closed;
}
LastProcessTime = DateTime.UtcNow;
if (OnConnectionRecycled != null)
{
RecycleNow();
}
}
HTTPCacheService.SaveLibrary();
CookieJar.Persist();
}
}
}
private void Connect()
{
Uri uri = (!base.CurrentRequest.HasProxy) ? base.CurrentRequest.CurrentUri : base.CurrentRequest.Proxy.Address;
if (Client == null)
{
Client = new TcpClient();
}
if (!Client.Connected)
{
Client.ConnectTimeout = base.CurrentRequest.ConnectTimeout;
Client.Connect(uri.Host, uri.Port);
if (HTTPManager.Logger.Level <= Loglevels.Information)
{
HTTPManager.Logger.Information("HTTPConnection", "Connected to " + uri.Host + ":" + uri.Port.ToString());
}
}
else if (HTTPManager.Logger.Level <= Loglevels.Information)
{
HTTPManager.Logger.Information("HTTPConnection", "Already connected to " + uri.Host + ":" + uri.Port.ToString());
}
lock (HTTPManager.Locker)
{
base.StartTime = DateTime.UtcNow;
}
if (Stream == null)
{
bool flag = HTTPProtocolFactory.IsSecureProtocol(base.CurrentRequest.CurrentUri);
if (base.HasProxy && (!base.Proxy.IsTransparent || (flag && base.Proxy.NonTransparentForHTTPS)))
{
Stream = Client.GetStream();
BinaryWriter binaryWriter = new BinaryWriter(Stream);
bool flag2;
do
{
flag2 = false;
binaryWriter.SendAsASCII($"CONNECT {base.CurrentRequest.CurrentUri.Host}:{base.CurrentRequest.CurrentUri.Port} HTTP/1.1");
binaryWriter.Write(HTTPRequest.EOL);
binaryWriter.SendAsASCII("Proxy-Connection: Keep-Alive");
binaryWriter.Write(HTTPRequest.EOL);
binaryWriter.SendAsASCII("Connection: Keep-Alive");
binaryWriter.Write(HTTPRequest.EOL);
binaryWriter.SendAsASCII($"Host: {base.CurrentRequest.CurrentUri.Host}:{base.CurrentRequest.CurrentUri.Port}");
binaryWriter.Write(HTTPRequest.EOL);
if (base.HasProxy && base.Proxy.Credentials != null)
{
switch (base.Proxy.Credentials.Type)
{
case AuthenticationTypes.Basic:
binaryWriter.Write(string.Format("Proxy-Authorization: {0}", "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(base.Proxy.Credentials.UserName + ":" + base.Proxy.Credentials.Password))).GetASCIIBytes());
binaryWriter.Write(HTTPRequest.EOL);
break;
case AuthenticationTypes.Unknown:
case AuthenticationTypes.Digest:
{
Digest digest = DigestStore.Get(base.Proxy.Address);
if (digest != null)
{
string text = digest.GenerateResponseHeader(base.CurrentRequest, base.Proxy.Credentials);
if (!string.IsNullOrEmpty(text))
{
binaryWriter.Write($"Proxy-Authorization: {text}".GetASCIIBytes());
binaryWriter.Write(HTTPRequest.EOL);
}
}
break;
}
}
}
binaryWriter.Write(HTTPRequest.EOL);
binaryWriter.Flush();
base.CurrentRequest.ProxyResponse = new HTTPResponse(base.CurrentRequest, Stream, isStreamed: false, isFromCache: false);
if (!base.CurrentRequest.ProxyResponse.Receive())
{
throw new Exception("Connection to the Proxy Server failed!");
}
if (HTTPManager.Logger.Level <= Loglevels.Information)
{
HTTPManager.Logger.Information("HTTPConnection", "Proxy returned - status code: " + base.CurrentRequest.ProxyResponse.StatusCode + " message: " + base.CurrentRequest.ProxyResponse.Message);
}
int statusCode = base.CurrentRequest.ProxyResponse.StatusCode;
if (statusCode == 407)
{
string text2 = DigestStore.FindBest(base.CurrentRequest.ProxyResponse.GetHeaderValues("proxy-authenticate"));
if (!string.IsNullOrEmpty(text2))
{
Digest orCreate = DigestStore.GetOrCreate(base.Proxy.Address);
orCreate.ParseChallange(text2);
if (base.Proxy.Credentials != null && orCreate.IsUriProtected(base.Proxy.Address) && (!base.CurrentRequest.HasHeader("Proxy-Authorization") || orCreate.Stale))
{
flag2 = true;
}
}
}
else if (!base.CurrentRequest.ProxyResponse.IsSuccess)
{
throw new Exception($"Proxy returned Status Code: \"{base.CurrentRequest.ProxyResponse.StatusCode}\", Message: \"{base.CurrentRequest.ProxyResponse.Message}\" and Response: {base.CurrentRequest.ProxyResponse.DataAsText}");
}
}while (flag2);
}
if (flag)
{
if (base.CurrentRequest.UseAlternateSSL)
{
TlsClientProtocol tlsClientProtocol = new TlsClientProtocol(Client.GetStream(), new SecureRandom());
List <string> list = new List <string>(1);
list.Add(base.CurrentRequest.CurrentUri.Host);
TlsClientProtocol tlsClientProtocol2 = tlsClientProtocol;
Uri currentUri = base.CurrentRequest.CurrentUri;
object verifyer;
if (base.CurrentRequest.CustomCertificateVerifyer == null)
{
ICertificateVerifyer certificateVerifyer = new AlwaysValidVerifyer();
verifyer = certificateVerifyer;
}
else
{
verifyer = base.CurrentRequest.CustomCertificateVerifyer;
}
tlsClientProtocol2.Connect(new LegacyTlsClient(currentUri, (ICertificateVerifyer)verifyer, base.CurrentRequest.CustomClientCredentialsProvider, list));
Stream = tlsClientProtocol.Stream;
}
else
{
SslStream sslStream = new SslStream(Client.GetStream(), leaveInnerStreamOpen: false, (object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors errors) => base.CurrentRequest.CallCustomCertificationValidator(cert, chain));
if (!sslStream.IsAuthenticated)
{
sslStream.AuthenticateAsClient(base.CurrentRequest.CurrentUri.Host);
}
Stream = sslStream;
}
}
else
{
Stream = Client.GetStream();
}
}
}
