using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Security;
using System.Runtime.InteropServices;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using BestHTTP.Authentication;
using BestHTTP.Caching;
using BestHTTP.Cookies;
using BestHTTP.Extensions;
using BestHTTP.Logger;
using BestHTTP.PlatformSupport.TcpClient.General;
using BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Tls;
using BestHTTP.SecureProtocol.Org.BouncyCastle.Security;
using Cpp2IlInjected;
using Org.BouncyCastle.Crypto.Tls;

namespace BestHTTP
{
	// Token: 0x0200129F RID: 4767
	[Token(Token = "0x200129F")]
	[StructLayout(3)]
	internal sealed class HTTPConnection : ConnectionBase
	{
		// Token: 0x17001328 RID: 4904
		// (get) Token: 0x0600769E RID: 30366 RVA: 0x00187DA0 File Offset: 0x00185FA0
		[Token(Token = "0x17001328")]
		public override bool IsRemovable
		{
			[Token(Token = "0x600769E")]
			[Address(RVA = "0x1C8D060", Offset = "0x1C8BA60", VA = "0x181C8D060", Slot = "5")]
			get
			{
				if (!base.IsRemovable)
				{
					if (base.IsFree && this.KeepAlive != (ulong)0L)
					{
						DateTime utcNow = DateTime.UtcNow;
						DateTime lastProcessTime = this.LastProcessTime;
						TimeSpan timeSpan = utcNow - lastProcessTime;
						TimeSpan <TimeOut>k__BackingField = this.KeepAlive.<TimeOut>k__BackingField;
						if (!(timeSpan >= <TimeOut>k__BackingField))
						{
						}
					}
				}
				return true;
			}
		}

		// Token: 0x0600769F RID: 30367 RVA: 0x00187E04 File Offset: 0x00186004
		[Token(Token = "0x600769F")]
		[Address(RVA = "0x1C89FC0", Offset = "0x1C889C0", VA = "0x181C89FC0")]
		internal HTTPConnection(string serverAddress)
			: base(serverAddress)
		{
		}

		// Token: 0x060076A0 RID: 30368 RVA: 0x00187E18 File Offset: 0x00186018
		[Token(Token = "0x60076A0")]
		[Address(RVA = "0x1C8B970", Offset = "0x1C8A370", VA = "0x181C8B970", Slot = "7")]
		protected override void ThreadFunc(object param)
		{
			for (;;)
			{
				int num = 0;
				int num2 = 0;
				if (!this.TryLoadAllFromCache())
				{
					TcpClient client = this.Client;
					if (client != 0 && !client.IsConnected())
					{
						this.Close();
					}
					if (num == 1)
					{
						this.Close();
						Thread.Sleep(100);
					}
					HTTPRequest <CurrentRequest>k__BackingField = this.<CurrentRequest>k__BackingField;
					if (<CurrentRequest>k__BackingField.<IsRedirected>k__BackingField)
					{
					}
					Uri <Uri>k__BackingField = <CurrentRequest>k__BackingField.<Uri>k__BackingField;
					this.<LastProcessedUri>k__BackingField = <Uri>k__BackingField;
					this.Connect();
					HTTPRequest <CurrentRequest>k__BackingField2 = this.<CurrentRequest>k__BackingField;
					if (!<CurrentRequest>k__BackingField2.disableCache)
					{
						HTTPCacheService.SetHeaders(<CurrentRequest>k__BackingField2);
					}
					TcpClient client2 = this.Client;
					bool <TryToMinimizeTCPLatency>k__BackingField = this.<CurrentRequest>k__BackingField.<TryToMinimizeTCPLatency>k__BackingField;
					client2.NoDelay = <TryToMinimizeTCPLatency>k__BackingField;
					HTTPRequest <CurrentRequest>k__BackingField3 = this.<CurrentRequest>k__BackingField;
					Stream stream = this.Stream;
					<CurrentRequest>k__BackingField3.SendOutTo(stream);
					bool flag = this.Receive();
					HTTPConnectionStates <State>k__BackingField = this.<State>k__BackingField;
					if (<State>k__BackingField == HTTPConnectionStates.TimedOut || <State>k__BackingField == HTTPConnectionStates.AbortRequested)
					{
						goto IL_828;
					}
					if (flag || num2 != 0 || (this.<CurrentRequest>k__BackingField.<DisableRetry>k__BackingField ? 1 : 0) == num2)
					{
					}
					HTTPRequest <CurrentRequest>k__BackingField4 = this.<CurrentRequest>k__BackingField;
					HTTPResponse <Response>k__BackingField = <CurrentRequest>k__BackingField4.<Response>k__BackingField;
					if (<Response>k__BackingField != 0)
					{
						if (<CurrentRequest>k__BackingField4.<IsCookiesEnabled>k__BackingField)
						{
							CookieJar.Set(<Response>k__BackingField);
							CookieJar.Persist();
						}
						HTTPRequest <CurrentRequest>k__BackingField5 = this.<CurrentRequest>k__BackingField;
						int <StatusCode>k__BackingField = <CurrentRequest>k__BackingField5.<Response>k__BackingField.<StatusCode>k__BackingField;
						if (<StatusCode>k__BackingField <= 308)
						{
							goto IL_2D0;
						}
						if (<StatusCode>k__BackingField == 401)
						{
							string text = DigestStore.FindBest(<CurrentRequest>k__BackingField5.<Response>k__BackingField.GetHeaderValues("www-authenticate"));
							if (!string.IsNullOrEmpty(text))
							{
								HTTPRequest <CurrentRequest>k__BackingField6 = this.<CurrentRequest>k__BackingField;
								if (<CurrentRequest>k__BackingField6.<IsRedirected>k__BackingField)
								{
								}
								Digest orCreate = DigestStore.GetOrCreate(<CurrentRequest>k__BackingField6.<Uri>k__BackingField);
								orCreate.ParseChallange(text);
								HTTPRequest <CurrentRequest>k__BackingField7 = this.<CurrentRequest>k__BackingField;
								if (<CurrentRequest>k__BackingField7.<Credentials>k__BackingField != (ulong)0L)
								{
									if (<CurrentRequest>k__BackingField7.<IsRedirected>k__BackingField)
									{
									}
									Uri <Uri>k__BackingField2 = <CurrentRequest>k__BackingField7.<Uri>k__BackingField;
									if (!orCreate.IsUriProtected(<Uri>k__BackingField2) || !this.<CurrentRequest>k__BackingField.HasHeader("Authorization") || orCreate.<Stale>k__BackingField)
									{
									}
								}
							}
							HTTPRequest <CurrentRequest>k__BackingField8 = this.<CurrentRequest>k__BackingField;
							if (<CurrentRequest>k__BackingField8.useStreaming || <CurrentRequest>k__BackingField8.disableCache || <CurrentRequest>k__BackingField8.<Response>k__BackingField == (ulong)0L || !HTTPCacheService.IsSupported)
							{
								goto IL_47F;
							}
							if (!this.<CurrentRequest>k__BackingField.<IsRedirected>k__BackingField)
							{
								goto IL_414;
							}
						}
						while ("Authorization" != (ulong)407L)
						{
						}
						List<string> list;
						string text2 = DigestStore.FindBest(list);
						if (string.IsNullOrEmpty(text2))
						{
							continue;
						}
						Digest orCreate2 = DigestStore.GetOrCreate(this.<CurrentRequest>k__BackingField.<Proxy>k__BackingField.<Address>k__BackingField);
						orCreate2.ParseChallange(text2);
						Proxy <Proxy>k__BackingField = this.<CurrentRequest>k__BackingField.<Proxy>k__BackingField;
						while (<Proxy>k__BackingField.<Credentials>k__BackingField == (ulong)0L)
						{
						}
						Uri <Address>k__BackingField = <Proxy>k__BackingField.<Address>k__BackingField;
						if (!orCreate2.IsUriProtected(<Address>k__BackingField))
						{
							continue;
						}
						HTTPRequest <CurrentRequest>k__BackingField9 = this.<CurrentRequest>k__BackingField;
						bool flag2 = <CurrentRequest>k__BackingField9.HasHeader("Proxy-Authorization");
						if (flag2)
						{
							while (!orCreate2.<Stale>k__BackingField)
							{
							}
							goto IL_2D0;
						}
						goto IL_2D0;
						IL_47F:
						HTTPResponse <Response>k__BackingField2 = this.<CurrentRequest>k__BackingField.<Response>k__BackingField;
						if (<Response>k__BackingField2 == 0 || !<Response>k__BackingField2.<IsClosedManually>k__BackingField)
						{
							if (<Response>k__BackingField2 == 0)
							{
							}
							uint num3;
							if (num3 == (uint)0)
							{
								List<string> list2;
								if (num3 == (uint)0 || list2 == 0)
								{
									goto IL_4D8;
								}
								KeepAliveHeader keepAliveHeader;
								if (this.KeepAlive == 0)
								{
									keepAliveHeader = new KeepAliveHeader();
									this.KeepAlive = keepAliveHeader;
								}
								keepAliveHeader.Parse(list2);
							}
							this.Close();
							goto IL_4D8;
						}
						goto IL_4D8;
						IL_414:
						HTTPRequest <CurrentRequest>k__BackingField10;
						Uri <Uri>k__BackingField3 = <CurrentRequest>k__BackingField10.<Uri>k__BackingField;
						HTTPMethods <MethodType>k__BackingField = <CurrentRequest>k__BackingField10.<MethodType>k__BackingField;
						HTTPResponse <Response>k__BackingField3 = <CurrentRequest>k__BackingField10.<Response>k__BackingField;
						if (HTTPCacheService.IsCacheble(<Uri>k__BackingField3, <MethodType>k__BackingField, <Response>k__BackingField3))
						{
							HTTPRequest <CurrentRequest>k__BackingField11 = this.<CurrentRequest>k__BackingField;
							if (<CurrentRequest>k__BackingField11.<IsRedirected>k__BackingField)
							{
							}
							Uri <Uri>k__BackingField4 = <CurrentRequest>k__BackingField11.<Uri>k__BackingField;
							HTTPMethods <MethodType>k__BackingField2 = <CurrentRequest>k__BackingField11.<MethodType>k__BackingField;
							HTTPResponse <Response>k__BackingField4 = <CurrentRequest>k__BackingField11.<Response>k__BackingField;
							HTTPCacheFileInfo httpcacheFileInfo = HTTPCacheService.Store(<Uri>k__BackingField4, <MethodType>k__BackingField2, <Response>k__BackingField4);
							HTTPCacheService.SaveLibrary();
							goto IL_47F;
						}
						goto IL_47F;
						IL_2D0:
						if (flag2 > true)
						{
							while (flag2 > true)
							{
							}
						}
						int i = <CurrentRequest>k__BackingField9.<RedirectCount>k__BackingField;
						while (i >= <CurrentRequest>k__BackingField9.<MaxRedirects>k__BackingField)
						{
						}
						i++;
						<CurrentRequest>k__BackingField9.<RedirectCount>k__BackingField = i;
						string firstHeaderValue = this.<CurrentRequest>k__BackingField.<Response>k__BackingField.GetFirstHeaderValue("location");
						if (!string.IsNullOrEmpty(firstHeaderValue))
						{
							Uri redirectUri = this.GetRedirectUri(firstHeaderValue);
							if (HTTPManager.Logger == 0)
							{
								ILogger logger = HTTPManager.Logger;
								HTTPRequest <CurrentRequest>k__BackingField12 = this.<CurrentRequest>k__BackingField;
								if (<CurrentRequest>k__BackingField12.<IsRedirected>k__BackingField)
								{
								}
								int hashCode = <CurrentRequest>k__BackingField12.<Uri>k__BackingField.GetHashCode();
								string text3 = string.Format("{0} - Redirected to Location: '{1}' redirectUri: '{1}'", hashCode, firstHeaderValue, redirectUri);
							}
							HTTPRequest <CurrentRequest>k__BackingField13 = this.<CurrentRequest>k__BackingField;
							OnBeforeRedirectionDelegate onBeforeRedirection = <CurrentRequest>k__BackingField13.onBeforeRedirection;
							if (onBeforeRedirection != 0)
							{
								HTTPResponse <Response>k__BackingField5 = <CurrentRequest>k__BackingField13.<Response>k__BackingField;
								if (!onBeforeRedirection(<CurrentRequest>k__BackingField13, <Response>k__BackingField5, redirectUri))
								{
									ILogger logger2 = HTTPManager.Logger;
								}
							}
							Dictionary<string, List<string>> <Headers>k__BackingField = this.<CurrentRequest>k__BackingField.<Headers>k__BackingField;
							if (<Headers>k__BackingField != 0)
							{
								bool flag3 = <Headers>k__BackingField.Remove("Host");
							}
							HTTPRequest <CurrentRequest>k__BackingField14 = this.<CurrentRequest>k__BackingField;
							if (<CurrentRequest>k__BackingField14.<IsRedirected>k__BackingField)
							{
							}
							int hashCode2 = <CurrentRequest>k__BackingField14.<Uri>k__BackingField.GetHashCode();
							this.<CurrentRequest>k__BackingField.<RedirectUri>k__BackingField = redirectUri;
							this.<CurrentRequest>k__BackingField.<Response>k__BackingField = num;
							<CurrentRequest>k__BackingField10 = this.<CurrentRequest>k__BackingField;
							<CurrentRequest>k__BackingField10.<IsRedirected>k__BackingField = true;
							goto IL_414;
						}
						goto IL_743;
					}
					IL_4D8:
					uint num4;
					while (num4 != (uint)0)
					{
					}
					this.Close();
					HTTPConnectionStates <State>k__BackingField2 = this.<State>k__BackingField;
					if (<State>k__BackingField2 == HTTPConnectionStates.TimedOut || <State>k__BackingField2 == HTTPConnectionStates.AbortRequested || this.<CurrentRequest>k__BackingField.<DisableRetry>k__BackingField)
					{
						goto IL_84C;
					}
				}
				HTTPRequest <CurrentRequest>k__BackingField15 = this.<CurrentRequest>k__BackingField;
				int num5 = 0;
				<CurrentRequest>k__BackingField15.<Response>k__BackingField = num5;
				this.<CurrentRequest>k__BackingField.<Exception>k__BackingField = <CurrentRequest>k__BackingField15;
				this.<CurrentRequest>k__BackingField.<State>k__BackingField = (HTTPRequestStates)((ulong)6L);
				this.Close();
				num++;
				HTTPRequest <CurrentRequest>k__BackingField16 = this.<CurrentRequest>k__BackingField;
				if (<CurrentRequest>k__BackingField16 == 0)
				{
					goto IL_5BD;
				}
				if (<CurrentRequest>k__BackingField16.useStreaming)
				{
					if (<CurrentRequest>k__BackingField16.<IsRedirected>k__BackingField)
					{
					}
					ulong num6;
					bool flag4 = HTTPCacheService.DeleteEntity(<CurrentRequest>k__BackingField16.<Uri>k__BackingField, num6 != 0UL);
				}
				HTTPRequest <CurrentRequest>k__BackingField17 = this.<CurrentRequest>k__BackingField;
				int num7 = 0;
				<CurrentRequest>k__BackingField17.<Response>k__BackingField = num7;
				HTTPConnectionStates <State>k__BackingField3 = this.<State>k__BackingField;
				if (num7 != 0)
				{
					if (num7 == 0)
					{
						goto IL_5CA;
					}
					if (num7 != 1)
					{
						this.<CurrentRequest>k__BackingField.<Exception>k__BackingField = <State>k__BackingField3;
						this.<CurrentRequest>k__BackingField.<State>k__BackingField = (HTTPRequestStates)((ulong)4L);
						goto IL_5BD;
					}
				}
				IL_5D8:
				uint num8;
				this.<CurrentRequest>k__BackingField.<State>k__BackingField = (HTTPRequestStates)num8;
				object locker = HTTPManager.Locker;
				int num9;
				Monitor.Enter(locker, num9);
				HTTPRequest <CurrentRequest>k__BackingField18 = this.<CurrentRequest>k__BackingField;
				HTTPResponse <Response>k__BackingField6;
				if (<CurrentRequest>k__BackingField18 != 0)
				{
					<Response>k__BackingField6 = <CurrentRequest>k__BackingField18.<Response>k__BackingField;
					if (<Response>k__BackingField6 != 0 && <Response>k__BackingField6.<IsUpgraded>k__BackingField)
					{
						this.<State>k__BackingField = (HTTPConnectionStates)((ulong)3L);
					}
				}
				uint num10;
				<Response>k__BackingField6.<StatusCode>k__BackingField = (int)num10;
				string <Message>k__BackingField = <Response>k__BackingField6.<Message>k__BackingField;
				string text4;
				if (<Response>k__BackingField6 == (ulong)4294967291L)
				{
					HTTPRequestStates httprequestStates;
					int hashCode3 = httprequestStates.GetHashCode();
					HTTPRequestStates httprequestStates2 = httprequestStates;
					text4 = string.Format("Remote server closed the connection before sending response header! Previous request state: {0}. Connection state: {1}", hashCode3, httprequestStates2);
					Exception ex = new Exception(text4);
					this.<CurrentRequest>k__BackingField.<State>k__BackingField = (HTTPRequestStates)((ulong)4L);
				}
				if (this.<CurrentRequest>k__BackingField.<State>k__BackingField == HTTPRequestStates.ConnectionTimedOut)
				{
					this.<State>k__BackingField = (HTTPConnectionStates)num10;
				}
				DateTime utcNow = DateTime.UtcNow;
				this.LastProcessTime = utcNow;
				base.RecycleNow();
				Monitor.Exit(locker);
				if (text4 != (ulong)(-1L))
				{
				}
				if (locker != 0)
				{
					continue;
				}
				if (text4 != (ulong)(-1L))
				{
				}
				if (locker == 0)
				{
					break;
				}
				continue;
				IL_5CA:
				this.<CurrentRequest>k__BackingField.<State>k__BackingField = (HTTPRequestStates)((ulong)7L);
				goto IL_5D8;
				IL_5BD:
				num9 = 0;
				this.Close();
				num++;
				goto IL_5CA;
			}
			return;
			IL_743:
			throw new NullReferenceException();
			IL_828:
			Exception ex2 = new Exception("AbortRequested");
			throw new NullReferenceException();
			IL_84C:
			Exception ex3 = new Exception("AbortRequested");
			throw new NullReferenceException();
		}

		// Token: 0x060076A1 RID: 30369 RVA: 0x001886E8 File Offset: 0x001868E8
		[Token(Token = "0x60076A1")]
		[Address(RVA = "0x1C8A180", Offset = "0x1C88B80", VA = "0x181C8A180")]
		private void Connect()
		{
			int num;
			TcpClient client5;
			TlsClientProtocol tlsClientProtocol;
			List<string> list;
			Uri <Uri>k__BackingField2;
			for (;;)
			{
				HTTPRequest <CurrentRequest>k__BackingField = this.<CurrentRequest>k__BackingField;
				num = 0;
				if (<CurrentRequest>k__BackingField.<Proxy>k__BackingField != 0)
				{
				}
				if ((<CurrentRequest>k__BackingField.<IsRedirected>k__BackingField ? 1 : 0) != num)
				{
				}
				Uri <Uri>k__BackingField = <CurrentRequest>k__BackingField.<Uri>k__BackingField;
				TcpClient tcpClient;
				if (this.Client == 0)
				{
					tcpClient = new TcpClient();
					this.Client = tcpClient;
				}
				if (tcpClient.Connected)
				{
					if (HTTPManager.Logger > (ulong)1L)
					{
						goto IL_22C;
					}
					ILogger logger = HTTPManager.Logger;
					string host = <Uri>k__BackingField.Host;
					int port = <Uri>k__BackingField.Port;
				}
				HTTPRequest <CurrentRequest>k__BackingField2 = this.<CurrentRequest>k__BackingField;
				TcpClient client = this.Client;
				TimeSpan <ConnectTimeout>k__BackingField = <CurrentRequest>k__BackingField2.<ConnectTimeout>k__BackingField;
				client.<ConnectTimeout>k__BackingField = <ConnectTimeout>k__BackingField;
				if (HTTPManager.Logger == 0)
				{
					ILogger logger2 = HTTPManager.Logger;
					HTTPRequest <CurrentRequest>k__BackingField3 = this.<CurrentRequest>k__BackingField;
					if ((<CurrentRequest>k__BackingField3.<IsRedirected>k__BackingField ? 1 : 0) == num)
					{
						continue;
					}
					int hashCode = <CurrentRequest>k__BackingField3.<RedirectUri>k__BackingField.m_String.GetHashCode();
					string host2 = <Uri>k__BackingField.Host;
					int port2 = <Uri>k__BackingField.Port;
					string text = string.Format("'{0}' - Connecting to {1}:{2}", hashCode, host2, port2);
				}
				TcpClient client2 = this.Client;
				int sendBufferSize = HTTPManager.SendBufferSize;
				client2.SendBufferSize = sendBufferSize;
				TcpClient client3 = this.Client;
				int receiveBufferSize = HTTPManager.ReceiveBufferSize;
				client3.ReceiveBufferSize = receiveBufferSize;
				if (HTTPManager.Logger == 0)
				{
					ILogger logger3 = HTTPManager.Logger;
					object[] array = new object[4];
					HTTPRequest <CurrentRequest>k__BackingField4 = this.<CurrentRequest>k__BackingField;
					if ((<CurrentRequest>k__BackingField4.<IsRedirected>k__BackingField ? 1 : 0) == num)
					{
						continue;
					}
					int num2 = <CurrentRequest>k__BackingField4.<RedirectUri>k__BackingField.m_String.GetHashCode();
					if (num2 != 0)
					{
					}
					array[0] = num2;
					int sendBufferSize2 = this.Client.SendBufferSize;
					num2 = sendBufferSize2;
					if (sendBufferSize2 != 0)
					{
					}
					array[1] = num2;
					int receiveBufferSize2 = this.Client.ReceiveBufferSize;
					num2 = receiveBufferSize2;
					if (receiveBufferSize2 != 0)
					{
					}
					array[2] = num2;
					bool is_blocking = this.Client.client.is_blocking;
					if (is_blocking)
					{
					}
					array[3] = is_blocking;
					string text2 = string.Format("'{0}' - Buffer sizes - Send: {1} Receive: {2} Blocking: {3}", array);
				}
				TcpClient client4 = this.Client;
				string host3 = <Uri>k__BackingField.Host;
				int port3 = <Uri>k__BackingField.Port;
				client4.Connect(host3, port3);
				if (HTTPManager.Logger <= (ulong)1L)
				{
					ILogger logger4 = HTTPManager.Logger;
					string host4 = <Uri>k__BackingField.Host;
					int port4 = <Uri>k__BackingField.Port;
				}
				IL_22C:
				DateTime utcNow = DateTime.UtcNow;
				this.<StartTime>k__BackingField = utcNow;
				if (this.Stream != num)
				{
					return;
				}
				HTTPRequest <CurrentRequest>k__BackingField5 = this.<CurrentRequest>k__BackingField;
				if ((<CurrentRequest>k__BackingField5.<IsRedirected>k__BackingField ? 1 : 0) != num)
				{
				}
				bool flag = HTTPProtocolFactory.IsSecureProtocol(<CurrentRequest>k__BackingField5.<Uri>k__BackingField);
				Stream stream = this.Client.GetStream();
				HTTPRequest <CurrentRequest>k__BackingField6 = this.<CurrentRequest>k__BackingField;
				this.Stream = stream;
				Proxy <Proxy>k__BackingField = <CurrentRequest>k__BackingField6.<Proxy>k__BackingField;
				if (<Proxy>k__BackingField != 0)
				{
					string text3 = <Proxy>k__BackingField.ToString();
				}
				if (!flag)
				{
					return;
				}
				HTTPRequest <CurrentRequest>k__BackingField7 = this.<CurrentRequest>k__BackingField;
				client5 = this.Client;
				if ((<CurrentRequest>k__BackingField7.<UseAlternateSSL>k__BackingField ? 1 : 0) == num)
				{
					break;
				}
				SecureRandom secureRandom = new SecureRandom();
				Stream stream2;
				tlsClientProtocol = new TlsClientProtocol(stream2, secureRandom);
				HTTPRequest <CurrentRequest>k__BackingField8 = this.<CurrentRequest>k__BackingField;
				if (<CurrentRequest>k__BackingField8.<CustomTLSServerNameList>k__BackingField != 0)
				{
				}
				if ((<CurrentRequest>k__BackingField8.<IsRedirected>k__BackingField ? 1 : 0) != num)
				{
				}
				if (!<CurrentRequest>k__BackingField8.<Uri>k__BackingField.IsHostIsAnIPAddress())
				{
					list = new List(1);
					HTTPRequest <CurrentRequest>k__BackingField9 = this.<CurrentRequest>k__BackingField;
					if ((<CurrentRequest>k__BackingField9.<IsRedirected>k__BackingField ? 1 : 0) != num)
					{
					}
					string host5 = <CurrentRequest>k__BackingField9.<Uri>k__BackingField.Host;
					list.Add(host5);
				}
				HTTPRequest <CurrentRequest>k__BackingField10 = this.<CurrentRequest>k__BackingField;
				if ((<CurrentRequest>k__BackingField10.<IsRedirected>k__BackingField ? 1 : 0) != num)
				{
				}
				<Uri>k__BackingField2 = <CurrentRequest>k__BackingField10.<Uri>k__BackingField;
				if (<CurrentRequest>k__BackingField10.<CustomCertificateVerifyer>k__BackingField == 0)
				{
					goto Block_14;
				}
			}
			Stream stream3 = client5.GetStream();
			RemoteCertificateValidationCallback remoteCertificateValidationCallback = delegate(object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors errors)
			{
				HTTPRequest <CurrentRequest>k__BackingField12 = this.<CurrentRequest>k__BackingField;
				Func<HTTPRequest, X509Certificate, X509Chain, bool> customCertificationValidator = <CurrentRequest>k__BackingField12.CustomCertificationValidator;
				return customCertificationValidator == 0 || customCertificationValidator(<CurrentRequest>k__BackingField12, cert, chain) != null;
			};
			int num3;
			SslStream sslStream = new SslStream(stream3, num3 != 0, remoteCertificateValidationCallback);
			num3 = 0;
			if (sslStream == 0)
			{
				HTTPRequest <CurrentRequest>k__BackingField11 = this.<CurrentRequest>k__BackingField;
				if ((<CurrentRequest>k__BackingField11.<IsRedirected>k__BackingField ? 1 : 0) != num)
				{
				}
				string host6 = <CurrentRequest>k__BackingField11.<Uri>k__BackingField.Host;
				bool isAuthenticated = sslStream.IsAuthenticated;
			}
			this.Stream = sslStream;
			return;
			Block_14:
			AlwaysValidVerifyer alwaysValidVerifyer = new AlwaysValidVerifyer();
			IClientCredentialsProvider <CustomClientCredentialsProvider>k__BackingField = this.<CurrentRequest>k__BackingField.<CustomClientCredentialsProvider>k__BackingField;
			LegacyTlsClient legacyTlsClient = new LegacyTlsClient(<Uri>k__BackingField2, alwaysValidVerifyer, <CustomClientCredentialsProvider>k__BackingField, list);
			tlsClientProtocol.RefuseRenegotiation();
			throw new NullReferenceException();
		}

		// Token: 0x060076A2 RID: 30370 RVA: 0x00188AD8 File Offset: 0x00186CD8
		[Token(Token = "0x60076A2")]
		[Address(RVA = "0x1C8B2F0", Offset = "0x1C89CF0", VA = "0x181C8B2F0")]
		private bool Receive()
		{
			/*
An exception occurred when decompiling this method (060076A2)

ICSharpCode.Decompiler.DecompilerException: Error decompiling System.Boolean BestHTTP.HTTPConnection::Receive()

 ---> System.Exception: Basic block has to end with unconditional control flow. 
{
	IL_22E:
	stloc:Exception(var_36_238, newobj:Exception(Exception::.ctor, ldstr:string("Malformed URI in GetProtocolFromUri")))
}

   at ICSharpCode.Decompiler.ILAst.ILAstOptimizer.FlattenBasicBlocks(ILNode node) in D:\a\dnSpy\dnSpy\Extensions\ILSpy.Decompiler\ICSharpCode.Decompiler\ICSharpCode.Decompiler\ILAst\ILAstOptimizer.cs:line 1852
   at ICSharpCode.Decompiler.ILAst.ILAstOptimizer.Optimize(DecompilerContext context, ILBlock method, AutoPropertyProvider autoPropertyProvider, StateMachineKind& stateMachineKind, MethodDef& inlinedMethod, AsyncMethodDebugInfo& asyncInfo, ILAstOptimizationStep abortBeforeStep) in D:\a\dnSpy\dnSpy\Extensions\ILSpy.Decompiler\ICSharpCode.Decompiler\ICSharpCode.Decompiler\ILAst\ILAstOptimizer.cs:line 355
   at ICSharpCode.Decompiler.Ast.AstMethodBodyBuilder.CreateMethodBody(IEnumerable`1 parameters, MethodDebugInfoBuilder& builder) in D:\a\dnSpy\dnSpy\Extensions\ILSpy.Decompiler\ICSharpCode.Decompiler\ICSharpCode.Decompiler\Ast\AstMethodBodyBuilder.cs:line 123
   at ICSharpCode.Decompiler.Ast.AstMethodBodyBuilder.CreateMethodBody(MethodDef methodDef, DecompilerContext context, AutoPropertyProvider autoPropertyProvider, IEnumerable`1 parameters, Boolean valueParameterIsKeyword, StringBuilder sb, MethodDebugInfoBuilder& stmtsBuilder) in D:\a\dnSpy\dnSpy\Extensions\ILSpy.Decompiler\ICSharpCode.Decompiler\ICSharpCode.Decompiler\Ast\AstMethodBodyBuilder.cs:line 88
   --- End of inner exception stack trace ---
   at ICSharpCode.Decompiler.Ast.AstMethodBodyBuilder.CreateMethodBody(MethodDef methodDef, DecompilerContext context, AutoPropertyProvider autoPropertyProvider, IEnumerable`1 parameters, Boolean valueParameterIsKeyword, StringBuilder sb, MethodDebugInfoBuilder& stmtsBuilder) in D:\a\dnSpy\dnSpy\Extensions\ILSpy.Decompiler\ICSharpCode.Decompiler\ICSharpCode.Decompiler\Ast\AstMethodBodyBuilder.cs:line 92
   at ICSharpCode.Decompiler.Ast.AstBuilder.AddMethodBody(EntityDeclaration methodNode, EntityDeclaration& updatedNode, MethodDef method, IEnumerable`1 parameters, Boolean valueParameterIsKeyword, MethodKind methodKind) in D:\a\dnSpy\dnSpy\Extensions\ILSpy.Decompiler\ICSharpCode.Decompiler\ICSharpCode.Decompiler\Ast\AstBuilder.cs:line 1663
*/;
		}

		// Token: 0x060076A3 RID: 30371 RVA: 0x00188D20 File Offset: 0x00186F20
		[Token(Token = "0x60076A3")]
		[Address(RVA = "0x1C8ADE0", Offset = "0x1C897E0", VA = "0x181C8ADE0")]
		private bool LoadFromCache(Uri uri)
		{
			int num;
			List<string> list;
			do
			{
				num = 0;
				if (HTTPManager.Logger == 0)
				{
					ILogger logger = HTTPManager.Logger;
					HTTPRequest <CurrentRequest>k__BackingField = this.<CurrentRequest>k__BackingField;
					if ((<CurrentRequest>k__BackingField.<IsRedirected>k__BackingField ? 1 : 0) != num)
					{
					}
					int hashCode = <CurrentRequest>k__BackingField.<Uri>k__BackingField.GetHashCode();
					int hashCode2 = uri.GetHashCode();
					string text = string.Format("{0} - LoadFromCache for Uri: {1}", hashCode, hashCode2);
				}
				HTTPCacheFileInfo entity = HTTPCacheService.GetEntity(uri);
				if (entity == 0)
				{
					goto IL_125;
				}
				HTTPRequest <CurrentRequest>k__BackingField2 = this.<CurrentRequest>k__BackingField;
				HTTPResponse httpresponse = entity.ReadResponseTo(<CurrentRequest>k__BackingField2);
				HTTPRequest <CurrentRequest>k__BackingField3 = this.<CurrentRequest>k__BackingField;
				if (httpresponse != 0)
				{
					break;
				}
				<CurrentRequest>k__BackingField3.<Response>k__BackingField.<CacheFileInfo>k__BackingField = entity;
				Stream stream;
				if (stream != 0)
				{
					if (this.<CurrentRequest>k__BackingField.<Response>k__BackingField.GetHeaderValues("content-length") == 0)
					{
						Dictionary<string, List<string>> <Headers>k__BackingField = this.<CurrentRequest>k__BackingField.<Response>k__BackingField.<Headers>k__BackingField;
						list = new List(1);
						<Headers>k__BackingField.Add("content-length", list);
					}
					this.<CurrentRequest>k__BackingField.<Response>k__BackingField.<IsFromCache>k__BackingField = true;
					HTTPRequest <CurrentRequest>k__BackingField4 = this.<CurrentRequest>k__BackingField;
					if (!<CurrentRequest>k__BackingField4.cacheOnly)
					{
						HTTPResponse <Response>k__BackingField = <CurrentRequest>k__BackingField4.<Response>k__BackingField;
					}
				}
				int num2;
				if (stream != 0)
				{
					num2 = 0;
				}
				if (num != -1)
				{
					if (num2 == 332)
					{
						goto IL_151;
					}
					if (num2 == 330)
					{
						break;
					}
				}
			}
			while (num != 0);
			return true;
			IL_125:
			int num3 = 0;
			ILogger logger2 = HTTPManager.Logger;
			int hashCode3 = num3.GetHashCode();
			int hashCode4 = list.GetHashCode();
			string text2 = string.Format("{0} - LoadFromCache for Uri: {1} - Cached entity not found!", hashCode3, hashCode4);
			IL_151:
			throw new NullReferenceException();
		}

		// Token: 0x060076A4 RID: 30372 RVA: 0x00188E90 File Offset: 0x00187090
		[Token(Token = "0x60076A4")]
		[Address(RVA = "0x1C8CBC0", Offset = "0x1C8B5C0", VA = "0x181C8CBC0")]
		private bool TryLoadAllFromCache()
		{
			if (!this.<CurrentRequest>k__BackingField.disableCache && HTTPCacheService.IsSupported)
			{
				HTTPRequest <CurrentRequest>k__BackingField = this.<CurrentRequest>k__BackingField;
				if (HTTPCacheService.IsCachedEntityExpiresInTheFuture(<CurrentRequest>k__BackingField))
				{
					if (HTTPManager.Logger == 0)
					{
						ILogger logger = HTTPManager.Logger;
						HTTPRequest <CurrentRequest>k__BackingField2 = this.<CurrentRequest>k__BackingField;
						if (<CurrentRequest>k__BackingField2.<IsRedirected>k__BackingField)
						{
						}
						int hashCode = <CurrentRequest>k__BackingField2.<Uri>k__BackingField.GetHashCode();
						string text = string.Format("{0} - TryLoadAllFromCache - whole response loading from cache", hashCode);
					}
					HTTPRequest <CurrentRequest>k__BackingField3 = this.<CurrentRequest>k__BackingField;
					HTTPResponse fullResponse = HTTPCacheService.GetFullResponse(<CurrentRequest>k__BackingField3);
					<CurrentRequest>k__BackingField3.<Response>k__BackingField = fullResponse;
					if (this.<CurrentRequest>k__BackingField.<Response>k__BackingField != (ulong)0L)
					{
						return true;
					}
				}
				if (<CurrentRequest>k__BackingField.<IsRedirected>k__BackingField)
				{
				}
				bool flag = HTTPCacheService.DeleteEntity(<CurrentRequest>k__BackingField.<Uri>k__BackingField, true);
			}
			throw new NullReferenceException();
		}

		// Token: 0x060076A5 RID: 30373 RVA: 0x00188F84 File Offset: 0x00187184
		[Token(Token = "0x60076A5")]
		[Address(RVA = "0x1C8CE50", Offset = "0x1C8B850", VA = "0x181C8CE50")]
		private void TryStoreInCache()
		{
			HTTPRequest <CurrentRequest>k__BackingField = this.<CurrentRequest>k__BackingField;
			if (!<CurrentRequest>k__BackingField.useStreaming && !<CurrentRequest>k__BackingField.disableCache && <CurrentRequest>k__BackingField.<Response>k__BackingField != (ulong)0L && HTTPCacheService.IsSupported)
			{
				HTTPRequest <CurrentRequest>k__BackingField2 = this.<CurrentRequest>k__BackingField;
				if (<CurrentRequest>k__BackingField2.<IsRedirected>k__BackingField)
				{
				}
				Uri <Uri>k__BackingField = <CurrentRequest>k__BackingField2.<Uri>k__BackingField;
				HTTPMethods <MethodType>k__BackingField = <CurrentRequest>k__BackingField2.<MethodType>k__BackingField;
				HTTPResponse <Response>k__BackingField = <CurrentRequest>k__BackingField2.<Response>k__BackingField;
				if (HTTPCacheService.IsCacheble(<Uri>k__BackingField, <MethodType>k__BackingField, <Response>k__BackingField))
				{
					HTTPRequest <CurrentRequest>k__BackingField3 = this.<CurrentRequest>k__BackingField;
					if (<CurrentRequest>k__BackingField3.<IsRedirected>k__BackingField)
					{
					}
					Uri <Uri>k__BackingField2 = <CurrentRequest>k__BackingField3.<Uri>k__BackingField;
					HTTPMethods <MethodType>k__BackingField2 = <CurrentRequest>k__BackingField3.<MethodType>k__BackingField;
					HTTPResponse <Response>k__BackingField2 = <CurrentRequest>k__BackingField3.<Response>k__BackingField;
					HTTPCacheFileInfo httpcacheFileInfo = HTTPCacheService.Store(<Uri>k__BackingField2, <MethodType>k__BackingField2, <Response>k__BackingField2);
					HTTPCacheService.SaveLibrary();
				}
			}
		}

		// Token: 0x060076A6 RID: 30374 RVA: 0x00189044 File Offset: 0x00187244
		[Token(Token = "0x60076A6")]
		[Address(RVA = "0x1C8AC50", Offset = "0x1C89650", VA = "0x181C8AC50")]
		private Uri GetRedirectUri(string location)
		{
			int num;
			int num2;
			do
			{
				Uri uri = new Uri(location);
				if (uri.IsFile || string.Equals(uri.AbsolutePath, location))
				{
				}
				num = 0;
				num2 = 0;
			}
			while (!(num == num2));
			Uri <Uri>k__BackingField = this.<CurrentRequest>k__BackingField.<Uri>k__BackingField;
			string scheme = <Uri>k__BackingField.Scheme;
			string host = <Uri>k__BackingField.Host;
			int port = <Uri>k__BackingField.Port;
			return new UriBuilder(scheme, host, port, location).Uri;
		}

		// Token: 0x060076A7 RID: 30375 RVA: 0x001890C8 File Offset: 0x001872C8
		[Token(Token = "0x60076A7")]
		[Address(RVA = "0x1C89FD0", Offset = "0x1C889D0", VA = "0x181C89FD0", Slot = "6")]
		internal override void Abort(HTTPConnectionStates newState)
		{
			this.<State>k__BackingField = newState;
			if (newState == HTTPConnectionStates.TimedOut)
			{
				DateTime utcNow = DateTime.UtcNow;
				this.<TimedOutStart>k__BackingField = utcNow;
			}
			if (this.Stream != (ulong)0L)
			{
				this.Stream.Dispose();
			}
		}

		// Token: 0x060076A8 RID: 30376 RVA: 0x00189110 File Offset: 0x00187310
		[Token(Token = "0x60076A8")]
		[Address(RVA = "0x1C8A080", Offset = "0x1C88A80", VA = "0x181C8A080")]
		private void Close()
		{
			int num;
			do
			{
				num = 0;
				this.KeepAlive = num;
				this.<LastProcessedUri>k__BackingField = num;
				if (this.Client == num)
				{
					break;
				}
				this.Client.Close();
				int num2 = 0;
				num2++;
				this.Stream = (ulong)0L;
				this.Client = (ulong)0L;
				if (num2 != -1)
				{
				}
			}
			while (num != 0);
		}

		// Token: 0x060076A9 RID: 30377 RVA: 0x00189168 File Offset: 0x00187368
		[Token(Token = "0x60076A9")]
		[Address(RVA = "0x1C8AC20", Offset = "0x1C89620", VA = "0x181C8AC20", Slot = "8")]
		protected override void Dispose(bool disposing)
		{
			this.Close();
			base.Dispose(disposing);
		}

		// Token: 0x040055E7 RID: 21991
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x58")]
		[Token(Token = "0x40055E7")]
		private TcpClient Client;

		// Token: 0x040055E8 RID: 21992
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x60")]
		[Token(Token = "0x40055E8")]
		private Stream Stream;

		// Token: 0x040055E9 RID: 21993
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x68")]
		[Token(Token = "0x40055E9")]
		private KeepAliveHeader KeepAlive;
	}
}