public void Start()
{
_tcpListener.Start();
_tcpListener.AcceptSocketAsync().ContinueWith(OnTcpSocketAccept);
_streamCopier.Start();
}
public static async Task RunAsync(IMvcApplication application, int port)
{
ServerRoutingTable = new ServerRoutingTable();
IServiceCollection serviceCollection = new ServiceCollection();
application.ConfigureServices(serviceCollection);
application.Configure(ServerRoutingTable);
ServerRoutingTable
.LoadControllers(application.GetType().Assembly, serviceCollection)
.LoadStaticFiles();
Console.WriteLine(string.Join(Environment.NewLine, ServerRoutingTable.GetAllRouteNames()));
TcpListener listener = new TcpListener(IPAddress.Parse(LocalhostIpAddress), port);
listener.Start();
IsRunning = true;
Console.WriteLine($"Server started at http://{LocalhostIpAddress}:{port}");
while (IsRunning)
{
Console.WriteLine("Waiting for client...");
var client = await listener.AcceptSocketAsync();
ListenAsync(client);
}
}
private Task <Socket> Accept()
{
if (tcpListener == null)
{
///同时支持IPv4和IPv6
tcpListener = TcpListener.Create(ConnectIPEndPoint.Port);
tcpListener.AllowNatTraversal(true);
}
tcpListener.Start();
Socket remoteSocket = null;
try
{
///此处有远程连接拒绝异常
return(tcpListener.AcceptSocketAsync());
}
catch (InvalidOperationException e)
{
Console.WriteLine(e);
///出现异常重新开始监听
tcpListener = null;
return(Accept());
}
}
private async Task ListenLoop()
{
while (true)
{
Socket socket;
try
{
socket = await _tcpListener.AcceptSocketAsync().ConfigureAwait(false);
}
catch
{
socket = null;
}
if (socket == null)
{
break;
}
var client = new MLLPClient(socket);
if (!_clients.TryAdd(client.Id, client))
{
//duplicated id
client.Disconnect();
continue;
}
}
}
public async Task Run(Settings settings)
{
Settings = settings;
var local = settings.Local;
var listener = new TcpListener(local.Listen, local.Port);
listener.Start();
var pairIdSeed = 0;
while (true)
{
var client = await listener.AcceptSocketAsync();
var pairId = Interlocked.Increment(ref pairIdSeed);
_ = Task.Run(async() =>
{
var command = Negotiate(client);
if (command != null)
{
var cmd = command.Value;
await SendMessageAsync($"+E {pairId} {cmd.act} {cmd.addr}");
EndPointStation.AddEndPoint(pairId, client);
}
});
}
}
internal override async ValueTask <QuicConnectionProvider> AcceptConnectionAsync(CancellationToken cancellationToken = default)
{
CheckDisposed();
Socket socket = await _tcpListener.AcceptSocketAsync().ConfigureAwait(false);
socket.NoDelay = true;
// Read first 4 bytes to get client listen port
byte[] buffer = new byte[4];
int bytesRead = 0;
do
{
bytesRead += await socket.ReceiveAsync(buffer.AsMemory().Slice(bytesRead), SocketFlags.None).ConfigureAwait(false);
} while (bytesRead != buffer.Length);
int peerListenPort = BinaryPrimitives.ReadInt32LittleEndian(buffer);
IPEndPoint peerListenEndPoint = new IPEndPoint(((IPEndPoint)socket.RemoteEndPoint !).Address, peerListenPort);
// Listen on a new local endpoint for inbound streams
TcpListener inboundListener = new TcpListener(_listenEndPoint.Address, 0);
inboundListener.Start();
int inboundListenPort = ((IPEndPoint)inboundListener.LocalEndpoint).Port;
// Write inbound listen port to socket so client can read it
BinaryPrimitives.WriteInt32LittleEndian(buffer, inboundListenPort);
await socket.SendAsync(buffer, SocketFlags.None).ConfigureAwait(false);
return(new MockConnection(socket, peerListenEndPoint, inboundListener));
}
public void Start()
{
_isRunning = true;
_server = new TcpListener(IPAddress.Any, Port);
Task.Run(async() =>
{
try
{
_server.Start();
_logger.Info("Server: {0} started listening port: {1}", _name, Port);
while (_isRunning)
{
var client = await _server.AcceptSocketAsync();
OnClientConnected(client);
}
}
catch (Exception ex)
{
_logger.Error(ex);
}
finally
{
if (_isRunning == true)
{
_isRunning = false;
_server.Stop();
}
}
});
}
public void Start()
{
informationMessage = "Beginne";
IP4s = GetLocalIpAdresse();
IP4 = IPAddress.Parse(IP4s);
IPE = new IPEndPoint(IP4, port);
listener = new TcpListener(IPE);
appserver[0] = Task.Run(async() =>
{
informationMessage = "Verbindungssuche.";
try
{
listener.Start();
connectionSocket = await listener.AcceptSocketAsync();
informationMessage = "Connected";
networkStream = new NetworkStream(connectionSocket);
}
catch (SocketException)
{
informationMessage = "WTF";
listener.Stop();
Start();
}
}
).ContinueWith((appservice) => Receive());
}
public async Task Accept_StartAfterStop_AcceptsSuccessfully()
{
var listener = new TcpListener(IPAddress.Loopback, 0);
listener.Start();
await VerifyAccept(listener);
listener.Stop();
Assert.NotNull(listener.Server);
listener.Start();
Assert.NotNull(listener.Server);
await VerifyAccept(listener);
listener.Stop();
async Task VerifyAccept(TcpListener listener)
{
using var client = new TcpClient();
Task connectTask = client.ConnectAsync(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndpoint).Port);
using Socket s = await listener.AcceptSocketAsync();
Assert.False(listener.Pending());
await connectTask;
}
}
private async Task DoListenForClients(object state, CancellationToken token)
{
TcpListener _server = (state as TcpListener);
while (!cancelListenToken.IsCancellationRequested)
{
logger.Info("Waiting for a connection... ");
// Perform a blocking call to accept requests.
Socket socket = await _server.AcceptSocketAsync().ConfigureAwait(false);
// Get ID
string id = GetIDFromSocket(socket);
// Create Framewrapper
var framewrapper = createFrameWrapperFunc();
// Create Communicator
CommunicatorBase <U> communicator = new IPSocketCommunicator <U>(socket, framewrapper);
// Add to dict
lock (lockerClientList)
ClientList.Add(id, communicator);
// Subscribe to events
communicator.ConnectionStateEvent += OnCommunicatorConnection;
communicator.DataReadySyncEvent += OnCommunicatorSyncData;
communicator.DataReadyAsyncEvent += OnCommunicatorAsyncData;
framewrapper.FrameAvailableEvent += OnFrameReady;
communicator.Init(null, false, id, 0);
communicator.Start();
}
}
private static IEnumerable <IObservable <Socket> > Listen(this TcpListener listener)
{
while (true)
{
yield return(listener.AcceptSocketAsync().ToObservable());
}
}
async void AcceptLoop()
{
try
{
while (true)
{
var socket = await listener.AcceptSocketAsync();
lock (clients)
{
logger.Info($"Accepted client {socket.RemoteEndPoint}");
if (acceptSingleClient && client?.Proto.IsConnected == true)
{
logger.Info($"Closing previous connection");
clients.Clear();
client.Proto.Dispose();
logger.Info($"Previous connection closed");
}
client = new Simulator {
Logic = new SimulatorLogic()
};
client.Proto = new SimulatorProtocol(client.Logic.HandleCommand);
clients.Add(client);
client.Proto.Accept(socket);
}
}
}
catch (Exception ex)
{
logger.Debug("SimulatorListener: " + ex);
}
}
internal override async ValueTask <QuicStreamProvider> AcceptStreamAsync(CancellationToken cancellationToken = default)
{
CheckDisposed();
Socket socket = await _inboundListener.AcceptSocketAsync().ConfigureAwait(false);
// Read first bytes to get stream ID
byte[] buffer = new byte[8];
int bytesRead = 0;
do
{
bytesRead += await socket.ReceiveAsync(buffer.AsMemory().Slice(bytesRead), SocketFlags.None).ConfigureAwait(false);
} while (bytesRead != buffer.Length);
long streamId = BinaryPrimitives.ReadInt64LittleEndian(buffer);
bool clientInitiated = ((streamId & 0b01) == 0);
if (clientInitiated == _isClient)
{
throw new Exception($"Wrong initiator on accepted stream??? streamId={streamId}, _isClient={_isClient}");
}
bool bidirectional = ((streamId & 0b10) == 0);
return(new MockStream(socket, streamId, bidirectional: bidirectional));
}
public async void StartHost()
{
if (Main == null)
{
throw new InvalidOperationException(" 'Main' was null!");
}
server.Start();
while (true)
{
var socket = await server.AcceptSocketAsync();
var session = new TelnetSession(this, socket);
_sessions.Add(session.ConnectionId, session);
var e = new SessionEventArgs(session); //todo: this client event can block the whole server
SessionConnected?.Invoke(this, e);
if (!e.RefuseConnection)
{
session.Run();
}
else
{
session.Kick();
}
}
}
/// <summary>
/// Listen tcp connections on any ip address.
/// </summary>
/// <returns>Task.</returns>
public async Task Listen()
{
var listener = new TcpListener(IPAddress.Any, this.port);
listener.Start();
Console.WriteLine($"Listening on {this.port} port");
while (true)
{
var socket = await listener.AcceptSocketAsync();
Task.Run(async() =>
{
try
{
await using var stream = new NetworkStream(socket);
await RequestHandler.Handle(stream);
}
finally
{
socket.Close();
}
});
}
}
static async Task AcceptWorkAsync()
{
try
{
while (true)
{
var socket = await _listener6022.AcceptSocketAsync();
_ = Task.Run(async delegate
{
LogMessage("Warning:accept server " + socket.LocalEndPoint + "," + socket.RemoteEndPoint);
try
{
socket.InitTcp();
await ProcesSocketAsync(socket);
}
catch (Exception x)
{
OnError(x);
}
finally
{
LogMessage("Warning:close server " + socket.LocalEndPoint + "," + socket.RemoteEndPoint);
socket.CloseSocket();
}
});
}
}
catch (Exception x)
{
OnError(x);
}
}
public async Task <AsyncSocketSession> GetConnectedSocket(IProcessor processor)
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
NoDelay = true,
LingerState = new LingerOption(true, 2)
};
var serverSocketAccept = listener.AcceptSocketAsync();
socket.Connect(new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndpoint).Port));
await serverSocketAccept;
var serverSocket = serverSocketAccept.Result;
var session = new AsyncSocketSession(Guid.NewGuid().ToString(),
socket,
processor,
SocketAwaitablePool,
BlockingBufferManager);
serverSocketsBySession.Add(session, serverSocket);
return(session);
}
private async Task ListenLoop()
{
bool running = !_exitListening;
while (running)
{
lock (_lock) {
if (_exitListening)
{
running = false;
}
}
if (_listener.Pending())
{
var socket = await _listener.AcceptSocketAsync();
ProcessClient(socket);
}
Thread.Sleep(50);
}
Console.WriteLine("> Stopped listening.");
_listener.Stop();
}
public void CheckAndAccept(object nothing)
{
while (listener != null && listener.Pending())
{
TcpRosAcceptConnection(new TcpTransport(listener.AcceptSocketAsync().Result, PollManager.Instance.poll_set));
}
}
private async void ProcessPing()
{
Console.Write("Waiting for a connection... ");
while (true)
{
Socket client = await pingListener.AcceptSocketAsync();
Console.WriteLine("Client connected from {0}", client.RemoteEndPoint.ToString());
// get a thread to handle the ping from the new client connection
var childSocketThread = new Thread(() =>
{
Console.WriteLine("In ping requests processing thread...");
byte[] data = new byte[100];
while (true)
{
try
{
int size = client.Receive(data);
OnPingReceived(client);
}
catch (Exception e)
{
Console.WriteLine("Remote peer disconnected.");
break;
}
}
Console.WriteLine("Exiting ping requests processing thread...");
});
childSocketThread.Start();
}
}
public async void AcceptPeersAsync()
{
Console.WriteLine("[Server] Waiting client connect...");
while (!cancellationTokenSource.IsCancellationRequested)
{
Socket socket;
try
{
socket = await listener.AcceptSocketAsync();
if (socket != null)
{
connections++;
}
Console.WriteLine("[Server] New Client Connection:{0} connected.", connections);
byte[] myBytes = Encoding.ASCII.GetBytes("[Server]Success to connect...");
socket.Send(myBytes);
TCPRemote remote = new TCPRemote(socket);
Thread thread = new Thread(remote.ReceiveMessage);
thread.Start();
}
catch (ObjectDisposedException)
{
break;
}
catch (SocketException)
{
continue;
}
}
}
private static async Task ListenConnect(IPAddress address)
{
TcpListener listener = new TcpListener(address, PORT_NUMBER);
listener.Start();
Console.WriteLine("Server started on " + listener.LocalEndpoint);
Console.WriteLine("Waiting for a connection...\n");
try
{
while (true)
{
Task <Socket> socket = listener.AcceptSocketAsync();
socket.Wait();
var Reader = new StreamReader(new NetworkStream(socket.Result));
User TmpUser = new User(await Reader.ReadLineAsync(), socket.Result);
ListUser.Add(TmpUser);
ReceiveMessage(TmpUser);
Console.WriteLine(String.Format("Connection received from {0}: {1}", socket.Result.RemoteEndPoint, TmpUser.GSName));
}
}
catch { listener.Stop(); }
}
private async Task AcceptPeers()
{
while (true)
{
Socket socket;
try
{
socket = await _listener.AcceptSocketAsync();
_logger.LogInformation($"\"{(socket.RemoteEndPoint as IPEndPoint)?.Address}\" is connected");
}
catch (ObjectDisposedException)
{
break;
}
catch (SocketException)
{
continue;
}
var peer = _peerFactory.CreateFrom(socket);
OnPeerConnected?.Invoke(this, peer);
}
}
public async void connectTcp()
{
tcpconnect = false;
Console.WriteLine("CONNECTING TCP");
while (!tcpconnect)
{
try
{
/* Initializes the Listener */
myList = new TcpListener(ip, 8001);
/* Start Listeneting at the specified port */
myList.Start();
Console.WriteLine("The server is running at port 8001...");
Console.WriteLine("The local End point is :" + myList.LocalEndpoint);
Console.WriteLine("...Waiting for a connection...");
s = await myList.AcceptSocketAsync();
Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);
tcpconnect = true;
}
catch (SocketException connectexcept)
{
Console.WriteLine("ERROR" + connectexcept.ToString());
}
}
//while(true) readTcp();
}
private async Task <string[]> ForwardRequestToIoTServer()
{
/* Initializes the Listener */
TcpListener tcpLis = new TcpListener(IPAddress.Any, 8001);
/* Start Listeneting at the specified port */
tcpLis.Start();
Socket s = await tcpLis.AcceptSocketAsync();
byte[] message = new byte[100];
int k = s.Receive(message);
ASCIIEncoding asen = new ASCIIEncoding();
var str = asen.GetString(message, 0, k);
string clientIP = "192.168.56.101"; //TODO
byte[] response = asen.GetBytes(clientIP);
s.Send(response);
k = s.Receive(message);
var port = asen.GetString(message, 0, k);
/* clean up */
s.Shutdown(SocketShutdown.Both);
tcpLis.Stop();
return(new string[] { port });
}
private Task <Socket> AcceptControlClient(List <Task> controlTasks)
{
var acceptControlClientTask = controlListener.AcceptSocketAsync();
controlTasks.Add(acceptControlClientTask);
return(acceptControlClientTask);
}
private async Task AcceptPeers()
{
#if !NET47
//There is a bug in .NET Core 2.0 that blocks async method which returns void.
await Task.Yield();
#endif
while (!cancellationTokenSource.IsCancellationRequested)
{
Socket socket;
try
{
socket = await listener.AcceptSocketAsync();
}
catch (ObjectDisposedException)
{
break;
}
catch (SocketException)
{
continue;
}
TcpRemoteNode remoteNode = new TcpRemoteNode(this, socket);
OnConnected(remoteNode);
}
}
/// <inheritdoc />
/// <param name="ipe">IP and Port for server to start</param>
/// <returns></returns>
public async Task StartAsync(IPEndPoint ipe)
{
// create server and put ip and port
_server = new TcpListener(ipe);
// init id from 0
_id = 0;
// start server
_server.Start();
// register stop method for cancellation token
_cancellationToken.Register(_server.Stop);
// while loop until server stopped
while (!_cancellationToken.IsCancellationRequested)
{
//safe for exceptions
try
{
// accept client connection
var client = await _server.AcceptSocketAsync().ConfigureAwait(false);
// create state object for receive data from tcp connection
var so = new StateObject(_id++.ToString(), client);
// if connected not null Invoke connected event args
Connected?.Invoke(this, new ConnectedEventArgs(so.Id));
// and start receive message
client.BeginReceive(so.Buffer, 0, StateObject.BufferSize, 0, Receive, so);
}
//if objecet is disposed and server stopeed give info
catch (ObjectDisposedException) when(_cancellationToken.IsCancellationRequested)
{
Logger.Info(Localization.Get("Comidat.Controller.Server.TCP.StartAsync.ObjectDisposedException"));
}
}
/// <summary>
/// Start accepting connections on <see cref="Socket"/>
/// </summary>
private async Task acceptAsync()
{
// indefinitely process new connections, until exception is thrown on AcceptSocketAsync() when the listener is stopped
while (true)
{
Socket socket;
try {
// wait for new connection
socket = await _listener.AcceptSocketAsync()
.ConfigureAwait(false); // to avoid deadlock, continue the execution on any free thread at the time
} catch (Exception ex) {
// report error only when the exception is not intentional
if (!_terminationSwitch)
{
// invoke the client handler to process the error in the implementation
ServerHandler?.OnAcceptError(ex);
}
// exception on AcceptSocketAsync means there is an error with the listener itself, so must terminate
break;
}
// invoke the connection handler to process the socket connection in implementation
ServerHandler?.OnSocketAccepted(socket);
}
}
private async Task CaptureModulesAsync(TcpListener listener)
{
try
{
HNode moduleNode = new HNode(await listener.AcceptSocketAsync());
moduleNode.InFormat = HFormat.EvaWire;
moduleNode.OutFormat = HFormat.EvaWire;
HPacket infoPacket = await moduleNode.ReceivePacketAsync();
var module = new ModuleInfo(moduleNode);
module.PropertyChanged += Module_PropertyChanged;
module.Version = Version.Parse(infoPacket.ReadUTF8());
module.Name = infoPacket.ReadUTF8();
module.Description = infoPacket.ReadUTF8();
module.Authors.Capacity = infoPacket.ReadInt32();
for (int i = 0; i < module.Authors.Capacity; i++)
{
module.Authors.Add(new AuthorAttribute(infoPacket.ReadUTF8()));
}
Modules.Add(module);
module.Initialize();
Task handleModuleDataTask = HandleModuleDataAsync(module);
}
finally { Task captureModulesAsync = CaptureModulesAsync(listener); }
}
public void SendRecvPollSync_TcpListener_Socket(IPAddress listenAt, bool pollBeforeOperation)
{
const int BytesToSend = 123456;
const int ListenBacklog = 1;
const int TestTimeout = 30000;
var listener = new TcpListener(listenAt, 0);
listener.Start(ListenBacklog);
try
{
int bytesReceived = 0;
var receivedChecksum = new Fletcher32();
Task serverTask = Task.Run(async () =>
{
using (Socket remote = await listener.AcceptSocketAsync())
{
var recvBuffer = new byte[256];
while (true)
{
if (pollBeforeOperation)
{
Assert.True(remote.Poll(-1, SelectMode.SelectRead), "Read poll before completion should have succeeded");
}
int received = remote.Receive(recvBuffer, 0, recvBuffer.Length, SocketFlags.None);
if (received == 0)
{
Assert.True(remote.Poll(0, SelectMode.SelectRead), "Read poll after completion should have succeeded");
break;
}
bytesReceived += received;
receivedChecksum.Add(recvBuffer, 0, received);
}
}
});
int bytesSent = 0;
var sentChecksum = new Fletcher32();
Task clientTask = Task.Run(async () =>
{
var clientEndpoint = (IPEndPoint)listener.LocalEndpoint;
using (var client = new Socket(clientEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
{
await client.ConnectAsync(clientEndpoint.Address, clientEndpoint.Port);
if (pollBeforeOperation)
{
Assert.False(client.Poll(TestTimeout, SelectMode.SelectRead), "Expected writer's read poll to fail after timeout");
}
var random = new Random();
var sendBuffer = new byte[512];
for (int remaining = BytesToSend, sent = 0; remaining > 0; remaining -= sent)
{
random.NextBytes(sendBuffer);
if (pollBeforeOperation)
{
Assert.True(client.Poll(-1, SelectMode.SelectWrite), "Write poll should have succeeded");
}
sent = client.Send(sendBuffer, 0, Math.Min(sendBuffer.Length, remaining), SocketFlags.None);
bytesSent += sent;
sentChecksum.Add(sendBuffer, 0, sent);
}
}
});
Assert.True(Task.WaitAll(new[] { serverTask, clientTask }, TestTimeout), "Wait timed out");
Assert.Equal(bytesSent, bytesReceived);
Assert.Equal(sentChecksum.Sum, receivedChecksum.Sum);
}
finally
{
listener.Stop();
}
}
