private async void CreateInternalServer()
{
InternalServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
ReceiveTimeout = ReadWriteTimeOut,
SendTimeout = ReadWriteTimeOut,
ExclusiveAddressUse = true
};
InternalServer.Bind(new IPEndPoint(IPAddress.Loopback, 0));
InternalPort = ((IPEndPoint)(InternalServer.LocalEndPoint)).Port;
InternalUri = new Uri($"http://127.0.0.1:{InternalPort}");
InternalServer.Listen(512);
while (!IsDisposed)
{
try
{
Socket InternalClient = await InternalServer?.AcceptAsync();
if (InternalClient != null)
{
_ = HandleClient(InternalClient);
}
}
catch
{
//? Ignore dispose intrnal server
}
}
}
public void Shutdown_TCP_CLOSED_Success()
{
// NOTE: this value should technically be at least as long as the amount
// of time that a TCP connection will stay in the TIME_WAIT state.
// That value, however, is technically defined as 2 * MSL, which is
// officially 4 minutes, and may differ between systems. In practice,
// 5 seconds has proved to be long enough.
const int TimeWaitTimeout = 5000;
using (Socket server = new Socket(SocketType.Stream, ProtocolType.Tcp))
using (Socket client = new Socket(SocketType.Stream, ProtocolType.Tcp))
{
int port = server.BindToAnonymousPort(IPAddress.IPv6Any);
server.Listen(1);
var args = new SocketAsyncEventArgs();
args.Completed += OnOperationCompleted;
Assert.True(server.AcceptAsync(args));
client.Connect(IPAddress.IPv6Loopback, port);
var buffer = new byte[] { 42 };
for (int i = 0; i < 32; i++)
{
int sent = client.Send(buffer);
Assert.Equal(1, sent);
}
client.Shutdown(SocketShutdown.Send);
int received = 0;
do
{
received = client.Receive(buffer);
} while (received != 0);
// Wait for the underlying connection to transition from TIME_WAIT to
// CLOSED.
Task.Delay(TimeWaitTimeout).Wait();
client.Shutdown(SocketShutdown.Both);
}
}
public async Task ReuseSocketAsyncEventArgs_SameInstance_MultipleSockets()
{
using (var listen = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
using (var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
listen.Bind(new IPEndPoint(IPAddress.Loopback, 0));
listen.Listen(1);
Task<Socket> acceptTask = listen.AcceptAsync();
await Task.WhenAll(
acceptTask,
client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listen.LocalEndPoint).Port)));
using (Socket server = await acceptTask)
{
TaskCompletionSource<bool> tcs = null;
var args = new SocketAsyncEventArgs();
args.SetBuffer(new byte[1024], 0, 1024);
args.Completed += (_,__) => tcs.SetResult(true);
for (int i = 1; i <= 10; i++)
{
tcs = new TaskCompletionSource<bool>();
args.Buffer[0] = (byte)i;
args.SetBuffer(0, 1);
if (server.SendAsync(args))
{
await tcs.Task;
}
args.Buffer[0] = 0;
tcs = new TaskCompletionSource<bool>();
if (client.ReceiveAsync(args))
{
await tcs.Task;
}
Assert.Equal(1, args.BytesTransferred);
Assert.Equal(i, args.Buffer[0]);
}
}
}
}
public void StartListen(SocketAsyncEventArgs saea)
{
if (saea == null)
{
saea = new SocketAsyncEventArgs();
}
else
{
saea.AcceptSocket = null;//初始化清空；
}
saea.Completed += Acction; //saea.Completed回调程序，在完成监听的时候执行委托
bool jim = socket.AcceptAsync(saea); //这里线程不会阻塞，但异步线程正在等待用户接入，等到用户接入时，就会调用saea.Completed;
//判断异步是否挂起
//true 挂起监听，如果挂起表示我们没有立刻收到客户端的链接，（假阻塞）需要等待客户端接入进来，通过Completed事件通知服务器有客户端接入进来
//false 没有挂起，没有挂起表示我们立刻收到了客户端链接,不会执行saea.Completed这个回调程序，所以需要自己手动执行
if (!jim) //取反，如果jim为true,这里就为false条件，反之为true条件；因为当jim为false时，需要执行下面方法；但是只有if(ture)才会执行，这里就绕了一下；相当于if(jim==false){};
{
ListenTheUser(saea); //同步完成
}
}
private void Accepted(object sender, SocketAsyncEventArgs eventArgs)
{
try
{
Socket acceptedSocket = eventArgs.AcceptSocket;
if (acceptedSocket.Connected == false)
{
return;
}
Session acceptedSession = _networkChannel.PopInactiveSession();
if (acceptedSession == null)
{
acceptedSocket.Close();
Logger.Err(LogMask.Aegis, "Cannot activate any more sessions. Please check MaxSessionPoolSize.");
return;
}
acceptedSession.AttachSocket(acceptedSocket);
acceptedSession.OnSocket_Accepted();
eventArgs.AcceptSocket = null;
_listenSocket.AcceptAsync(_eventAccept);
}
catch (SocketException e)
{
if (e.SocketErrorCode != SocketError.Interrupted)
{
Logger.Err(LogMask.Aegis, e.ToString());
}
}
catch (Exception e)
{
Logger.Err(LogMask.Aegis, e.ToString());
}
}
public async Task Start(IPAddress address = null, int bindPort = 9050)
{
if (_alive)
{
throw new Exception("Cannot start, server is running");
}
if (address == null)
{
address = await Utils.GetIPAddress().ConfigureAwait(false);
}
_listener = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp)
{
NoDelay = true
};
_listener.Bind(new IPEndPoint(address, bindPort));
_listener.Listen(100);
_alive = true;
HostName = address.ToString();
Socket socket;
try
{
while (true)
{
socket = await _listener.AcceptAsync().ConfigureAwait(false);
socket.NoDelay = true;
_ = ProcessSocket(socket);
}
}
catch { }
ShutDown();
}
public async void Start()
{
var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var localEndPoint = new IPEndPoint(IPAddress.Any, _port);
try
{
listener.Bind(localEndPoint);
listener.Listen(100);
while (true)
{
var clientSocket = await listener.AcceptAsync();
ProcessSocket(clientSocket);
}
}
catch (Exception e)
{
Logger.Write(e);
}
}
protected override void Start(CancellationToken token)
{
var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var connectArgs = new SocketAsyncEventArgs();
token.Register(() => {
listener.Close();
connectArgs.Dispose();
});
listener.Bind(OriginalEndPoint);
EndPoint = (IPEndPoint)listener.LocalEndPoint;
listener.Listen(6);
connectArgs.Completed += OnSocketReceived;
if (!listener.AcceptAsync(connectArgs))
{
OnSocketReceived(listener, connectArgs);
}
}
private void ContinueAccept(SocketAsyncEventArgs currentAcceptor)
{
bool callbackPending;
try
{
callbackPending = socket.AcceptAsync(currentAcceptor);
}
catch (ObjectDisposedException)
{
// either acceptor is disposed/corrupted, or socket is closed
StartAccept(); // possible stack overflow if too many accepts end up bad
HandleBadAcceptor(currentAcceptor);
return;
}
if (!callbackPending)
{
ProcessAccept(currentAcceptor);
}
}
/// <summary>
/// 开始客户端连接监听
/// </summary>
public void StartAccept(SocketAsyncEventArgs e)
{
//如果当前传入为空 说明调用新的客户端连接监听事件 否则的话 移除当前客户端连接
if (e == null)
{
e = new SocketAsyncEventArgs();
e.Completed += new EventHandler <SocketAsyncEventArgs>(Accept_Comleted);
}
else
{
e.AcceptSocket = null;
}
//信号量-1
acceptClients.WaitOne();
bool result = server.AcceptAsync(e);
//判断异步事件是否挂起 没挂起说明立刻执行完成 直接处理事件 否则会在处理完成后触发Accept_Comleted事件
if (!result)
{
ProcessAccept(e);
}
}
public EndPointListener(HttpListener listener, IPAddress addr, int port, bool secure)
{
this.listener = listener;
if (secure)
{
this.secure = secure;
cert = listener.LoadCertificateAndKey(addr, port);
}
endpoint = new IPEndPoint(addr, port);
sock = new Socket(addr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
sock.Bind(endpoint);
sock.Listen(500);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.UserToken = this;
args.Completed += OnAccept;
sock.AcceptAsync(args);
prefixes = new Hashtable();
unregistered = new Dictionary <HttpConnection, HttpConnection> ();
}
public void CreateSocketServer()
{
s_listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
s_listener.Listen(int.MaxValue);
var ep = (IPEndPoint)s_listener.LocalEndPoint;
s_uri = new Uri($"https://{ep.Address}:{ep.Port}/");
Task.Run(async() =>
{
while (true)
{
Socket s = await s_listener.AcceptAsync();
var ignored = Task.Run(async() =>
{
using (X509Certificate2 serverCert = GetServerCertificate())
using (var serverStream = new SslStream(new NetworkStream(s, true), false, delegate { return(true); }))
{
await serverStream.AuthenticateAsServerAsync(serverCert, false, SslProtocols.None, false);
using (var reader = new StreamReader(serverStream))
using (var writer = new StreamWriter(serverStream)
{
AutoFlush = true
})
{
while (true)
{
while (!string.IsNullOrEmpty(await reader.ReadLineAsync()))
{
;
}
await writer.WriteAsync("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello");
}
}
}
});
}
});
}
/// <summary>
/// Binds and listens for connections on the specified port.
/// </summary>
/// <param name="address"></param>
/// <param name="port"></param>
/// <returns></returns>
private Socket BindSocket(IPAddress address, int port)
{
try {
var endpoint = new IPEndPoint(address, port);
var socket = new Socket(endpoint.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
var args = new SocketAsyncEventArgs();
args.Completed += OnAccept;
args.UserToken = socket;
socket.Bind(endpoint);
socket.Listen(int.MaxValue);
if (!socket.AcceptAsync(args))
{
OnAccept(null, args);
}
return(socket);
}
catch (Exception ex) {
_logger.Warning(ex, "failed to create listening socket.");
return(null);
}
}
private async Task AcceptClientConnectionsAsync(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
try
{
#if NET452 || NET461
var clientSocket = await Task.Factory.FromAsync(_socket.BeginAccept, _socket.EndAccept, null).ConfigureAwait(false);
#else
var clientSocket = await _socket.AcceptAsync().ConfigureAwait(false);
#endif
#pragma warning disable 4014
Task.Run(() => TryHandleClientConnectionAsync(clientSocket), cancellationToken);
#pragma warning restore 4014
}
catch (Exception exception)
{
_logger.Error(exception, $"Error while accepting connection at TCP listener {_socket.LocalEndPoint} TLS={_tlsCertificate != null}.");
await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
}
}
}
public void Run(IBackgroundTaskInstance taskInstance)
{
// Setup Netowrk Socket
Server = new Socket(SocketType.Stream, ProtocolType.Tcp);
Server.Bind(new IPEndPoint(IPAddress.Any, 1911));
Server.Listen(100);
// Setup Servos
var controller = GpioController.GetDefault();
// GPIO 18
var pin = controller.OpenPin(18, GpioSharingMode.Exclusive);
pin.SetDriveMode(GpioPinDriveMode.Output);
Azimuth = new ServoController(new SofwarePwm(n => pin.Write(n ? GpioPinValue.High : GpioPinValue.Low), 50, 0));
Azimuth.Start(90);
// GPIO 23
pin = controller.OpenPin(23, GpioSharingMode.Exclusive);
pin.SetDriveMode(GpioPinDriveMode.Output);
Inclenation = new ServoController(new SofwarePwm(n => pin.Write(n ? GpioPinValue.High : GpioPinValue.Low), 50, 0));
Inclenation.Start(90);
Server.Listen(10);
var connectEvent = new AutoResetEvent(false);
while (true)
{
SocketAsyncEventArgs e = new SocketAsyncEventArgs();
e.Completed += AcceptCallback;
if (!Server.AcceptAsync(e))
{
AcceptCallback(Server, e);
connectEvent.Set();
}
connectEvent.WaitOne(1000);
}
}
public async void AcceptConnections()
{
while (true)
{
Socket clientSocket = null;
try
{
try
{
clientSocket = await _serverSocket.AcceptAsync();
}
catch (ObjectDisposedException)
{
break;
}
var client = await Transport.AcceptAsync(clientSocket,
supportsFdPassing : _serverSocket.AddressFamily == AddressFamily.Unix);
lock (_gate)
{
if (IsDisposed)
{
client.Dispose();
break;
}
var clientsUpdated = new IMessageStream[_clients.Length + 1];
Array.Copy(_clients, clientsUpdated, _clients.Length);
clientsUpdated[clientsUpdated.Length - 1] = client;
_clients = clientsUpdated;
}
_connection.ReceiveMessages(client, RemoveStream);
}
catch
{
clientSocket?.Dispose();
}
}
}
public void Start()
{
Debug.Info("Socket server starting");
Debug.Info($"Port: {Settings.Server.SrvPort}");
Socket listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
/// listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, 4444));
listenSocket.Bind(new IPEndPoint(IPAddress.Any, Convert.ToInt16(Settings.Server.SrvPort)));
listenSocket.Listen(100);
SocketAsyncEventArgs e = new SocketAsyncEventArgs();
e.Completed += AcceptCallback;
if (!listenSocket.AcceptAsync(e))
{
AcceptCallback(listenSocket, e);
}
Console.WriteLine("Socket server Ending");
// Console.ReadKey(true);
}
public override void Initialize()
{
if (_socket != null)
{
return;
}
_policy = Encoding.UTF8.GetBytes(string.Format(PolicyTemplate, PortFrom, PortTo));
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
ExclusiveAddressUse = true
};
_socket.Bind(new IPEndPoint(IPAddress.Any, 943));
_socket.Listen(100);
var args = new SocketAsyncEventArgs();
args.Completed += AcceptAsyncCompleted;
_socket.AcceptAsync(args);
}
/// <summary>
/// 开始接受连接请求
/// </summary>
/// <param name="acceptEventArg"></param>
private void StartAccept(SocketAsyncEventArgs acceptEventArg)
{
if (acceptEventArg == null)
{
acceptEventArg = new SocketAsyncEventArgs();
acceptEventArg.Completed += new EventHandler <SocketAsyncEventArgs>(AcceptEventArg_Completed);
}
else
{
// 由于上下文对象正在被使用Socket必须被清理
acceptEventArg.AcceptSocket = null;
}
try
{
m_maxNumberAcceptedClients.WaitOne();// 对信号量进行一次P操作
bool willRaiseEvent = listenSocket.AcceptAsync(acceptEventArg);
if (!willRaiseEvent)
{
ProcessAccept(acceptEventArg);
}
}
catch (ObjectDisposedException)
{
}
catch (SocketException socketException)
{
RaiseErrorEvent(null, new AsyncSocketException("服务器接受客户端请求发生一次异常", socketException));
// 接受客户端发生异常
//throw new AsyncSocketException("服务器接受客户端请求发生一次异常", AsyncSocketErrorCode.ServerAcceptFailure);
}
catch (Exception exception_debug)
{
Debug.WriteLine("调试：" + exception_debug.Message);
throw exception_debug;
}
}
public void Listen(ushort port)
{
try
{
if (!_Listening)
{
_Clients = new List <ServerClient>();
Item = new SocketAsyncEventArgs();
Item.Completed += Process;
Item.AcceptSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Item.AcceptSocket.NoDelay = true;
if (_KeepAlive)
{
Item.AcceptSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 20000);
}
Handle = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Handle.Bind(new IPEndPoint(IPAddress.Any, port));
Handle.Listen(10);
Processing = false;
_Listening = true;
OnStateChanged(true);
if (!Handle.AcceptAsync(Item))
{
Process(null, Item);
}
}
}
catch (Exception ex)
{
OnExceptionThrown(ex);
Disconnect();
}
}
private void ProcessAccept(SocketAsyncEventArgs e)
{
bool bLoop = false;
do
{
Socket socket = null;
try
{
if (e.SocketError != SocketError.Success)
{
var errorCode = (int)e.SocketError;
if (errorCode == 995 || errorCode == 10004 || errorCode == 10038)
{
return;
}
}
socket = e.AcceptSocket;
if (socket != null)
{
OnNewSocket(socket);
}
}
catch (Exception ex)
{
LogHelper.LogException(ex);
if (socket != null)
{
socket.Close();
}
}
finally
{
_AcceptEvent.AcceptSocket = null;
bLoop = !_LocalSocket.AcceptAsync(_AcceptEvent);
}
} while (bLoop);
}
public async Task Handle()
{
//var document = new Documents();
//var keys = document.GetKeys();
//var api = new TwitterApi(keys);
//var sentences = api.GiveMeMostRecentTweets("Pontifex_ln");
//var tweets = new List<TweetInDatabase>();
//foreach (var sentence in sentences)
//{
// var tweet = new TweetInDatabase() { Text = sentence.CleanTweet() };
// tweets.Add(tweet);
//}
//document.StoreSermonTweetFragments(tweets, "ln");
//var epis = new Epistula() { Preparatio = 20, Lingua = "ln", Modus = "pontifex" };
//var proc = new Sermon();
//Console.WriteLine(proc.Generate(epis));
System.Console.WriteLine($"Starting TCP Server on port {Port}");
Accepting = true;
_socket.Listen(100);
//handle new connection
//check for disconnects
//check for new requests
//send back messages
while (Accepting)
{
var acceptTask = _socket.AcceptAsync();
foreach (var conn in _clients)
{
ProcessConnectionAsync(conn);
}
var client = await acceptTask;
_clients.Add(client);
}
//accept
//invoke connecteD?
//receive messages?
}
public void Listen(ushort port)
{
try
{
if (!Listening)
{
_keepAlives = new List <KeepAlive>();
_clients = new List <Client>();
_item = new SocketAsyncEventArgs();
_item.Completed += Process;
_handle = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_handle.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
_handle.NoDelay = true;
_handle.Bind(new IPEndPoint(IPAddress.Any, port));
_handle.Listen(10);
Processing = false;
Listening = true;
OnServerState(true);
SendKeepAlives();
if (!_handle.AcceptAsync(_item))
{
Process(null, _item);
}
}
}
catch
{
Disconnect();
}
}
private async Task AcceptCallback(Socket listener)
{
List <Task> pending_tasks = new List <Task>();
while (true)
{
try
{
pending_tasks.Add(listener.AcceptAsync());
Task task = await Task.WhenAny(pending_tasks);
pending_tasks.Remove(task);
if (task is Task <Socket> )
{
Socket client = await(Task <Socket>) task;
if (ClientConnected != null)
{
pending_tasks.Add(SetupClient(client));
}
else
{
// There was noone to accept the message, so just close
client.Dispose();
}
}
}
catch (ObjectDisposedException)
{
// If client socket closed then exit loop.
break;
}
catch (Exception ex)
{
_logger.LogException(ex);
}
}
}
public bool Start(int backLog = 10)
{
if (IsRuning)
{
return(false);
}
try
{
IPEndPoint localEndPoint = new IPEndPoint(Address, Port);
Socket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
if (localEndPoint.AddressFamily == AddressFamily.InterNetworkV6)
{
Socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false);
Socket.Bind(new IPEndPoint(IPAddress.IPv6Any, localEndPoint.Port));
}
else
{
Socket.Bind(localEndPoint);
}
Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
Socket.Listen(backLog);
Msaea = new SocketAsyncEventArgs();
Msaea.Completed += new EventHandler <SocketAsyncEventArgs>(Msaea_Completed);
IsRuning = true;
if (!Socket.AcceptAsync(Msaea))
{
ProcessAccept(Msaea);
}
return(true);
}
catch
{
return(false);
}
}
public void AcceptAsync_IPv6_Success()
{
Assert.True(Capability.IPv6Support());
AutoResetEvent completed = new AutoResetEvent(false);
AutoResetEvent completedClient = new AutoResetEvent(false);
using (Socket sock = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
{
int port = sock.BindToAnonymousPort(IPAddress.IPv6Loopback);
sock.Listen(1);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += OnAcceptCompleted;
args.UserToken = completed;
Assert.True(sock.AcceptAsync(args));
_log.WriteLine("IPv6 Server: Waiting for clients.");
using (Socket client = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
{
SocketAsyncEventArgs argsClient = new SocketAsyncEventArgs();
argsClient.RemoteEndPoint = new IPEndPoint(IPAddress.IPv6Loopback, port);
argsClient.Completed += OnConnectCompleted;
argsClient.UserToken = completedClient;
client.ConnectAsync(argsClient);
_log.WriteLine("IPv6 Client: Connecting.");
Assert.True(completed.WaitOne(5000), "IPv6: Timed out while waiting for connection");
Assert.Equal <SocketError>(SocketError.Success, args.SocketError);
Assert.NotNull(args.AcceptSocket);
Assert.True(args.AcceptSocket.Connected, "IPv6 Accept Socket was not connected");
Assert.NotNull(args.AcceptSocket.RemoteEndPoint);
Assert.Equal(client.LocalEndPoint, args.AcceptSocket.RemoteEndPoint);
}
}
}
private async Task AcceptClientConnectionsAsync(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
try
{
#if NET452 || NET461
var clientSocket = await Task.Factory.FromAsync(_socket.BeginAccept, _socket.EndAccept, null).ConfigureAwait(false);
#else
var clientSocket = await _socket.AcceptAsync().ConfigureAwait(false);
#endif
if (clientSocket == null)
{
continue;
}
Task.Run(() => TryHandleClientConnectionAsync(clientSocket), cancellationToken).Forget(_logger);
}
catch (OperationCanceledException)
{
}
catch (Exception exception)
{
if (exception is SocketException socketException)
{
if (socketException.SocketErrorCode == SocketError.ConnectionAborted ||
socketException.SocketErrorCode == SocketError.OperationAborted)
{
continue;
}
}
_logger.Error(exception, $"Error while accepting connection at TCP listener {_localEndPoint} TLS={_tlsCertificate != null}.");
await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
}
}
}
public void AcceptAsync_IpV4_Success()
{
Assert.True(Capability.IPv4Support());
AutoResetEvent completed = new AutoResetEvent(false);
AutoResetEvent completedClient = new AutoResetEvent(false);
using (Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
int port = sock.BindToAnonymousPort(IPAddress.Loopback);
sock.Listen(1);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += OnAcceptCompleted;
args.UserToken = completed;
Assert.True(sock.AcceptAsync(args));
_log.WriteLine("IPv4 Server: Waiting for clients.");
using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
SocketAsyncEventArgs argsClient = new SocketAsyncEventArgs();
argsClient.RemoteEndPoint = new IPEndPoint(IPAddress.Loopback, port);
argsClient.Completed += OnConnectCompleted;
argsClient.UserToken = completedClient;
client.ConnectAsync(argsClient);
_log.WriteLine("IPv4 Client: Connecting.");
Assert.True(completed.WaitOne(5000), "IPv4: Timed out while waiting for connection");
Assert.Equal<SocketError>(SocketError.Success, args.SocketError);
Assert.NotNull(args.AcceptSocket);
Assert.True(args.AcceptSocket.Connected, "IPv4 Accept Socket was not connected");
Assert.NotNull(args.AcceptSocket.RemoteEndPoint);
Assert.Equal(client.LocalEndPoint, args.AcceptSocket.RemoteEndPoint);
}
}
}
public static Task <Socket> AcceptSocketAsync(this Socket socket)
{
var acceptSource = new TaskCompletionSource <Socket>();
void AcceptHandler(object sender, SocketAsyncEventArgs eventArgs)
{
var error = eventArgs.SocketError;
eventArgs.Completed -= AcceptHandler;
eventArgs.Dispose();
if (error != SocketError.Success)
{
acceptSource.TrySetException(new SocketException((int)error));
return;
}
acceptSource.TrySetResult(eventArgs.AcceptSocket);
}
var e = new SocketAsyncEventArgs();
e.Completed += AcceptHandler;
try
{
if (!socket.AcceptAsync(e))
{
AcceptHandler(null, e);
}
}
catch (Exception ex)
{
acceptSource.TrySetException(ex);
}
return(acceptSource.Task);
}
private void StartAccept(SocketAsyncEventArgs AcceptEventArgs)
{
try
{
if (IsListening)
{
if (AcceptEventArgs == null)
{
AcceptEventArgs = new SocketAsyncEventArgs();
AcceptEventArgs.Completed += AcceptEventArgs_Completed;
}
else
{
AcceptEventArgs.AcceptSocket = null;
}
if (!Listener.AcceptAsync(AcceptEventArgs))
{
ProcessAccept(AcceptEventArgs);
}
}
}
catch (SocketException)
{
if (IsListening == true && IsShutdown == false)
{
SetOnException(new Exception("Server Exception (StartAccept): Could not start accept due to server shutdown"));
Shutdown();
}
}
catch (Exception ex)
{
if (IsListening == true && IsShutdown == false)
{
SetOnException(new Exception(string.Format("Server Exception (StartAccept): {0}", ex.Message)));
Shutdown();
}
}
}
/// <summary>
/// Starts accepting incoming clients.
/// </summary>
/// <param name="args">The async event args to use, if any (passing null
/// will create a new object).</param>
private void Accept(SocketAsyncEventArgs args)
{
if (args == null)
{
args = SocketAsyncEventArgsPool.Acquire();
args.Completed += OnAccept;
}
else
{
args.AcceptSocket = null;
}
try
{
if (!_socket.AcceptAsync(args))
{
OnAccept(this, args);
}
}
catch (Exception ex)
{
args.Completed -= OnAccept;
SocketAsyncEventArgsPool.Release(args);
if (ex is ObjectDisposedException)
{
return;
}
if (ex is SocketException)
{
ExceptionManager.RegisterException(ex);
return;
}
throw;
}
}
/// <summary>
/// Discover the server EndPoint. Will async wait forever if it cannot find one.
/// </summary>
/// <param name="port"></param>
/// <returns>IPEndPoint of the server</returns>
private static async Task <IPEndPoint> DiscoverServerEndPoint(int port)
{
// Create our broadcast address
var broadcastIp = IPAddress.Parse("255.255.255.255");
var broadcastEndpoint = new IPEndPoint(broadcastIp, port);
// Create a UDP socket with broadcasting enabled
var broadcaster = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
broadcaster.EnableBroadcast = true;
// Connect to this socket to find our local IP
broadcaster.Connect(broadcastEndpoint);
var localIp = ((IPEndPoint)broadcaster.LocalEndPoint).Address;
// Create a TCP socket for listening for the server IP
var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Bind to our local IP we just discovered but with our standard port
listener.Bind(new IPEndPoint(localIp, port));
listener.Listen(120);
// Send off our broadcast datagram
broadcaster.SendTo(Array.Empty <byte>(), broadcastEndpoint);
// Async wait for the server IP address to come on the TCP socket
var buffer = new byte[4];
var socket = await listener.AcceptAsync();
await socket.ReceiveAsync(buffer, SocketFlags.None);
// Release all resources used by our sockets
broadcaster.Dispose();
listener.Dispose();
// Return the address we received from the server
return(new IPEndPoint(new IPAddress(buffer), port));
}
public async Task Socket_SendReceiveAsync_Success()
{
string path = GetRandomNonExistingFilePath();
var endPoint = new UnixDomainSocketEndPoint(path);
try
{
using (var server = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
using (var client = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
{
server.Bind(endPoint);
server.Listen(1);
await client.ConnectAsync(endPoint);
using (Socket accepted = await server.AcceptAsync())
{
var data = new byte[1];
for (int i = 0; i < 10; i++)
{
data[0] = (byte)i;
await accepted.SendAsync(new ArraySegment <byte>(data), SocketFlags.None);
data[0] = 0;
Assert.Equal(1, await client.ReceiveAsync(new ArraySegment <byte>(data), SocketFlags.None));
Assert.Equal(i, data[0]);
}
}
}
}
finally
{
try { File.Delete(path); }
catch { }
}
}
public void AcceptAsync_NotListening_Throws_InvalidOperation()
{
using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
socket.Bind(new IPEndPoint(IPAddress.Loopback, 0));
Assert.Throws<InvalidOperationException>(() => socket.AcceptAsync(s_eventArgs));
}
}
public void PollWrite_Single_Timeout()
{
using (var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
listener.BindToAnonymousPort(IPAddress.Loopback);
listener.Listen(1);
listener.AcceptAsync();
Assert.False(listener.Poll(SelectTimeout, SelectMode.SelectWrite));
}
}
public void SelectWrite_Multiple_Mixed()
{
using (var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
using (var sender = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
listener.BindToAnonymousPort(IPAddress.Loopback);
listener.Listen(1);
listener.AcceptAsync();
var list = new List<Socket> { listener, sender };
Socket.Select(null, list, null, SelectSuccessTimeoutMicroseconds);
Assert.Equal(1, list.Count);
Assert.Equal(sender, list[0]);
}
}
public void SendRecvAsync_Stream_TCP(IPAddress listenAt, bool useMultipleBuffers)
{
const int BytesToSend = 123456;
const int ListenBacklog = 1;
const int LingerTime = 60;
const int TestTimeout = 30000;
var server = new Socket(listenAt.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
server.BindToAnonymousPort(listenAt);
server.Listen(ListenBacklog);
var serverFinished = new TaskCompletionSource<bool>();
int bytesReceived = 0;
var receivedChecksum = new Fletcher32();
var serverEventArgs = new SocketAsyncEventArgs();
server.AcceptAsync(serverEventArgs, remote =>
{
Action<int> recvHandler = null;
bool first = true;
if (!useMultipleBuffers)
{
var recvBuffer = new byte[256];
recvHandler = received =>
{
if (!first)
{
if (received == 0)
{
remote.Dispose();
server.Dispose();
serverFinished.SetResult(true);
return;
}
bytesReceived += received;
receivedChecksum.Add(recvBuffer, 0, received);
}
else
{
first = false;
}
remote.ReceiveAsync(serverEventArgs, recvBuffer, 0, recvBuffer.Length, SocketFlags.None, recvHandler);
};
}
else
{
var recvBuffers = new List<ArraySegment<byte>> {
new ArraySegment<byte>(new byte[123]),
new ArraySegment<byte>(new byte[256], 2, 100),
new ArraySegment<byte>(new byte[1], 0, 0),
new ArraySegment<byte>(new byte[64], 9, 33)
};
recvHandler = received =>
{
if (!first)
{
if (received == 0)
{
remote.Dispose();
server.Dispose();
serverFinished.SetResult(true);
return;
}
bytesReceived += received;
for (int i = 0, remaining = received; i < recvBuffers.Count && remaining > 0; i++)
{
ArraySegment<byte> buffer = recvBuffers[i];
int toAdd = Math.Min(buffer.Count, remaining);
receivedChecksum.Add(buffer.Array, buffer.Offset, toAdd);
remaining -= toAdd;
}
}
else
{
first = false;
}
remote.ReceiveAsync(serverEventArgs, recvBuffers, SocketFlags.None, recvHandler);
};
}
recvHandler(0);
});
EndPoint clientEndpoint = server.LocalEndPoint;
var client = new Socket(clientEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
int bytesSent = 0;
var sentChecksum = new Fletcher32();
var clientEventArgs = new SocketAsyncEventArgs();
client.ConnectAsync(clientEventArgs, clientEndpoint, () =>
{
Action<int> sendHandler = null;
var random = new Random();
var remaining = BytesToSend;
bool first = true;
if (!useMultipleBuffers)
{
var sendBuffer = new byte[512];
sendHandler = sent =>
{
if (!first)
{
bytesSent += sent;
sentChecksum.Add(sendBuffer, 0, sent);
remaining -= sent;
Assert.True(remaining >= 0);
if (remaining == 0)
{
client.LingerState = new LingerOption(true, LingerTime);
client.Dispose();
return;
}
}
else
{
first = false;
}
random.NextBytes(sendBuffer);
client.SendAsync(clientEventArgs, sendBuffer, 0, Math.Min(sendBuffer.Length, remaining), SocketFlags.None, sendHandler);
};
}
else
{
var sendBuffers = new List<ArraySegment<byte>> {
new ArraySegment<byte>(new byte[23]),
new ArraySegment<byte>(new byte[256], 2, 100),
new ArraySegment<byte>(new byte[1], 0, 0),
new ArraySegment<byte>(new byte[64], 9, 9)
};
sendHandler = sent =>
{
if (!first)
{
bytesSent += sent;
for (int i = 0, r = sent; i < sendBuffers.Count && r > 0; i++)
{
ArraySegment<byte> buffer = sendBuffers[i];
int toAdd = Math.Min(buffer.Count, r);
sentChecksum.Add(buffer.Array, buffer.Offset, toAdd);
r -= toAdd;
}
remaining -= sent;
if (remaining <= 0)
{
client.LingerState = new LingerOption(true, LingerTime);
client.Dispose();
return;
}
}
else
{
first = false;
}
for (int i = 0; i < sendBuffers.Count; i++)
{
random.NextBytes(sendBuffers[i].Array);
}
client.SendAsync(clientEventArgs, sendBuffers, SocketFlags.None, sendHandler);
};
}
sendHandler(0);
});
Assert.True(serverFinished.Task.Wait(TestTimeout), "Completed within allowed time");
Assert.Equal(bytesSent, bytesReceived);
Assert.Equal(sentChecksum.Sum, receivedChecksum.Sum);
}
public static async Task SendRecvAsync_0ByteReceive_Success()
{
using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
listener.Listen(1);
Task<Socket> acceptTask = listener.AcceptAsync();
await Task.WhenAll(
acceptTask,
client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)));
using (Socket server = await acceptTask)
{
TaskCompletionSource<bool> tcs = null;
var ea = new SocketAsyncEventArgs();
ea.SetBuffer(Array.Empty<byte>(), 0, 0);
ea.Completed += delegate { tcs.SetResult(true); };
for (int i = 0; i < 3; i++)
{
tcs = new TaskCompletionSource<bool>();
// Have the client do a 0-byte receive. No data is available, so this should pend.
Assert.True(client.ReceiveAsync(ea));
Assert.Equal(0, client.Available);
// Have the server send 1 byte to the client.
Assert.Equal(1, server.Send(new byte[1], 0, 1, SocketFlags.None));
// The client should now wake up, getting 0 bytes with 1 byte available.
await tcs.Task;
Assert.Equal(0, ea.BytesTransferred);
Assert.Equal(SocketError.Success, ea.SocketError);
Assert.Equal(1, client.Available); // Due to #13778, this sometimes fails on macOS
// Receive that byte
Assert.Equal(1, client.Receive(new byte[1]));
Assert.Equal(0, client.Available);
}
}
}
}
public void AcceptAsync_WithReceiveBuffer_Success()
{
Assert.True(Capability.IPv4Support());
AutoResetEvent accepted = new AutoResetEvent(false);
using (Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
int port = server.BindToAnonymousPort(IPAddress.Loopback);
server.Listen(1);
const int acceptBufferOverheadSize = 288; // see https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.acceptasync(v=vs.110).aspx
const int acceptBufferDataSize = 256;
const int acceptBufferSize = acceptBufferOverheadSize + acceptBufferDataSize;
byte[] sendBuffer = new byte[acceptBufferDataSize];
new Random().NextBytes(sendBuffer);
SocketAsyncEventArgs acceptArgs = new SocketAsyncEventArgs();
acceptArgs.Completed += OnAcceptCompleted;
acceptArgs.UserToken = accepted;
acceptArgs.SetBuffer(new byte[acceptBufferSize], 0, acceptBufferSize);
Assert.True(server.AcceptAsync(acceptArgs));
_log.WriteLine("IPv4 Server: Waiting for clients.");
using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
client.Connect(IPAddress.Loopback, port);
client.Send(sendBuffer);
client.Shutdown(SocketShutdown.Both);
}
Assert.True(
accepted.WaitOne(Configuration.PassingTestTimeout), "Test completed in alotted time");
Assert.Equal(
SocketError.Success, acceptArgs.SocketError);
Assert.Equal(
acceptBufferDataSize, acceptArgs.BytesTransferred);
Assert.Equal(
new ArraySegment<byte>(sendBuffer),
new ArraySegment<byte>(acceptArgs.Buffer, 0, acceptArgs.BytesTransferred));
}
}
public void ConcurrentSendReceive()
{
using (Socket server = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
using (Socket client = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
{
const int Iters = 2048;
byte[] sendData = new byte[Iters];
byte[] receiveData = new byte[sendData.Length];
new Random().NextBytes(sendData);
string path = GetRandomNonExistingFilePath();
server.Bind(new UnixDomainSocketEndPoint(path));
server.Listen(1);
Task<Socket> acceptTask = server.AcceptAsync();
client.Connect(new UnixDomainSocketEndPoint(path));
acceptTask.Wait();
Socket accepted = acceptTask.Result;
Task[] writes = new Task[Iters];
Task<int>[] reads = new Task<int>[Iters];
for (int i = 0; i < Iters; i++)
{
writes[i] = client.SendAsync(new ArraySegment<byte>(sendData, i, 1), SocketFlags.None);
}
for (int i = 0; i < Iters; i++)
{
reads[i] = accepted.ReceiveAsync(new ArraySegment<byte>(receiveData, i, 1), SocketFlags.None);
}
Task.WaitAll(writes);
Task.WaitAll(reads);
Assert.Equal(sendData, receiveData);
}
}
public async Task Socket_SendReceiveAsync_Success()
{
string path = GetRandomNonExistingFilePath();
var endPoint = new UnixDomainSocketEndPoint(path);
try
{
using (var server = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
using (var client = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
{
server.Bind(endPoint);
server.Listen(1);
await client.ConnectAsync(endPoint);
using (Socket accepted = await server.AcceptAsync())
{
var data = new byte[1];
for (int i = 0; i < 10; i++)
{
data[0] = (byte)i;
await accepted.SendAsync(new ArraySegment<byte>(data), SocketFlags.None);
data[0] = 0;
Assert.Equal(1, await client.ReceiveAsync(new ArraySegment<byte>(data), SocketFlags.None));
Assert.Equal(i, data[0]);
}
}
}
}
finally
{
try { File.Delete(path); }
catch { }
}
}
private void DualModeConnect_AcceptAsync_Helper(IPAddress listenOn, IPAddress connectTo)
{
using (Socket serverSocket = new Socket(SocketType.Stream, ProtocolType.Tcp))
{
int port = serverSocket.BindToAnonymousPort(listenOn);
serverSocket.Listen(1);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += AsyncCompleted;
ManualResetEvent waitHandle = new ManualResetEvent(false);
args.UserToken = waitHandle;
_log.WriteLine(args.GetHashCode() + " SocketAsyncEventArgs with manual event " + waitHandle.GetHashCode());
serverSocket.AcceptAsync(args);
SocketClient client = new SocketClient(serverSocket, connectTo, port);
Assert.True(waitHandle.WaitOne(Configuration.PassingTestTimeout), "Timed out while waiting for connection");
if (args.SocketError != SocketError.Success)
{
throw new SocketException((int)args.SocketError);
}
Socket clientSocket = args.AcceptSocket;
Assert.NotNull(clientSocket);
Assert.True(clientSocket.Connected);
Assert.True(clientSocket.DualMode);
Assert.Equal(AddressFamily.InterNetworkV6, clientSocket.AddressFamily);
Assert.Equal(connectTo.MapToIPv6(), ((IPEndPoint)clientSocket.LocalEndPoint).Address);
}
}
public void AcceptAsync_WithReceiveBuffer_Failure()
{
//
// Unix platforms don't yet support receiving data with AcceptAsync.
//
Assert.True(Capability.IPv4Support());
using (Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
int port = server.BindToAnonymousPort(IPAddress.Loopback);
server.Listen(1);
SocketAsyncEventArgs acceptArgs = new SocketAsyncEventArgs();
acceptArgs.Completed += OnAcceptCompleted;
acceptArgs.UserToken = new ManualResetEvent(false);
byte[] buffer = new byte[1024];
acceptArgs.SetBuffer(buffer, 0, buffer.Length);
Assert.Throws<PlatformNotSupportedException>(() => server.AcceptAsync(acceptArgs));
}
}
public void Success()
{
AutoResetEvent completed = new AutoResetEvent(false);
if (Socket.OSSupportsIPv4)
{
using (Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
int port = sock.BindToAnonymousPort(IPAddress.Loopback);
sock.Listen(1);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += OnAcceptCompleted;
args.UserToken = completed;
// Not expecting the operation to finish synchronously as no client should be trying to connect.
Assert.True(sock.AcceptAsync(args));
_log.WriteLine("IPv4 Server: Waiting for clients.");
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
client.Connect(new IPEndPoint(IPAddress.Loopback, port));
_log.WriteLine("IPv4 Client: Connecting.");
Assert.True(completed.WaitOne(Configuration.PassingTestTimeout), "IPv4: Timed out while waiting for connection");
Assert.Equal<SocketError>(SocketError.Success, args.SocketError);
Assert.NotNull(args.AcceptSocket);
Assert.True(args.AcceptSocket.Connected, "IPv4 Accept Socket was not connected");
client.Dispose();
}
}
if (Socket.OSSupportsIPv6)
{
using (Socket sock = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
{
int port = sock.BindToAnonymousPort(IPAddress.IPv6Loopback);
sock.Listen(1);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += OnAcceptCompleted;
args.UserToken = completed;
Assert.True(sock.AcceptAsync(args));
_log.WriteLine("IPv6 Server: Waiting for clients.");
Socket client = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
client.Connect(new IPEndPoint(IPAddress.IPv6Loopback, port));
_log.WriteLine("IPv6 Client: Connecting.");
Assert.True(completed.WaitOne(Configuration.PassingTestTimeout), "IPv6: Timed out while waiting for connection");
Assert.Equal<SocketError>(SocketError.Success, args.SocketError);
Assert.NotNull(args.AcceptSocket);
Assert.True(args.AcceptSocket.Connected, "IPv6 Accept Socket was not connected");
//Assert.NotNull(args.AcceptSocket.m_RightEndPoint, "m_RightEndPoint was not set");
//Assert.Equal(client.LocalEndPoint, args.AcceptSocket.m_RemoteEndPoint, "m_RemoteEndPoint is wrong!");
client.Dispose();
}
}
}
public async Task Socket_Connect_IPv4AddressAsStringHost_Supported()
{
using (Socket host = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
host.Bind(new IPEndPoint(IPAddress.Loopback, 0));
host.Listen(1);
Task accept = host.AcceptAsync();
using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
s.Connect(IPAddress.Loopback.ToString(), ((IPEndPoint)host.LocalEndPoint).Port);
}
await accept;
}
}
public void SelectWrite_Multiple_Timeout()
{
using (var firstListener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
using (var secondListener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
firstListener.BindToAnonymousPort(IPAddress.Loopback);
firstListener.Listen(1);
firstListener.AcceptAsync();
secondListener.BindToAnonymousPort(IPAddress.Loopback);
secondListener.Listen(1);
secondListener.AcceptAsync();
var list = new List<Socket> { firstListener, secondListener };
Socket.Select(null, list, null, SelectTimeout);
Assert.Equal(0, list.Count);
}
}
private static KeyValuePair<Socket, Socket> CreateConnectedSockets()
{
using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
listener.LingerState = new LingerOption(true, 0);
listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
listener.Listen(1);
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
client.LingerState = new LingerOption(true, 0);
Task<Socket> acceptTask = listener.AcceptAsync();
client.Connect(listener.LocalEndPoint);
Socket server = acceptTask.GetAwaiter().GetResult();
return new KeyValuePair<Socket, Socket>(client, server);
}
}
private void DualModeConnect_AcceptAsync_Helper(IPAddress listenOn, IPAddress connectTo)
{
using (Socket serverSocket = new Socket(SocketType.Stream, ProtocolType.Tcp))
{
int port = serverSocket.BindToAnonymousPort(listenOn);
serverSocket.Listen(1);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed += AsyncCompleted;
ManualResetEvent waitHandle = new ManualResetEvent(false);
args.UserToken = waitHandle;
args.SocketError = SocketError.SocketError;
_log.WriteLine(args.GetHashCode() + " SocketAsyncEventArgs with manual event " + waitHandle.GetHashCode());
if (!serverSocket.AcceptAsync(args))
{
throw new SocketException((int)args.SocketError);
}
SocketClient client = new SocketClient(_log, serverSocket, connectTo, port);
var waitHandles = new WaitHandle[2];
waitHandles[0] = waitHandle;
waitHandles[1] = client.WaitHandle;
int completedHandle = WaitHandle.WaitAny(waitHandles, Configuration.PassingTestTimeout);
if (completedHandle == WaitHandle.WaitTimeout)
{
throw new TimeoutException("Timed out while waiting for either of client and server connections...");
}
if (completedHandle == 1) // Client finished
{
if (client.Error != SocketError.Success)
{
// Client SocketException
throw new SocketException((int)client.Error);
}
if (!waitHandle.WaitOne(5000)) // Now wait for the server.
{
throw new TimeoutException("Timed out while waiting for the server accept...");
}
}
_log.WriteLine(args.SocketError.ToString());
if (args.SocketError != SocketError.Success)
{
throw new SocketException((int)args.SocketError);
}
Socket clientSocket = args.AcceptSocket;
Assert.NotNull(clientSocket);
Assert.True(clientSocket.Connected);
AssertDualModeEnabled(clientSocket, listenOn);
Assert.Equal(AddressFamily.InterNetworkV6, clientSocket.AddressFamily);
if (connectTo == IPAddress.Loopback)
{
Assert.Contains(((IPEndPoint)clientSocket.LocalEndPoint).Address, ValidIPv6Loopbacks);
}
else
{
Assert.Equal(connectTo.MapToIPv6(), ((IPEndPoint)clientSocket.LocalEndPoint).Address);
}
clientSocket.Dispose();
}
}
public async Task Socket_ConnectAsync_IPv6AddressAsStringHost_Supported()
{
using (Socket host = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
{
host.Bind(new IPEndPoint(IPAddress.IPv6Loopback, 0));
host.Listen(1);
using (Socket s = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
{
await Task.WhenAll(
host.AcceptAsync(),
s.ConnectAsync(IPAddress.IPv6Loopback.ToString(), ((IPEndPoint)host.LocalEndPoint).Port));
}
}
}