public static void EventSource_ResolveInvalidHostName_LogsStartFailureStop()
{
RemoteExecutor.Invoke(async() =>
{
const string InvalidHostName = "invalid...example.com";
using var listener = new TestEventListener("System.Net.NameResolution", EventLevel.Informational);
listener.AddActivityTracking();
var events = new ConcurrentQueue <(EventWrittenEventArgs Event, Guid ActivityId)>();
await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async() =>
{
await Assert.ThrowsAnyAsync <SocketException>(async() => await Dns.GetHostEntryAsync(InvalidHostName));
await Assert.ThrowsAnyAsync <SocketException>(async() => await Dns.GetHostAddressesAsync(InvalidHostName));
Assert.ThrowsAny <SocketException>(() => Dns.GetHostEntry(InvalidHostName));
Assert.ThrowsAny <SocketException>(() => Dns.GetHostAddresses(InvalidHostName));
Assert.ThrowsAny <SocketException>(() => Dns.EndGetHostEntry(Dns.BeginGetHostEntry(InvalidHostName, null, null)));
Assert.ThrowsAny <SocketException>(() => Dns.EndGetHostAddresses(Dns.BeginGetHostAddresses(InvalidHostName, null, null)));
});
VerifyEvents(events, InvalidHostName, 6, shouldHaveFailures: true);
}).Dispose();
}
private void GetHostAddressCallback(IAsyncResult ar)
{
try
{
var param = (object[])ar.AsyncState;
var host = (string)param[0];
var port = (int)param[1];
var results = Dns.EndGetHostAddresses(ar);
var supportV4 = Socket.OSSupportsIPv4;
var supportV6 = Socket.OSSupportsIPv6;
var address = results?.FirstOrDefault(d =>
d.AddressFamily == AddressFamily.InterNetwork && supportV4 ||
d.AddressFamily == AddressFamily.InterNetworkV6 && supportV6);
if (address == null)
{
Client.OnAfterServerConnected(Client.ServerReply.HostUnreachable);
return;
}
StartConnection(address, port);
}
catch (Exception)
{
// TODO: log
Stop();
}
}
private void OnHostNameResolved(IAsyncResult ar)
{
object unrelatedObject = ar.AsyncState;
IPAddress[] addresses = Dns.EndGetHostAddresses(ar);
//Do something with addresses
}
protected void DnsGetHostAddressesCallback(IAsyncResult ar)
{
try {
IPAddresses = Dns.EndGetHostAddresses(ar);
}
catch (SocketException e) {
Debug.Print("ServerConnector.DnsGetHostAddressesCallback: Dns.EndGetHostAddresses threw SocketException:\n{0}", e);
OnConnectionFailed(new InvalidOperationException("DNS lookup failed: Socket error occurred while resolving host name.", e));
return;
}
catch (Exception e) {
Debug.Print("ServerConnector.DnsGetHostAddressesCallback: Dns.EndGetHostAddresses threw unexpected exception:\n{0}", e);
OnConnectionFailed(e);
return;
}
try {
EndPoints =
from ipAddress in IPAddresses
from port in Configuration.Ports
select new SslEndPoint(ipAddress, Math.Abs(port), (port < 0));
EndPointEnumerator = EndPoints.GetEnumerator( );
TryEstablishConnection( );
}
catch (Exception e) {
Debug.Print("ServerConnector.DnsGetHostAddressesCallback: caught exception:\n{0}", e);
}
}
private void EndGetHostAddress(IAsyncResult asyncResult)
{
var state = (State)asyncResult.AsyncState;
try
{
var addresses = Dns.EndGetHostAddresses(asyncResult);
var endPoint = new IPEndPoint(addresses[0], 123);
var socket = new UdpClient();
socket.Connect(endPoint);
socket.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 500);
socket.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 500);
var sntpData = new byte[SntpDataLength];
sntpData[0] = 0x1B; // version = 4 & mode = 3 (client)
var newState = new State(socket, endPoint, state.GetTime, state.Failure);
var result = socket.BeginSend(sntpData, sntpData.Length, EndSend, newState);
RegisterWaitForTimeout(newState, result);
}
catch (Exception)
{
// retry, recursion stops at the end of the hosts
BeginGetDate(state.GetTime, state.Failure);
}
}
private static void SetRemoteIPAsyncCallback(IAsyncResult ar)
{
SetRemoteIPRequestInfo setRemoteIPRequestInfo = (SetRemoteIPRequestInfo)ar.AsyncState;
if (setRemoteIPRequestInfo.RequestId == _currentRequestId)
{
try
{
bool flag = false;
IPAddress[] array = Dns.EndGetHostAddresses(ar);
for (int i = 0; i < array.Length; i++)
{
if (array[i].AddressFamily == AddressFamily.InterNetwork)
{
ServerIP = array[i];
ServerIPText = setRemoteIPRequestInfo.RemoteAddress;
flag = true;
break;
}
}
if (flag)
{
setRemoteIPRequestInfo.SuccessCallback();
}
}
catch (Exception)
{
}
}
}
public static IPAddress[] GetHostAddresses(string hostNameOrAddress, int timeout)
{
IPAddress[] addresses = null;
using (var waitAsyncResult = new WaitAsyncResult((w, r) =>
{
try
{
addresses = Dns.EndGetHostAddresses(r);
return(true);
}
catch (SystemException sex)
{
if (g_traceInfo.IsWarningEnabled)
{
TraceHelper.TraceWarning(g_traceInfo, sex.Message);
}
return(false);
}
}))
{
Dns.BeginGetHostAddresses(hostNameOrAddress, waitAsyncResult.Callback, null);
waitAsyncResult.Wait(timeout);
return(addresses);
}
}
private void GetHostAddressesCallback(IAsyncResult ar)
{
// Make sure the request was still relevant
if ((ar.AsyncState as string) != Text)
{
try
{
_ = Dns.EndGetHostAddresses(ar);
}
catch { }
return;
}
Resolving = false;
IpAddresses = null;
try
{
IpAddresses = Dns.EndGetHostAddresses(ar).Where(a =>
a.AddressFamily == AddressFamily.InterNetwork ||
a.AddressFamily == AddressFamily.InterNetworkV6);
}
catch (SocketException) { }
if (IpAddresses == null || !IpAddresses.Any())
{
OnResolveFailed(Text);
ForeColor = ErrorForeColor;
return;
}
ResolvedSuccessfully = true;
OnResolveSuccessful(Text, IpAddresses);
}
/// <summary>
/// Create a new RPC client.
/// </summary>
/// <remarks>Note that creating a client object does not connect to the server -
/// it simply gathers all the required information for future connections. </remarks>
/// <param name="serverAddress">IP address or hostname of rpc server.</param>
/// <param name="serverPort">Server port number.</param>
/// <param name="timeout">Timeout (in ms) for all send and receive operations.</param>
/// <exception cref="TimeoutException">Thown if unable to resolve hostname within 10 seconds.</exception>
/// <exception cref="SocketException">Thownn if DNS lookup fails</exception>
public RpcClient(string serverAddress, int serverPort, int timeout = 5000)
{
this.serverPort = serverPort;
this.timeout = timeout;
if (!IPAddress.TryParse(serverAddress, out this.serverAddress))
{
// lookup hostname if we can't parse out an ip address
var asyncDnsLookup = Dns.BeginGetHostAddresses(serverAddress, null, null);
if (!asyncDnsLookup.AsyncWaitHandle.WaitOne(timeout))
{
throw new TimeoutException("Unable to resolve hostname to IP address.");
}
var dnsResult = Dns.EndGetHostAddresses(asyncDnsLookup);
this.serverAddress = dnsResult.Where(x => x.AddressFamily == AddressFamily.InterNetwork).FirstOrDefault();
if (this.serverAddress == null)
{
throw new ArgumentException("No IPv4 address for this hostname.");
}
}
// handle binding redirection
DirectoryInfo AssemblyDirectory = new FileInfo(typeof(RpcClient).Assembly.Location).Directory;
resolver = new AssemblyRedirectResolver(AssemblyDirectory);
AppDomain.CurrentDomain.AssemblyResolve += (s, e) => resolver.ResolveAssembly(e.Name, e.RequestingAssembly);
}
public static void EventSource_ResolveValidHostName_LogsStartStop()
{
RemoteExecutor.Invoke(async() =>
{
const string ValidHostName = "microsoft.com";
using var listener = new TestEventListener("System.Net.NameResolution", EventLevel.Informational);
var events = new ConcurrentQueue <EventWrittenEventArgs>();
await listener.RunWithCallbackAsync(events.Enqueue, async() =>
{
await Dns.GetHostEntryAsync(ValidHostName);
await Dns.GetHostAddressesAsync(ValidHostName);
Dns.GetHostEntry(ValidHostName);
Dns.GetHostAddresses(ValidHostName);
Dns.EndGetHostEntry(Dns.BeginGetHostEntry(ValidHostName, null, null));
Dns.EndGetHostAddresses(Dns.BeginGetHostAddresses(ValidHostName, null, null));
});
Assert.DoesNotContain(events, e => e.EventId == 0); // errors from the EventSource itself
Assert.True(events.Count >= 2 * 6);
EventWrittenEventArgs[] starts = events.Where(e => e.EventName == "ResolutionStart").ToArray();
Assert.Equal(6, starts.Length);
Assert.All(starts, s => Assert.Equal(ValidHostName, Assert.Single(s.Payload).ToString()));
EventWrittenEventArgs[] stops = events.Where(e => e.EventName == "ResolutionStop").ToArray();
Assert.Equal(6, stops.Length);
Assert.DoesNotContain(events, e => e.EventName == "ResolutionFailed");
}).Dispose();
}
/// <summary>
/// Completes a pending asynchronous socket connection attempt.
/// </summary>
/// <param name="ar">The <see cref="IAsyncResult" /> instance returned by the initiating call to <see cref="BeginConnect" />.</param>
/// <exception cref="SocketException">Thrown if the connection could not be establised.</exception>
/// <remarks>
/// <note>
/// All successful calls to <see cref="BeginConnect" /> should be eventually matched with a call to <see cref="EndConnect" />.
/// </note>
/// </remarks>
public void EndConnect(IAsyncResult ar)
{
lock (syncLock)
{
if (isTcp)
{
sock.EndConnect(ar);
}
else
{
var addresses = Dns.EndGetHostAddresses(ar);
sock.Bind();
udpRemoteEndPoint = new IPEndPoint(addresses[0], remoteBinding.Port);
isUdpConnected = true;
// $hack(jeff.lill)
//
// This is a minor hack. Instead of adding the additional complexity of transmitting the
// connection packet asynchronously, I'm just going to make a synchronous call here. This
// shouldn't ever block in real life since the socket send buffer starts out empty.
sock.SendTo(udpConnectPacket, udpRemoteEndPoint);
udpConnectPacket = null; // Don't need this any longer
}
}
}
} // func ResolveEndpointAsync
private IPEndPoint EndResolveEndPoint(IAsyncResult ar)
{
var port = (int)ar.AsyncState;
var addresses = Dns.EndGetHostAddresses(ar);
return(new IPEndPoint(addresses[0], port));
} // func EndResolveEndPoint
public static void EventSource_ResolveInvalidHostName_LogsStartFailureStop()
{
RemoteExecutor.Invoke(async() =>
{
const string InvalidHostName = "invalid...example.com";
using var listener = new TestEventListener("System.Net.NameResolution", EventLevel.Informational);
var events = new ConcurrentQueue <EventWrittenEventArgs>();
await listener.RunWithCallbackAsync(events.Enqueue, async() =>
{
await Assert.ThrowsAnyAsync <SocketException>(async() => await Dns.GetHostEntryAsync(InvalidHostName));
await Assert.ThrowsAnyAsync <SocketException>(async() => await Dns.GetHostAddressesAsync(InvalidHostName));
Assert.ThrowsAny <SocketException>(() => Dns.GetHostEntry(InvalidHostName));
Assert.ThrowsAny <SocketException>(() => Dns.GetHostAddresses(InvalidHostName));
Assert.ThrowsAny <SocketException>(() => Dns.EndGetHostEntry(Dns.BeginGetHostEntry(InvalidHostName, null, null)));
Assert.ThrowsAny <SocketException>(() => Dns.EndGetHostAddresses(Dns.BeginGetHostAddresses(InvalidHostName, null, null)));
});
Assert.DoesNotContain(events, e => e.EventId == 0); // errors from the EventSource itself
EventWrittenEventArgs[] starts = events.Where(e => e.EventName == "ResolutionStart").ToArray();
Assert.Equal(6, starts.Length);
Assert.All(starts, s => Assert.Equal(InvalidHostName, Assert.Single(s.Payload).ToString()));
EventWrittenEventArgs[] failures = events.Where(e => e.EventName == "ResolutionFailed").ToArray();
Assert.Equal(6, failures.Length);
EventWrittenEventArgs[] stops = events.Where(e => e.EventName == "ResolutionStop").ToArray();
Assert.Equal(6, stops.Length);
}).Dispose();
}
/// <summary>
/// 根据Dns获取到Ip地址后
/// </summary>
/// <param name="result">异步执行结果</param>
private void OnDnsGetHostAddressesComplete(IAsyncResult result)
{
var payload = (InternalRuntime)result.AsyncState;
try
{
var ipAddress = Dns.EndGetHostAddresses(result);
client = Client ?? new UdpClient();
serviceEndPoint = new IPEndPoint(ipAddress[0], remotePort);
client.Connect(serviceEndPoint);
InitKcp(conv);
client.BeginReceive(OnReceiveCallBack, null);
status = Status.Establish;
Trigger(SocketEvents.Connect, this);
payload.Result = true;
payload.IsDone = true;
}
catch (Exception ex)
{
payload.Result = ex;
payload.IsDone = true;
Trigger(SocketEvents.Error, ex);
Dispose();
}
}
private void EndGetHostAddresses(IAsyncResult ar)
{
lock (addresses)
{
try
{
int port = (int)ar.AsyncState;
IPAddress[] newAddrs = Dns.EndGetHostAddresses(ar);
{
//Preference IPv6
foreach (IPAddress newAddr in newAddrs)
{
if (newAddr.AddressFamily == AddressFamily.InterNetworkV6)
{
dnsReceived = true;
addresses.Add(new IPEndPoint(newAddr, port));
}
}
foreach (IPAddress newAddr in newAddrs)
{
if (newAddr.AddressFamily == AddressFamily.InterNetwork)
{
dnsReceived = true;
addresses.Add(new IPEndPoint(newAddr, port));
}
}
}
}
catch (Exception e)
{
DarkLog.Debug("EndGetHostAddresses error: " + e);
}
}
}
private static Task <IPAddress[]> GetHostAddressesAsync(string host)
{
return(Task.Factory.FromAsync(
(c, s) => Dns.BeginGetHostAddresses(host, c, s),
(r) => Dns.EndGetHostAddresses(r),
null));
}
public static void EventSource_ResolveValidHostName_LogsStartStop()
{
RemoteExecutor.Invoke(async() =>
{
const string ValidHostName = "microsoft.com";
using var listener = new TestEventListener("System.Net.NameResolution", EventLevel.Informational);
listener.AddActivityTracking();
var events = new ConcurrentQueue <(EventWrittenEventArgs Event, Guid ActivityId)>();
await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async() =>
{
await Dns.GetHostEntryAsync(ValidHostName);
await Dns.GetHostAddressesAsync(ValidHostName);
Dns.GetHostEntry(ValidHostName);
Dns.GetHostAddresses(ValidHostName);
Dns.EndGetHostEntry(Dns.BeginGetHostEntry(ValidHostName, null, null));
Dns.EndGetHostAddresses(Dns.BeginGetHostAddresses(ValidHostName, null, null));
});
VerifyEvents(events, ValidHostName, 6);
}).Dispose();
}
/// <summary>
/// Async Get IPAdress
/// </summary>
/// <param name="host"></param>
/// <param name="callback"></param>
public static void GetIpAddress(string host, Action <IPAddress> callback = null)
{
IPAddress ipAddress = null;
if (!IPAddress.TryParse(host, out ipAddress))
{
Dns.BeginGetHostAddresses(host, new AsyncCallback((asyncResult) =>
{
IPAddress[] addrs = Dns.EndGetHostAddresses(asyncResult);
if (callback != null)
{
if (addrs.Length > 0)
{
ipAddress = addrs[0];
}
callback(ipAddress);
}
}), null);
}
else
{
if (callback != null)
{
callback(ipAddress);
}
}
}
private static void SetRemoteIPAsyncCallback(IAsyncResult ar)
{
Netplay.SetRemoteIPRequestInfo asyncState = (Netplay.SetRemoteIPRequestInfo)ar.AsyncState;
if (asyncState.RequestId != Netplay._currentRequestId)
{
return;
}
try
{
bool flag = false;
IPAddress[] hostAddresses = Dns.EndGetHostAddresses(ar);
for (int index = 0; index < hostAddresses.Length; ++index)
{
if (hostAddresses[index].AddressFamily == AddressFamily.InterNetwork)
{
Netplay.ServerIP = hostAddresses[index];
Netplay.ServerIPText = asyncState.RemoteAddress;
flag = true;
break;
}
}
if (!flag)
{
return;
}
asyncState.SuccessCallback();
}
catch (Exception ex)
{
}
}
public void DnsBeginGetHostAddresses_MachineName_MatchesGetHostAddresses()
{
IAsyncResult asyncObject = Dns.BeginGetHostAddresses(TestSettings.LocalHost, null, null);
IPAddress[] results = Dns.EndGetHostAddresses(asyncObject);
IPAddress[] addresses = Dns.GetHostAddresses(TestSettings.LocalHost);
Assert.Equal(addresses, results);
}
private void GetHostAddressesTaskComplete(IAsyncResult ar)
{
try {
UpdateIpAddressList(Dns.EndGetHostAddresses(ar));
} catch {
}
GetHostAddressesSetup();
}
private void OnHostResolve(IAsyncResult iar)
{
IPAddress[] host = null;
try
{
host = Dns.EndGetHostAddresses(iar);
// Check to make sure we got at least one IP address, otherwise we can stop right now.
bool gotOne = false;
IPAddress ip = null;
bool useIP6 = ConfigHelper.GetStringConfig("UseIPv6").ToLower() == "true";
foreach (IPAddress addy in host)
{
if (useIP6 ? addy.AddressFamily == AddressFamily.InterNetworkV6 : addy.AddressFamily == AddressFamily.InterNetwork)
{
gotOne = true;
ip = addy;
break;
}
}
if (!gotOne)
{
FireConnectedEvent(false, "Unable to resolve server IP Address.");
}
OnHostnameResolved(gotOne, ip);
Log.LogMsg("Resolved host IP address to [" + ip + "]");
IPEndPoint ipep = new IPEndPoint(ip, m_Port);
SocketAsyncEventArgs connectEventArgs = CreateNewSaeaForConnect();
MyTCPSocket = new Socket(useIP6 ? AddressFamily.InterNetworkV6 : AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
connectEventArgs.AcceptSocket = MyTCPSocket;
MyTCPSocket.Bind(new IPEndPoint(useIP6 ? IPAddress.IPv6Any : IPAddress.Any, 0));
//MyUDPSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
//MyUDPSocket.ExclusiveAddressUse = false;
connectEventArgs.RemoteEndPoint = ipep;
MyTCPSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
MyTCPSocket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, DisableTCPDelay);
//MyTCPSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.OutOfBandInline, true);
Log.LogMsg("Connecting to host [" + ip + "] ...");
bool willRaiseEvent = connectEventArgs.AcceptSocket.ConnectAsync(connectEventArgs);
if (!willRaiseEvent)
{
OnConnectionAttemptConcluded(connectEventArgs);
}
}
catch (Exception e)
{
FireConnectedEvent(false, "Unable to resolve server IP Address. " + e.Message);
return;
}
}
public void DnsBeginGetHostAddresses_BadIpString_ReturnsAddress()
{
IAsyncResult asyncObject = Dns.BeginGetHostAddresses("0.0.1.1", null, null);
IPAddress[] results = Dns.EndGetHostAddresses(asyncObject);
Assert.Equal(1, results.Length);
Assert.Equal(IPAddress.Parse("0.0.1.1"), results[0]);
}
private static void OnGetHostAddresses(IAsyncResult result)
{
var connectState = result.AsyncState as DnsConnectState;
IPAddress[] addresses;
try
{
addresses = Dns.EndGetHostAddresses(result);
}
catch
{
connectState.Callback(null, connectState.State, null);
return;
}
if (addresses == null || addresses.Length <= 0)
{
connectState.Callback(null, connectState.State, null);
return;
}
connectState.Addresses = addresses;
CreateAttempSocket(connectState);
Socket attempSocket;
var address = GetNextAddress(connectState, out attempSocket);
if (address == null)
{
connectState.Callback(null, connectState.State, null);
return;
}
if (connectState.LocalEndPoint != null)
{
attempSocket.ExclusiveAddressUse = false;
attempSocket.Bind(connectState.LocalEndPoint);
}
var socketEventArgs = new SocketAsyncEventArgs();
socketEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(SocketConnectCompleted);
var ipEndPoint = new IPEndPoint(address, connectState.Port);
socketEventArgs.RemoteEndPoint = ipEndPoint;
socketEventArgs.UserToken = connectState;
if (!attempSocket.ConnectAsync(socketEventArgs))
{
SocketConnectCompleted(attempSocket, socketEventArgs);
}
}
private static void DNSAsyncCallbackTongcai(IAsyncResult ar)
{
int asyncState = (int)ar.AsyncState;
IPAddress[] addressArray = Dns.EndGetHostAddresses(ar);
if ((addressArray != null) && (addressArray.Length != 0))
{
ApolloConfig.loginOnlyIpTongCai = addressArray[0].ToString();
}
}
private static void OnHostNameResolved(IAsyncResult ar)
{
object unrelatedObject = ar.AsyncState;
var addresses = Dns.EndGetHostAddresses(ar);
foreach (var ipAddress in addresses)
{
Console.WriteLine(ipAddress);
}
}
// Called when the DNS query completes (either synchronously or asynchronously). Checks for failure and
// starts the first connection attempt if it succeeded. Returns true if the operation will be asynchronous,
// false if it has failed synchronously.
private bool DoDnsCallback(IAsyncResult result, bool sync)
{
Exception exception = null;
lock (lockObject)
{
// If the connection attempt was canceled during the dns query, the user's callback has already been
// called asynchronously and we simply need to return.
if (state == State.Canceled)
{
return(true);
}
GlobalLog.Assert(state == State.DnsQuery, "MultipleConnectAsync.DoDnsCallback(): Unexpected object state");
try
{
addressList = Dns.EndGetHostAddresses(result);
GlobalLog.Assert(addressList != null, "MultipleConnectAsync.DoDnsCallback(): EndGetHostAddresses returned null!");
}
catch (Exception e)
{
state = State.Completed;
exception = e;
}
// If the dns query succeeded, try to connect to the first address
if (exception == null)
{
state = State.ConnectAttempt;
internalArgs = new SocketAsyncEventArgs();
internalArgs.Completed += InternalConnectCallback;
internalArgs.SetBuffer(userArgs.Buffer, userArgs.Offset, userArgs.Count);
exception = AttemptConnection();
if (exception != null)
{
// There was a synchronous error while connecting
state = State.Completed;
}
}
}
// Call this outside of the lock because it might call the user's callback.
if (exception != null)
{
return(Fail(sync, exception));
}
else
{
return(true);
}
}
private static void DNSAsyncCallback(IAsyncResult ar)
{
int num = (int)ar.get_AsyncState();
IPAddress[] array = Dns.EndGetHostAddresses(ar);
if (array == null || array.Length == 0)
{
return;
}
ApolloConfig.loginOnlyIp = array[0].ToString();
}
static void LookupHostName2()
{
//le variaibli vengono catturate
//si perde però ogni possibilità di gestire eventuali accezioni
Dns.BeginGetHostAddresses("www.elfo.net", ar =>
{
Dns.EndGetHostAddresses(ar).ToList().ForEach(Console.WriteLine);
},
null);
}
private static void OnGetHostAddresses(IAsyncResult result)
{
DnsConnectState dnsConnectState = result.AsyncState as DnsConnectState;
IPAddress[] array;
try
{
array = Dns.EndGetHostAddresses(result);
}
catch (Exception exception)
{
dnsConnectState.Callback(null, dnsConnectState.State, null, exception);
return;
}
if (array == null || array.Length == 0)
{
dnsConnectState.Callback(null, dnsConnectState.State, null, new SocketException(11001));
return;
}
dnsConnectState.Addresses = array;
CreateAttempSocket(dnsConnectState);
Socket attempSocket;
IPAddress nextAddress = GetNextAddress(dnsConnectState, out attempSocket);
if (nextAddress == null)
{
dnsConnectState.Callback(null, dnsConnectState.State, null, new SocketException(10047));
return;
}
if (dnsConnectState.LocalEndPoint != null)
{
try
{
attempSocket.ExclusiveAddressUse = false;
attempSocket.Bind(dnsConnectState.LocalEndPoint);
}
catch (Exception exception2)
{
dnsConnectState.Callback(null, dnsConnectState.State, null, exception2);
return;
}
}
SocketAsyncEventArgs socketAsyncEventArgs = new SocketAsyncEventArgs();
socketAsyncEventArgs.Completed += SocketConnectCompleted;
IPEndPoint iPEndPoint = (IPEndPoint)(socketAsyncEventArgs.RemoteEndPoint = new IPEndPoint(nextAddress, dnsConnectState.Port));
socketAsyncEventArgs.UserToken = dnsConnectState;
if (!attempSocket.ConnectAsync(socketAsyncEventArgs))
{
SocketConnectCompleted(attempSocket, socketAsyncEventArgs);
}
}