public void RemoteEndPoint()
{
CompletionPort completionPort = CompletionPort.Create();
var listenSocket = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(listenSocket, null);
listenSocket.Bind(IPAddress.Any, 0);
int port = listenSocket.LocalEndPoint.Port;
listenSocket.Listen(1);
listenSocket.Accept();
var clientSocket = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(clientSocket, null);
clientSocket.Bind(IPAddress.Any, 0);
clientSocket.Connect("localhost", port);
CompletionStatus completionStatus;
bool accepted = false;
bool connected = false;
while (!accepted || !connected)
{
completionPort.GetQueuedCompletionStatus(-1, out completionStatus);
if (completionStatus.AsyncSocket == clientSocket && !connected)
{
Assert.AreEqual(OperationType.Connect, completionStatus.OperationType);
Assert.AreEqual(SocketError.Success, completionStatus.SocketError);
connected = true;
}
else if (completionStatus.AsyncSocket == listenSocket && !accepted)
{
Assert.AreEqual(OperationType.Accept, completionStatus.OperationType);
Assert.AreEqual(SocketError.Success, completionStatus.SocketError);
accepted = true;
}
else
{
Assert.Fail();
}
}
var server = listenSocket.GetAcceptedSocket();
Assert.AreEqual(clientSocket.LocalEndPoint, server.RemoteEndPoint);
Assert.AreEqual(clientSocket.RemoteEndPoint, server.LocalEndPoint);
completionPort.Dispose();
listenSocket.Dispose();
server.Dispose();
clientSocket.Dispose();
}
private void Loop()
{
CompletionStatus completionStatus;
while (!m_stopping)
{
// Execute any due timers.
int timeout = ExecuteTimers();
if (m_completionPort.GetQueuedCompletionStatus(timeout != 0 ? timeout * 1000 : -1, out completionStatus))
{
if (completionStatus.OperationType == OperationType.Signal)
{
IOThreadMailbox mailbox = (IOThreadMailbox)completionStatus.State;
mailbox.RaiseEvent();
}
// if the state is null we just ignore the completion status
else if (completionStatus.State != null)
{
Item item = (Item)completionStatus.State;
if (!item.Cancelled)
{
try
{
switch (completionStatus.OperationType)
{
case OperationType.Accept:
case OperationType.Receive:
item.ProcatorEvents.InCompleted(completionStatus.SocketError,
completionStatus.BytesTransferred);
break;
case OperationType.Connect:
case OperationType.Disconnect:
case OperationType.Send:
item.ProcatorEvents.OutCompleted(completionStatus.SocketError,
completionStatus.BytesTransferred);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
catch (TerminatingException)
{
}
}
}
}
}
}
public static void Main(string[] args)
{
CompletionPort completionPort = CompletionPort.Create();
AutoResetEvent listenerEvent = new AutoResetEvent(false);
AutoResetEvent clientEvent = new AutoResetEvent(false);
AutoResetEvent serverEvent = new AutoResetEvent(false);
AsyncSocket listener = AsyncSocket.Create(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
completionPort.AssociateSocket(listener, listenerEvent);
AsyncSocket server = AsyncSocket.Create(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
completionPort.AssociateSocket(server, serverEvent);
AsyncSocket client = AsyncSocket.Create(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
completionPort.AssociateSocket(client, clientEvent);
Task.Factory.StartNew(() =>
{
CompletionStatus completionStatus;
while (true)
{
var result = completionPort.GetQueuedCompletionStatus(-1, out completionStatus);
if (result)
{
Console.WriteLine("{0} {1} {2}", completionStatus.SocketError,
completionStatus.OperationType, completionStatus.BytesTransferred);
if (completionStatus.State != null)
{
AutoResetEvent resetEvent = (AutoResetEvent)completionStatus.State;
resetEvent.Set();
}
}
}
});
listener.Bind(IPAddress.Any, 5555);
listener.Listen(1);
client.Connect("localhost", 5555);
listener.Accept(server);
listenerEvent.WaitOne();
clientEvent.WaitOne();
byte[] sendBuffer = new byte[1] {
2
};
byte[] recvBuffer = new byte[1];
client.Send(sendBuffer);
server.Receive(recvBuffer);
clientEvent.WaitOne();
serverEvent.WaitOne();
server.Dispose();
client.Dispose();
Console.ReadLine();
}
