public static byte[] GetAddressBytes(this SocksAddress address)
{
switch (address.HostNameType)
{
case EndPointType.IPv4:
return(GetBytesForIPv4(address.Host));
case EndPointType.IPv6:
return(GetBytesForIPv6(address.Host));
}
throw new NotSupportedException();
}
private async Task <SocksAddress> ResolveHostName(SocksAddress address)
{
if (address.HostNameType != EndPointType.HostName)
{
return(address);
}
var supportLevel = (AddressCompatibility & AddressCompatibility.SupportsIPv6) == AddressCompatibility.SupportsIPv6
? SocksUtilities.IPv4SupportLevel.NoPreference
: SocksUtilities.IPv4SupportLevel.RequiresIPv4;
// Try resolve host name
var resolvedHost = await SocksUtilities.ResolveHost(address.Host, supportLevel);
if (string.IsNullOrEmpty(resolvedHost))
{
return(null);
}
return(new SocksAddress(resolvedHost, address.Port));
}
public static byte[] GetPortBytes(this SocksAddress address)
{
return(GetPortBytes(address.Port));
}
protected async Task <HttpResponseMessage> InternalSendAsync(HttpRequestMessage request, HttpMethod requestMethod, Uri requestUri, CancellationToken cancellationToken, bool forceRecreate)
{
var useSsl = string.Equals(requestUri.Scheme, "https", StringComparison.OrdinalIgnoreCase);
var destinationAddress = new SocksAddress(requestUri);
switch (destinationAddress.HostNameType)
{
case EndPointType.IPv4:
// All SOCKS implementations support IPv4
break;
case EndPointType.IPv6:
if ((AddressCompatibility & AddressCompatibility.SupportsIPv6) != AddressCompatibility.SupportsIPv6)
{
throw new NotSupportedException();
}
break;
case EndPointType.HostName:
if ((AddressCompatibility & AddressCompatibility.SupportsHost) != AddressCompatibility.SupportsHost)
{
destinationAddress = await ResolveHostName(destinationAddress);
if (destinationAddress == null)
{
throw new NotSupportedException();
}
}
break;
}
if (ResolveHost && destinationAddress.HostNameType == EndPointType.HostName)
{
destinationAddress = await ResolveHostName(destinationAddress) ?? destinationAddress;
}
var client = CreateClient(request, destinationAddress, useSsl, cancellationToken, forceRecreate);
try
{
client.Timeout = Timeout;
client.ReadWriteTimeout = ReadWriteTimeout;
await client.Open(cancellationToken);
var stream = client.GetStream();
await ValidateHeader(request);
// Send request
await WriteRequestHeader(stream, request, requestMethod, requestUri, cancellationToken);
await WriteContent(stream, request, cancellationToken);
await stream.FlushAsync(cancellationToken);
if (UseCookies && CookieContainer == null)
{
CookieContainer = new CookieContainer();
}
// Parse response
var response = new TcpResponseMessage(client, request, requestUri, this);
await response.Parse(cancellationToken);
OnResponseReceived(response);
return(response);
}
catch
{
client.Dispose();
throw;
}
}
protected abstract ITcpClient CreateClient(HttpRequestMessage request, SocksAddress destinationAddress, bool useSsl, CancellationToken cancellationToken, bool forceRecreate);
