using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Net.Security;
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: 0x02001970 RID: 6512
	[Token(Token = "0x2001970")]
	internal sealed class HTTPConnection : ConnectionBase
	{
		// Token: 0x170017DE RID: 6110
		// (get) Token: 0x060096EC RID: 38636 RVA: 0x001EB284 File Offset: 0x001E9484
		[Token(Token = "0x170017DE")]
		public override bool IsRemovable
		{
			[Token(Token = "0x60096EC")]
			[Address(RVA = "0x2A73B10", Offset = "0x2A72B10", VA = "0x182A73B10", 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: 0x060096ED RID: 38637 RVA: 0x001EB2E8 File Offset: 0x001E94E8
		[Token(Token = "0x60096ED")]
		[Address(RVA = "0x2A70930", Offset = "0x2A6F930", VA = "0x182A70930")]
		internal HTTPConnection(string serverAddress)
			: base(serverAddress)
		{
		}

		// Token: 0x060096EE RID: 38638 RVA: 0x001EB2FC File Offset: 0x001E94FC
		[Token(Token = "0x60096EE")]
		[Address(RVA = "0x2A722B0", Offset = "0x2A712B0", VA = "0x182A722B0", Slot = "7")]
		protected override void ThreadFunc(object param)
		{
			uint num11;
			for (;;)
			{
				int num = 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();
					uint num2;
					num2 += (uint)1;
					if (num != 0)
					{
						goto IL_721;
					}
					if (num2 != (uint)(-1))
					{
					}
					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);
					num2 += (uint)1;
					if (num != 0)
					{
						goto IL_727;
					}
					if (num2 != (uint)(-1))
					{
					}
					bool flag = this.Receive();
					num2 += (uint)1;
					if (num != 0)
					{
						goto IL_727;
					}
					if (num2 != (uint)(-1))
					{
					}
					HTTPConnectionStates <State>k__BackingField = this.<State>k__BackingField;
					if (<State>k__BackingField == HTTPConnectionStates.TimedOut || <State>k__BackingField == HTTPConnectionStates.AbortRequested)
					{
						goto IL_88D;
					}
					if (flag || this.<CurrentRequest>k__BackingField.<DisableRetry>k__BackingField == flag)
					{
					}
					HTTPRequest <CurrentRequest>k__BackingField4 = this.<CurrentRequest>k__BackingField;
					if (<CurrentRequest>k__BackingField4.<Response>k__BackingField != (ulong)0L)
					{
						int num3;
						if (<CurrentRequest>k__BackingField4.<IsCookiesEnabled>k__BackingField)
						{
							CookieJar.Set(this.<CurrentRequest>k__BackingField.<Response>k__BackingField);
							CookieJar.Persist();
							num2 += (uint)1;
							num3 = 0;
							if (num != 0)
							{
								goto IL_733;
							}
							if (num2 != (uint)(-1))
							{
							}
						}
						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_319;
						}
						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_4C9;
							}
							if (!this.<CurrentRequest>k__BackingField.<IsRedirected>k__BackingField)
							{
								goto IL_45E;
							}
						}
						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_319;
						}
						goto IL_319;
						IL_4C9:
						HTTPResponse <Response>k__BackingField = this.<CurrentRequest>k__BackingField.<Response>k__BackingField;
						if (<Response>k__BackingField != 0 && <Response>k__BackingField.<IsClosedManually>k__BackingField)
						{
							goto IL_51C;
						}
						if (<Response>k__BackingField == 0)
						{
						}
						uint num4;
						if (num4 != (uint)0)
						{
							goto IL_522;
						}
						List<string> list2;
						if (num4 != (uint)0 && list2 != 0)
						{
							KeepAliveHeader keepAliveHeader;
							if (this.KeepAlive == 0)
							{
								keepAliveHeader = new KeepAliveHeader();
								this.KeepAlive = keepAliveHeader;
							}
							keepAliveHeader.Parse(list2);
							goto IL_51C;
						}
						goto IL_51C;
						IL_45E:
						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__BackingField2 = <CurrentRequest>k__BackingField10.<Response>k__BackingField;
						if (HTTPCacheService.IsCacheble(<Uri>k__BackingField3, <MethodType>k__BackingField, <Response>k__BackingField2))
						{
							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__BackingField3 = <CurrentRequest>k__BackingField11.<Response>k__BackingField;
							HTTPCacheFileInfo httpcacheFileInfo = HTTPCacheService.Store(<Uri>k__BackingField4, <MethodType>k__BackingField2, <Response>k__BackingField3);
							HTTPCacheService.SaveLibrary();
							goto IL_4C9;
						}
						goto IL_4C9;
						IL_319:
						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__BackingField4 = <CurrentRequest>k__BackingField13.<Response>k__BackingField;
								if (!onBeforeRedirection(<CurrentRequest>k__BackingField13, <Response>k__BackingField4, 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 = num3;
							<CurrentRequest>k__BackingField10 = this.<CurrentRequest>k__BackingField;
							<CurrentRequest>k__BackingField10.<IsRedirected>k__BackingField = true;
							goto IL_45E;
						}
						goto IL_79F;
					}
					IL_51C:
					uint num5;
					while (num5 != (uint)0)
					{
					}
					IL_522:
					this.Close();
					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_8AB;
					}
				}
				HTTPRequest <CurrentRequest>k__BackingField15 = this.<CurrentRequest>k__BackingField;
				int num6 = 0;
				<CurrentRequest>k__BackingField15.<Response>k__BackingField = num6;
				this.<CurrentRequest>k__BackingField.<Exception>k__BackingField = <CurrentRequest>k__BackingField15;
				this.<CurrentRequest>k__BackingField.<State>k__BackingField = (HTTPRequestStates)((ulong)6L);
				this.Close();
				HTTPRequest <CurrentRequest>k__BackingField16 = this.<CurrentRequest>k__BackingField;
				if (<CurrentRequest>k__BackingField16 == 0)
				{
					goto IL_609;
				}
				Uri <Uri>k__BackingField5;
				if (<CurrentRequest>k__BackingField16.useStreaming)
				{
					if (<CurrentRequest>k__BackingField16.<IsRedirected>k__BackingField)
					{
					}
					<Uri>k__BackingField5 = <CurrentRequest>k__BackingField16.<Uri>k__BackingField;
					ulong num7;
					bool flag4 = HTTPCacheService.DeleteEntity(<Uri>k__BackingField5, num7 != 0UL);
				}
				HTTPRequest <CurrentRequest>k__BackingField17 = this.<CurrentRequest>k__BackingField;
				int num8 = 0;
				<CurrentRequest>k__BackingField17.<Response>k__BackingField = num8;
				HTTPConnectionStates <State>k__BackingField3 = this.<State>k__BackingField;
				if (<Uri>k__BackingField5 != 0)
				{
					if (<Uri>k__BackingField5 == 0)
					{
						goto IL_612;
					}
					if (<Uri>k__BackingField5 != (ulong)1L)
					{
						this.<CurrentRequest>k__BackingField.<Exception>k__BackingField = <State>k__BackingField3;
						this.<CurrentRequest>k__BackingField.<State>k__BackingField = (HTTPRequestStates)((ulong)4L);
						goto IL_609;
					}
				}
				IL_620:
				uint num9;
				this.<CurrentRequest>k__BackingField.<State>k__BackingField = (HTTPRequestStates)num9;
				object locker = HTTPManager.Locker;
				int num10;
				Monitor.Enter(locker, num10);
				HTTPRequest <CurrentRequest>k__BackingField18 = this.<CurrentRequest>k__BackingField;
				HTTPResponse <Response>k__BackingField5;
				if (<CurrentRequest>k__BackingField18 != 0)
				{
					<Response>k__BackingField5 = <CurrentRequest>k__BackingField18.<Response>k__BackingField;
					if (<Response>k__BackingField5 != 0 && <Response>k__BackingField5.<IsUpgraded>k__BackingField)
					{
						this.<State>k__BackingField = (HTTPConnectionStates)((ulong)3L);
					}
				}
				<CurrentRequest>k__BackingField18.<MethodType>k__BackingField = (HTTPMethods)num11;
				byte[] <RawData>k__BackingField = <CurrentRequest>k__BackingField18.<RawData>k__BackingField;
				Exception ex;
				if ("{il2cpp array field local192->}" == (ulong)2L && <Response>k__BackingField5 == (ulong)4294967291L && "{il2cpp array field local192->}" == (ulong)0L)
				{
					HTTPRequestStates httprequestStates;
					int hashCode3 = httprequestStates.GetHashCode();
					HTTPRequestStates httprequestStates2 = httprequestStates;
					ex = new Exception(string.Format("Remote server closed the connection before sending response header! Previous request state: {0}. Connection state: {1}", hashCode3, httprequestStates2));
					<RawData>k__BackingField[12] = ex;
					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)num11;
				}
				DateTime utcNow = DateTime.UtcNow;
				this.LastProcessTime = utcNow;
				base.RecycleNow();
				Monitor.Exit(locker);
				if (ex == 0 && num11 == (uint)0)
				{
					break;
				}
				continue;
				IL_612:
				this.<CurrentRequest>k__BackingField.<State>k__BackingField = (HTTPRequestStates)((ulong)7L);
				goto IL_620;
				IL_609:
				num10 = 0;
				this.Close();
				goto IL_612;
			}
			return;
			IL_721:
			throw new NullReferenceException();
			IL_727:
			throw new NullReferenceException();
			IL_733:
			throw new NullReferenceException();
			IL_79F:
			PropertyDescriptor propertyDescriptor = num11.PropertyDescriptor;
			throw new NullReferenceException();
			IL_88D:
			Exception ex2 = new Exception("AbortRequested");
			throw new NullReferenceException();
			IL_8AB:
			Exception ex3 = new Exception("AbortRequested");
			throw new NullReferenceException();
		}

		// Token: 0x060096EF RID: 38639 RVA: 0x001EBC10 File Offset: 0x001E9E10
		[Token(Token = "0x60096EF")]
		[Address(RVA = "0x2A70AD0", Offset = "0x2A6FAD0", VA = "0x182A70AD0")]
		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_239;
					}
					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 text2;
					string text = string.Format("'{0}' - Connecting to {1}:{2}", hashCode, host2, text2);
				}
				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 hashCode2 = <CurrentRequest>k__BackingField4.<RedirectUri>k__BackingField.m_String.GetHashCode();
					if (hashCode2 != 0)
					{
					}
					array[0] = hashCode2;
					int sendBufferSize2 = this.Client.SendBufferSize;
					string text3;
					if (text3 != 0)
					{
					}
					array[1] = text3;
					int receiveBufferSize2 = this.Client.ReceiveBufferSize;
					string text4;
					if (text4 != 0)
					{
					}
					array[2] = text4;
					bool is_blocking = this.Client.client.is_blocking;
					string text5;
					if (text5 != 0)
					{
					}
					array[3] = text5;
					string text6 = 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;
					string text8;
					string text7 = "Connected to " + host4 + ":" + text8;
				}
				IL_239:
				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 text9 = <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 num2;
			SslStream sslStream = new SslStream(stream3, num2 != 0, remoteCertificateValidationCallback);
			num2 = 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: 0x060096F0 RID: 38640 RVA: 0x001EC010 File Offset: 0x001EA210
		[Token(Token = "0x60096F0")]
		[Address(RVA = "0x2A71C30", Offset = "0x2A70C30", VA = "0x182A71C30")]
		private bool Receive()
		{
			/*
An exception occurred when decompiling this method (060096F0)

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: 0x060096F1 RID: 38641 RVA: 0x001EC258 File Offset: 0x001EA458
		[Token(Token = "0x60096F1")]
		[Address(RVA = "0x2A71730", Offset = "0x2A70730", VA = "0x182A71730")]
		private bool LoadFromCache(Uri uri)
		{
			int num;
			for (;;)
			{
				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_117;
				}
				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)
				{
					return true;
				}
				<CurrentRequest>k__BackingField3.<Response>k__BackingField.<CacheFileInfo>k__BackingField = entity;
				Stream stream;
				if (stream != 0)
				{
					if (!this.<CurrentRequest>k__BackingField.<Response>k__BackingField.HasHeader("content-length"))
					{
						break;
					}
					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;
					}
				}
				if (stream != 0)
				{
				}
				if (num == 0)
				{
					goto Block_6;
				}
			}
			Dictionary<string, List<string>> <Headers>k__BackingField = this.<CurrentRequest>k__BackingField.<Response>k__BackingField.<Headers>k__BackingField;
			List<string> list = new List(1);
			string text2;
			list.Add(text2);
			throw new NullReferenceException();
			Block_6:
			if (num != -1)
			{
			}
			return true;
			IL_117:
			int num2 = 0;
			ILogger logger2 = HTTPManager.Logger;
			int hashCode3 = num2.GetHashCode();
			int hashCode4 = list.GetHashCode();
			string text3 = string.Format("{0} - LoadFromCache for Uri: {1} - Cached entity not found!", hashCode3, hashCode4);
			throw new NullReferenceException();
		}

		// Token: 0x060096F2 RID: 38642 RVA: 0x001EC3BC File Offset: 0x001EA5BC
		[Token(Token = "0x60096F2")]
		[Address(RVA = "0x2A73670", Offset = "0x2A72670", VA = "0x182A73670")]
		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: 0x060096F3 RID: 38643 RVA: 0x001EC4B0 File Offset: 0x001EA6B0
		[Token(Token = "0x60096F3")]
		[Address(RVA = "0x2A73900", Offset = "0x2A72900", VA = "0x182A73900")]
		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: 0x060096F4 RID: 38644 RVA: 0x001EC570 File Offset: 0x001EA770
		[Token(Token = "0x60096F4")]
		[Address(RVA = "0x2A715A0", Offset = "0x2A705A0", VA = "0x182A715A0")]
		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: 0x060096F5 RID: 38645 RVA: 0x001EC5F4 File Offset: 0x001EA7F4
		[Token(Token = "0x60096F5")]
		[Address(RVA = "0x2A70940", Offset = "0x2A6F940", VA = "0x182A70940", 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: 0x060096F6 RID: 38646 RVA: 0x001EC63C File Offset: 0x001EA83C
		[Token(Token = "0x60096F6")]
		[Address(RVA = "0x2A709F0", Offset = "0x2A6F9F0", VA = "0x182A709F0")]
		private void Close()
		{
			int num;
			do
			{
				num = 0;
				this.KeepAlive = num;
				this.<LastProcessedUri>k__BackingField = num;
				if (this.Client == num)
				{
					break;
				}
				this.Client.Close();
				this.Stream = (ulong)0L;
				this.Client = (ulong)0L;
			}
			while (num != 0);
		}

		// Token: 0x060096F7 RID: 38647 RVA: 0x001EC68C File Offset: 0x001EA88C
		[Token(Token = "0x60096F7")]
		[Address(RVA = "0x2A71570", Offset = "0x2A70570", VA = "0x182A71570", Slot = "8")]
		protected override void Dispose(bool disposing)
		{
			this.Close();
			base.Dispose(disposing);
		}

		// Token: 0x0400663A RID: 26170
		[FieldOffset(Offset = "0x58")]
		[Token(Token = "0x400663A")]
		private TcpClient Client;

		// Token: 0x0400663B RID: 26171
		[FieldOffset(Offset = "0x60")]
		[Token(Token = "0x400663B")]
		private Stream Stream;

		// Token: 0x0400663C RID: 26172
		[FieldOffset(Offset = "0x68")]
		[Token(Token = "0x400663C")]
		private KeepAliveHeader KeepAlive;
	}
}