public void ProcessIncomingConnection( )
{
while (true)
{
try
{
TcpClient client = Listener.AcceptTcpClient( );
client.GetStream( );
SslStream stream = new SslStream(
client.GetStream( ),
false);
stream.AuthenticateAsServer(ServerCertificate,
false,
SslProtocols.Tls,
true);
Clients.Add(new StreamManager(stream));
}
catch (ThreadAbortException)
{
}
}
}
/// <summary>
/// Returns the Packet of data sent by a TcpClient
/// </summary>
/// <param name="serverData">Returns the ServerData object if the packet was a ServerDataPacket</param>
/// <returns>The Packet sent</returns>
IDataPacket ListenForPackets(out Data data)
{
Logger.Instance.Log("Waiting for a connection");
var client = Listener.AcceptTcpClient();
Logger.Instance.Log("Connected");
byte[] bytes = new byte[Packet.MAX_BYTE_LENGTH];
IDataPacket packet = null;
if (client.GetStream().Read(bytes, 0, bytes.Length) != 0)
{
packet = Packet.ToPacket(bytes);
}
data = new Data {
TcpClient = client
};
if (packet is ServerDataPacket)
{
var sPacket = (ServerDataPacket)packet;
data = new Data(ConnectedClients.Count == 0 ? 0 : ConnectedClients.Last().ID + 1)
{
TcpClient = client, IPv4 = sPacket.IPv4, Name = sPacket.Name, Port = sPacket.Port
};
ConnectedClients.Add(data);
Logger.Instance.Log($"Server @ {data.IPv4} added to collection");
}
return(packet);
}
public async void Start()
{
await Task.Run(() => {
Listener.Start();
while (true)
{
_main.WriteConsole("In attesa di connessione...");
//qui il listener inizia ad ascoltare, il metodo Accept è bloccante e attende l'arrivo di una richiesta di connessione tcp
//e accettandola crea un oggetto tcp client
TcpClient client = Listener.AcceptTcpClient();
string tmp = "client" + (ClientConnessi.Count + 1);
//qui invece facco partire un metodo in async che ascolta sul singolo client
ListenToTheStereo(client);
//aggiungo il client alla lista di client connessi
ClientConnessi.Add(tmp, client);
//aggiorno l'elenco sulla finestra
_main.AggiornaClientView();
//scrivo un aggiornamento in modo testuale
_main.WriteConsole("nuova connessione con: " + client.Client.LocalEndPoint.ToString());
}
});
}
private async Task Listen()
{
try
{
Task CheckerTask = Task.CompletedTask;
while (!CancellationToken.IsCancellationRequested)
{
if (Clients.Count <= Configuration.MaximumNumberOfConnections && Listener.Pending())
{
var client = Listener.AcceptTcpClient();
var t = new T();
t.Init(client, this);
Clients.Add(t);
this.OnClientConnected(t);
}
else
{
if (CheckerTask.IsCompleted)
{
CheckerTask = Task.Run(() => CheckClients());
}
await Task.Delay(10, CancellationToken.Token);
}
}
}
catch (Exception ex)
{
OnError(ex);
}
}
void AcceptClients()
{
int Id = 0;
while (true)
{
try
{
TcpClient CurrentClient = Listener.AcceptTcpClient();
ClassToSend MSG = (ClassToSend)bf.Deserialize(CurrentClient.GetStream());
ClassToSend msg = new ClassToSend();
msg.Id = Id;
Users.Add(new ServerUser(Id++, MSG.Name, CurrentClient));
msg.Users = Users;
msg.Type = Type.LobbyUpdate;
foreach (var user in Users)
{
SendMessage(user, msg);
}
}
catch (Exception e)
{
Console.Write(e.Message);
}
}
}
public void AcceptClients(Action <object> callbackForReceiveData)
{
CallbackForReceiveData = callbackForReceiveData;
IsOpen = true;
Listener.Start();
ProcessClientsTasks.Add(Task.Run(() =>
{
try
{
while (IsOpen)
{
var client = Listener.AcceptTcpClient();
Clients.Add(client);
}
}
catch (System.Net.Sockets.SocketException ex)
{
}
}));
ProcessClientsTasks.Add(Task.Run(() =>
{
while (IsOpen)
{
if (Clients.Count > 0)
{
Receive();
}
}
}));
}
public void FindClients()
{
int[] curClientsId = new int[5];
byte[] data = new byte[Constants.SIZE_OF_BYTES_NULL];
StartListener();
while (CheckEveryoneIsFound(curClientsId) == false)
{
//Get connected
Console.WriteLine("Waiting for a connection...");
TcpClient newClient = Listener.AcceptTcpClient();
NetworkStream newStream = newClient.GetStream();
Console.WriteLine("Connected");
int newClientId = GetDataFromClient(0, newStream)[0];
//Who and what?
Tuple <int, int> correctIdRepeate = GetCorrectIdForClient_GetRepeate(newClientId);
data[0] = Constants.ID_SERVER;
data[1] = Convert.ToByte(correctIdRepeate.Item1);
curClientsId[correctIdRepeate.Item1] = 1;
Clients[correctIdRepeate.Item1] = newClient;
Streams[correctIdRepeate.Item1] = newStream;
//Send reply
SendDataToCLient(data, 0, newStream);
}
Console.WriteLine("First connection is done.");
Console.WriteLine("GameType: " + Constants.GAMETYPE_MESS[GameType]);
}
public void AcceptConnections()
{
while (true)
{
Honeypots.Add(Listener.AcceptTcpClient());
Console.WriteLine("Client " + IPAddress.Parse(((IPEndPoint)Honeypots.Last().Client.RemoteEndPoint).Address.ToString()) + " has connected!");
}
}
/// <summary>
/// Beginnt auf dem Port zu lauschen
/// Wird nebenläufig ausgeführt
/// </summary>
private void Run()
{
// Client-Task
var clientTask = Task.Factory.StartNew(() =>
{
while (!ClientTokenSource.IsCancellationRequested)
{
TcpClient client = null;
lock (Queue)
{
client = Queue.Count > 0 ? Queue.Dequeue() : null;
}
if (client != null)
{
// Worker-Task
var workerTask = Task.Factory.StartNew(() =>
{
HandleClient(client);
});
}
else
{
Thread.Sleep(10);
}
}
}, ClientTokenSource.Token);
// Server-Task
while (!ServerTokenSource.IsCancellationRequested)
{
if (Listener == null)
{
break;
}
try
{
var client = Listener.AcceptTcpClient();
lock (Queue)
{
if (Queue.Count < ConnectionLimit)
{
Queue.Enqueue(client);
}
else
{
client.Close();
}
}
}
catch
{
}
}
}
private void ClientListenLoop()
{
Listener.Start();
while (true)
{
RemoteClient client = new RemoteClient(Listener.AcceptTcpClient());
Clients.AddClient(client);
}
}
public void Update_Client()
{
if (IsClientConnected)
{
return; // Make sure no other client is already connected
}
Client = Listener.AcceptTcpClient(); // Accept the TCP request
Stream = Client.GetStream(); // Get the network stream of the client
}
/// <summary>
/// Waits for connections any makes a new delegate for each client
/// </summary>
protected override void AcceptConnetion()
{
while (true)
{
TcpClient client = Listener.AcceptTcpClient();
stream = client.GetStream();
DataTransmissionDelegate transmissionDelegate = new DataTransmissionDelegate(BeginDataTransmission);
transmissionDelegate.BeginInvoke(stream, TransmissionCallback, client);
}
}
Data AcceptClient()
{
Logger.Instance.Log("Waiting for a connection");
var client = Listener.AcceptTcpClient();
//Logger.Instance.Log("Server Connected");
return(new Data {
TcpClient = client
});
}
public void HandleListen()
{
acceptingTask = Task.Factory.StartNew(
() => {
while (true)
{
TcpClient client = Listener.AcceptTcpClient();
mClientQueue.Enqueue(client);
}
}
);
}
protected override void AcceptClient()
{
while (true)
{
TcpClient tcpClient = Listener.AcceptTcpClient();
Stream = tcpClient.GetStream();
TransmissionDataDelegate transmissionDelegate = new TransmissionDataDelegate(BeginDataTransmission);
transmissionDelegate.BeginInvoke(Stream, TransmissionCallback, tcpClient);
}
}
public void GetNewConnection()
{
while (true)
{
TcpClient client = Listener.AcceptTcpClient();
ClientElement element = new ClientElement(client, this);
Clients.Add(element);
OnNewConnectionCreated(this, new ClientConnectedEventArgs()
{
ConnectedClient = client
});
}
}
/// <summary>
///
/// </summary>
/// <remarks>Not Thread safe! draait niet in main thread</remarks>
private void ListenForClients()
{
try
{
Listener.Start();
}
catch (Exception ex)
{
OnListenerError(new ListenerErrorEventArgs(ex));
}
while (Listening)
{
TcpClient CL = null;
try
{
CL = Listener.AcceptTcpClient();
if (Listening == false)
{
return;
}
}
catch (SocketException se)
{
switch (se.SocketErrorCode)
{
case SocketError.Interrupted:
if (Listening == false)
{
return;
}
break;
}
OnListenerError(new ListenerErrorEventArgs(se));
}
catch (Exception ex)
{
OnListenerError(new ListenerErrorEventArgs(ex));
Listening = false;
}
if (CL != null)
{
OnClientConnected(new ClientConnectedEventArgs(CL));
}
CL = null;
}
}
private void ReceiveThreadFunction()
{
try
{
// Start listening for client requests.
Listener.Start();
// Buffer for reading data
byte[] bytes = new byte[256];
// Enter the listening loop.
while (true)
{
// Perform a blocking call to accept requests.
var client = Listener.AcceptTcpClient();
// Get a stream object for reading and writing
var stream = client.GetStream();
int count = stream.Read(bytes, 0, bytes.Length);
if (count != 0)
{
// Translate data bytes to a ASCII string.
string data = Encoding.ASCII.GetString(bytes, 0, count);
var parts = data.Split(':');
switch (parts[0])
{
case "+":
Regist(parts[1], int.Parse(parts[2]));
break;
case "-":
Regist(parts[1], int.Parse(parts[2]));
break;
}
}
client.Close();
}
}
catch (SocketException e)
{
Host.Logger.WriteLine("SocketException: {0}", e);
}
finally
{
Listener.Stop();
}
}
protected virtual void ListenOnNewClients()
{
Listener.Start();
while (true)
{
TcpClient connectedClient = Listener.AcceptTcpClient();
var client = HandleNewConnectedClient(connectedClient, connectedClient.GetStream());
Clients.Add(client);
OnClientConnected(new ClientConnectedEventArgs(client));
Log.Info("New client connected (IP: " + connectedClient.Client.RemoteEndPoint + ")");
}
}
private void AcceptClients()
{
try
{
Listener.Start();
while (Running)
{
ProcessClient(Listener.AcceptTcpClient());
}
}
catch
{
//nothing
}
}
public Task StartAsync()
{
Listener.Start();
return(Task.Run(() =>
{
while (true)
{
var client = Listener.AcceptTcpClient();
var remote = ((IPEndPoint)client.Client.RemoteEndPoint).ToString();
Console.WriteLine("Client connected: " + remote);
var connection = new TcpConnection(client, remote);
Connections.Add(connection);
}
}));
}
protected override void ListenOnNewClients()
{
Listener.Start();
while (true)
{
TcpClient connectedClient = Listener.AcceptTcpClient();
var sslStream = ProcessClient(connectedClient);
var client = HandleNewConnectedClient(connectedClient, sslStream);
Clients.Add(client);
OnClientConnected(new ClientConnectedEventArgs(client));
Log.Info("New Client connected (IP: " + connectedClient.Client.RemoteEndPoint + ")");
}
}
/// <summary>
/// Accepts pending client connections and begins listening for packets on each accepted client.
/// </summary>
private void Accept()
{
running = true;
if (StartedEvent != null)
{
StartedEvent(this);
}
while (Status)
{
if (!Listener.Pending())
{
continue;
}
TcpClientHandler client = (ClientCreatedEvent != null) ? ClientCreatedEvent(Binder, this, ClientTimeout) : new TcpClientHandler(Binder, this, ClientTimeout);
client.Receiver = Listener.AcceptTcpClient();
client.Connected = true;
if ((ClientMap.Count <= MaxConnections && MaxConnections >= 0) || MaxConnections <= 0)
{
TcpClient receiver = client.Receiver;
receiver.LingerState = new LingerOption(false, 0);
receiver.NoDelay = true;
client.Stream = receiver.GetStream();
ClientMap.Add(client.Socket, client);
ThreadPool.QueueUserWorkItem(thread => Handle(client));
}
else
{
if (ClientOverflowEvent != null)
{
ThreadPool.QueueUserWorkItem(thread => ClientOverflowEvent(client));
}
client.Close();
}
}
if (ClosedEvent != null)
{
ClosedEvent(this);
}
running = false;
Close();
}
private void Listening()
{
IsListening = true;
while (IsListening && Listener != null)
{
bool pending = false;
try
{
pending = Listener.Pending();
}
catch
{
pending = false;
}
if (pending)
{
TcpClient client = null;
try
{
client = Listener.AcceptTcpClient();
}
catch
{
break;
}
if (client != null)
{
ConnectedClient newClient = new ConnectedClient(client);
Clients.Add(newClient);
newClient.StartListening();
newClient.OnNewResponseFromClient += newClient_OnNewResponseFromClient;
}
}
// detecter les déco :
List <ConnectedClient> clients2BeRemoved = new List <ConnectedClient>(Clients.Where(x => !x.TcpClient.Connected).ToList());
foreach (ConnectedClient client in clients2BeRemoved)
{
Clients.Remove(client);
}
}
}
public async void Start()
{
await Task.Run(() => {
Listener.Start();
while (true)
{
_main.WriteConsole("In attesa di connessione...");
//waiting for connection
TcpClient client = Listener.AcceptTcpClient();
string tmp = "client" + (ClientConnessi.Count + 1);
ClientConnessi.Add(tmp, client);
_main.WriteConsole("nuova connessione con: " + client.Client.LocalEndPoint.ToString());
}
});
}
//public void AcceptTelnetConnection()
//{
// while (true)
// {
// TcpClient client = null;
// client = TelnetListener.AcceptTcpClient();
// try
// {
// client.Client.Send(ASCIIEncoding.ASCII.GetBytes("Welcome to my Telnet!\n")); // let the attacker think there's a telnet service open on port 23.
// }
// catch (Exception)
// {
// continue;
// }
// TelnetClients.Add(client);
// Console.WriteLine("Telnet Client " + ((IPEndPoint)TelnetClients.Last().Client.RemoteEndPoint).Address.ToString() + " has connected!");
// }
//}
public void AcceptConnections()
{
while (true)
{
TcpClient client = null;
client = Listener.AcceptTcpClient();
try
{
client.Client.Send(ASCIIEncoding.ASCII.GetBytes("Please enter your password: "******"Client " + ((IPEndPoint)Clients.Last().Client.RemoteEndPoint).Address.ToString() + " has connected!");
}
}
private TcpClient BeginRunServer(TcpClient tcpClient)
{
if (tcpClient is null)
{
return(null);
}
else if (!tcpClient.Connected)
{
tcpClient = Listener.AcceptTcpClient();
RunServerDelegate serverDelegate = new RunServerDelegate(BeginRunServer);
serverDelegate.BeginInvoke(new TcpClient(), RunServerCallback, new object[] { serverDelegate });
this.EndPointHistory.Add(new Tuple <IPAddress, DateTime, bool>(((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address, DateTime.Now, true));
Console.WriteLine("Połączenie: \t" + ((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address.ToString() + " : " + DateTime.Now.ToString());
}
NetworkStream str = tcpClient.GetStream();
byte[] buffer = new byte[BufferSize];
string message = String.Empty;
try
{
str.Read(buffer, 0, BufferSize);
message = Encoding.ASCII.GetString(buffer).Trim().Replace("\0", String.Empty);
int number = int.Parse(message);
string silnia = this.Silnia(number).ToString();
str.Write(Encoding.ASCII.GetBytes(silnia), 0, silnia.Length);
}
catch (IOException)
{ }
catch (FormatException formatEx)
{
if (message.Trim() == "q")
{
this.EndPointHistory.Add(new Tuple <IPAddress, DateTime, bool>(((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address, DateTime.Now, true));
Console.WriteLine("Rozłączenie: \t" + ((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address.ToString() + " : " + DateTime.Now.ToString());
tcpClient.Close();
}
}
return(tcpClient);
}
private void HandleConnections()
{
IsRunning = true;
while (IsRunning)
{
if (Listener == null)
{
break;
}
TcpClient tcp = Listener.AcceptTcpClient();
Task.Factory.StartNew(() =>
{
AcceptClient(tcp);
});
}
Stop();
}
private void ReceiveThreadFunction()
{
try
{
Listener.Start();
byte[] bytes = new byte[256];
while (true)
{
var client = Listener.AcceptTcpClient();
var stream = client.GetStream();
int count = stream.Read(bytes, 0, bytes.Length);
if (count != 0)
{
string data = Encoding.ASCII.GetString(bytes, 0, count);
var parts = data.Split(':');
switch (parts[0])
{
case "+":
Regist(parts[1], int.Parse(parts[2]), int.Parse(parts[3]), parts[4]);
break;
case "-":
Unregist(parts[1], int.Parse(parts[2]), int.Parse(parts[3]), parts[4]);
break;
}
}
client.Close();
}
}
catch (SocketException e)
{
Host.Logger.WriteLine("SocketException: {0}", e);
}
finally
{
Listener.Stop();
}
}
public void Listen()
{
try
{
Listener.Start();
_containerInterfaces.Logger.LogInformation("Server Start listen");
while (true)
{
TcpClient client = Listener.AcceptTcpClient();
Thread thread = new Thread(() =>
{
SeverHandler socketHandler = new SeverHandler(client, AllChatDetails, _containerInterfaces);
socketHandler.Run();
});
thread.Start();
}
}
catch (Exception e)
{
Listener.Stop();
}
}