public override async ValueTask <IEnumerable <IConnector> > ConnectorsAsync(
EndpointSelectionType endptSelection)
{
Instrumentation.IObserver?observer = Communicator.Observer?.GetEndpointLookupObserver(this);
observer?.Attach();
try
{
INetworkProxy?networkProxy = Communicator.NetworkProxy;
int ipVersion = Communicator.IPVersion;
if (networkProxy != null)
{
networkProxy = await networkProxy.ResolveHostAsync(ipVersion).ConfigureAwait(false);
if (networkProxy != null)
{
ipVersion = networkProxy.GetIPVersion();
}
}
IEnumerable <IPEndPoint> addrs = await Network.GetAddressesForClientEndpointAsync(Host, Port, ipVersion,
endptSelection, Communicator.PreferIPv6).ConfigureAwait(false);
return(addrs.Select(item => CreateConnector(item, networkProxy)));
}
catch (Exception ex)
{
observer?.Failed(ex.GetType().FullName ?? "System.Exception");
throw;
}
finally
{
observer?.Detach();
}
}
public StreamSocket(TransportInstance instance, INetworkProxy?proxy, EndPoint addr, IPAddress?sourceAddr)
{
_instance = instance;
_proxy = proxy;
_addr = addr;
_sourceAddr = sourceAddr;
_fd = Network.CreateSocket(false, (_proxy != null ? _proxy.GetAddress() : _addr).AddressFamily);
_state = StateNeedConnect;
Network.SetBlock(_fd, false);
Network.SetTcpBufSize(_fd, _instance);
_readEventArgs = new SocketAsyncEventArgs();
_readEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted);
_writeEventArgs = new SocketAsyncEventArgs();
_writeEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted);
//
// For timeouts to work properly, we need to receive/send
// the data in several chunks. Otherwise, we would only be
// notified when all the data is received/written. The
// connection timeout could easily be triggered when
// receiving/sending large messages.
//
_maxSendPacketSize = Math.Max(512, Network.GetSendBufferSize(_fd));
_maxRecvPacketSize = Math.Max(512, Network.GetRecvBufferSize(_fd));
}
private protected override IConnector CreateConnector(EndPoint addr, INetworkProxy?proxy) =>
new TcpConnector(this,
Communicator,
addr,
proxy,
SourceAddress,
Timeout);
// TODO: why are we copying all these readonly fields of the endpoint?
internal TcpConnector(
TcpEndpoint endpoint,
Communicator communicator,
EndPoint addr,
INetworkProxy?proxy,
IPAddress?sourceAddr,
int timeout,
string connectionId)
{
_endpoint = endpoint;
_communicator = communicator;
_addr = addr;
_proxy = proxy;
_sourceAddr = sourceAddr;
_timeout = timeout;
_connectionId = connectionId;
var hash = new System.HashCode();
hash.Add(_addr);
if (_sourceAddr != null)
{
hash.Add(_sourceAddr);
}
hash.Add(_timeout);
hash.Add(_connectionId);
_hashCode = hash.ToHashCode();
}
public virtual List <IConnector> Connectors(List <IPEndPoint> endpoints, INetworkProxy?proxy)
{
var connectors = new List <IConnector>();
foreach (EndPoint p in endpoints)
{
connectors.Add(CreateConnector(p, proxy));
}
return(connectors);
}
internal override SingleStreamSocket CreateSocket(
IConnector connector,
EndPoint addr,
INetworkProxy?proxy,
bool preferNonSecure) =>
new WSSocket(Communicator,
base.CreateSocket(connector, addr, proxy, preferNonSecure),
Host,
Resource,
connector);
public void Resolve(string host, int port, EndpointSelectionType selType, IPEndpoint endpoint,
IEndpointConnectors callback)
{
//
// Try to get the addresses without DNS lookup. If this doesn't work, we queue a resolve
// entry and the thread will take care of getting the endpoint addresses.
//
INetworkProxy?networkProxy = NetworkProxy;
if (networkProxy == null)
{
try
{
List <EndPoint> addrs = Network.GetAddresses(host, port, IPVersion, selType, PreferIPv6, false);
if (addrs.Count > 0)
{
callback.Connectors(endpoint.Connectors(addrs, null));
return;
}
}
catch (LocalException ex)
{
callback.Exception(ex);
return;
}
}
lock (_endpointHostResolverThread)
{
Debug.Assert(!_endpointHostResolverDestroyed);
var entry = new ResolveEntry(host, port, selType, endpoint, callback);
Instrumentation.ICommunicatorObserver?obsv = Observer;
if (obsv != null)
{
entry.Observer = obsv.GetEndpointLookupObserver(endpoint);
if (entry.Observer != null)
{
entry.Observer.Attach();
}
}
_enpointHostResolverQueue.AddLast(entry);
Monitor.Pulse(_endpointHostResolverThread);
}
}
internal TcpConnector(TcpEndpoint endpoint, EndPoint addr, INetworkProxy?proxy)
{
_endpoint = endpoint;
_addr = addr;
_proxy = proxy;
var hash = new System.HashCode();
hash.Add(_endpoint.Protocol);
hash.Add(_endpoint.Transport);
hash.Add(_addr);
if (_endpoint.SourceAddress != null)
{
hash.Add(_endpoint.SourceAddress);
}
_hashCode = hash.ToHashCode();
}
internal TcpTransceiver(Communicator communicator, EndPoint addr, INetworkProxy?proxy, IPAddress?sourceAddr)
{
_communicator = communicator;
_proxy = proxy;
_addr = addr;
_desc = "";
_sourceAddr = sourceAddr;
Socket = Network.CreateSocket(false, (_proxy != null ? _proxy.Address : _addr).AddressFamily);
try
{
Network.SetBufSize(Socket, _communicator, Transport.TCP);
}
catch (Exception)
{
Socket.CloseNoThrow();
throw;
}
}
//
// Only for use by TcpEndpoint
//
internal TcpConnector(ProtocolInstance instance, EndPoint addr, INetworkProxy?proxy, EndPoint?sourceAddr,
int timeout, string connectionId)
{
_instance = instance;
_addr = addr;
_proxy = proxy;
_sourceAddr = sourceAddr;
_timeout = timeout;
_connectionId = connectionId;
_hashCode = 5381;
HashUtil.HashAdd(ref _hashCode, _addr);
if (_sourceAddr != null)
{
HashUtil.HashAdd(ref _hashCode, _sourceAddr);
}
HashUtil.HashAdd(ref _hashCode, _timeout);
HashUtil.HashAdd(ref _hashCode, _connectionId);
}
//
// Only for use by TcpEndpoint
//
internal TcpConnector(TransportInstance instance, EndPoint addr, INetworkProxy?proxy, IPAddress?sourceAddr,
int timeout, string connectionId)
{
_instance = instance;
_addr = addr;
_proxy = proxy;
_sourceAddr = sourceAddr;
_timeout = timeout;
_connectionId = connectionId;
var hash = new System.HashCode();
hash.Add(_addr);
if (_sourceAddr != null)
{
hash.Add(_sourceAddr);
}
hash.Add(_timeout);
hash.Add(_connectionId);
_hashCode = hash.ToHashCode();
}
public static string FdToString(Socket socket, INetworkProxy?proxy, EndPoint?target)
{
try
{
if (socket == null)
{
return("<closed>");
}
EndPoint?remote = GetRemoteAddress(socket);
var s = new System.Text.StringBuilder();
s.Append("local address = " + LocalAddrToString(GetLocalAddress(socket)));
if (proxy != null)
{
if (remote == null)
{
remote = proxy.GetAddress();
}
s.Append("\n" + proxy.GetName() + " proxy address = " + RemoteAddrToString(remote));
s.Append("\nremote address = " + RemoteAddrToString(target));
}
else
{
if (remote == null)
{
remote = target;
}
s.Append("\nremote address = " + RemoteAddrToString(remote));
}
return(s.ToString());
}
catch (ObjectDisposedException)
{
return("<closed>");
}
}
public void RunEndpointHostResolver()
{
while (true)
{
ResolveEntry r;
Instrumentation.IThreadObserver?threadObserver;
lock (_endpointHostResolverThread)
{
while (!_endpointHostResolverDestroyed && _enpointHostResolverQueue.Count == 0)
{
Monitor.Wait(_endpointHostResolverThread);
}
if (_endpointHostResolverDestroyed)
{
break;
}
r = _enpointHostResolverQueue.First.Value;
_enpointHostResolverQueue.RemoveFirst();
threadObserver = _endpointHostResolverObserver;
}
if (threadObserver != null)
{
threadObserver.StateChanged(Instrumentation.ThreadState.ThreadStateIdle,
Instrumentation.ThreadState.ThreadStateInUseForOther);
}
try
{
INetworkProxy?networkProxy = NetworkProxy;
int ipVersion = IPVersion;
if (networkProxy != null)
{
networkProxy = networkProxy.ResolveHost(ipVersion);
if (networkProxy != null)
{
ipVersion = networkProxy.GetIPVersion();
}
}
List <EndPoint> addrs = Network.GetAddresses(r.Host, r.Port, ipVersion, r.SelType,
PreferIPv6, true);
if (r.Observer != null)
{
r.Observer.Detach();
r.Observer = null;
}
r.Callback.Connectors(r.Endpoint.Connectors(addrs, networkProxy));
}
catch (LocalException ex)
{
if (r.Observer != null)
{
r.Observer.Failed(ex.ice_id());
r.Observer.Detach();
}
r.Callback.Exception(ex);
}
finally
{
if (threadObserver != null)
{
threadObserver.StateChanged(Instrumentation.ThreadState.ThreadStateInUseForOther,
Instrumentation.ThreadState.ThreadStateIdle);
}
}
}
foreach (ResolveEntry entry in _enpointHostResolverQueue)
{
var ex = new CommunicatorDestroyedException();
if (entry.Observer != null)
{
entry.Observer.Failed(ex.ice_id());
entry.Observer.Detach();
}
entry.Callback.Exception(ex);
}
_enpointHostResolverQueue.Clear();
if (_endpointHostResolverObserver != null)
{
_endpointHostResolverObserver.Detach();
}
}
private protected abstract IConnector CreateConnector(EndPoint addr, INetworkProxy?proxy);
internal override ITransceiver CreateTransceiver(EndPoint addr, INetworkProxy?proxy) => new WSTransceiver(Communicator, base.CreateTransceiver(addr, proxy), Host, Resource);
private protected override IConnector CreateConnector(EndPoint addr, INetworkProxy?proxy) => new TcpConnector(Instance, addr, proxy, SourceAddress, Timeout, ConnectionId);
internal override ITransceiver CreateTransceiver(IConnector connector, EndPoint addr, INetworkProxy?proxy) => new WSTransceiver(Communicator, base.CreateTransceiver(connector, addr, proxy), Host, Resource, connector);
private protected override IConnector CreateConnector(EndPoint addr, INetworkProxy?proxy) => new TcpConnector(this, addr, proxy);
private protected override IConnector CreateConnector(EndPoint addr, INetworkProxy?proxy) => new UdpConnector(Communicator, addr, SourceAddress, McastInterface, McastTtl, ConnectionId);