public void Start(Action <IWebSocketConnection> config)
{
if (CheckIfPortAvailable(Port))
{
var ipLocal = new IPEndPoint(_locationIP, Port);
ListenerSocket.Bind(ipLocal);
ListenerSocket.Listen(100);
Port = ((IPEndPoint)ListenerSocket.LocalEndPoint).Port;
FleckLog.Info(string.Format("Server started at {0} (actual port {1})", Location, Port));
if (_scheme == "wss")
{
if (Certificate == null)
{
FleckLog.Error("Scheme cannot be 'wss' without a Certificate");
return;
}
if (EnabledSslProtocols == SslProtocols.None)
{
EnabledSslProtocols = SslProtocols.Tls;
FleckLog.Debug("Using default TLS 1.0 security protocol.");
}
}
ListenForClients();
_config = config;
}
else
{
FleckLog.Error(string.Format("Server cannot start port {0}, port already in use", Port));
throw new Exception("Error: listen EADDRINUSE: address already in use :::" + Port);
}
}
public void Shutdown()
{
ListenerSocket?.Close();
ListenerSocket = null;
Loop.Stop();
}
public void Start(Action <IWebSocketConnection> config)
{
var ipLocal = new IPEndPoint(_locationIP, Port);
ListenerSocket.Bind(ipLocal);
ListenerSocket.Listen(100);
Port = ((IPEndPoint)ListenerSocket.LocalEndPoint).Port;
FleckLog.Info(string.Format("Server started at {0} (actual port {1})", Location, Port));
if (_scheme == "wss")
{
if (Certificate == null)
{
FleckLog.Error("Scheme cannot be 'wss' without a Certificate");
return;
}
if (EnabledSslProtocols == SslProtocols.None)
{
EnabledSslProtocols = SslProtocols.Tls;
FleckLog.Debug("Using default TLS 1.0 security protocol.");
}
}
ListenForClients();
_config = config;
}
public void SomeoneIsConnecting(string IPaddress, string Name)
{
ConnectedUser tmp = new ConnectedUser();
tmp.Ip = IPaddress;
tmp.Name = Name;
tmp.MyNumber = connectedUsers.Count + 1;
tmp.HasControl = false;
MTObservableCollection <ConnectedUser> newList = new MTObservableCollection <ConnectedUser>();
newList = connectedUsers;
newList.Add(tmp);
connectedUsers = new MTObservableCollection <ConnectedUser>();
connectedUsers = newList;
this.RaisePropertyChanged("ConnectedUsers");
SocketMessage socketMessage = new SocketMessage();
socketMessage.Port = (listenerSockets.Count + 12001).ToString();
socketMessage.MessageType = "PortInformation";
talkerSocket = new TalkerSocket(IPaddress, ClientUnderlyingListenerPort);
ListenerSocket newListenSocket = new ListenerSocket(Int32.Parse(socketMessage.Port), this);
listenerSockets.Add(newListenSocket);
listenerSockets.ElementAt(listenerSockets.Count - 1).StartListening();
talkerSocket.sendData(socketMessage);
viewShouldUpdate = true;
}
private void ListenForClients()
{
ManualResetEvent acceptDone = new ManualResetEvent(false);
bool running = true;
Task.Run(() => {
while (running)
{
acceptDone.Reset();
var task = ListenerSocket.Accept(
s => {
running = (s != null);
acceptDone.Set();
OnClientConnect(s);
},
e => { FleckLog.Error("Error while listening for new clients", e);
if (RestartAfterListenError)
{
TryRestart();
}
running = false; acceptDone.Set(); }
);
task.ContinueWith((t) => FleckLog.Warn("Error during client connect", t.Exception),
TaskContinuationOptions.OnlyOnFaulted);
acceptDone.WaitOne();
}
});
}
public void Start(Action <IWebsocketConnection> callsbacks)
{
_callbacks = callsbacks;
var ipLocal = new IPEndPoint(BindIp, LocalUri.Port);
ListenerSocket.Bind(ipLocal);
ListenerSocket.Listen(100);
Console.WriteLine("Websocket Server Started at " + LocalUri);
if (LocalUri.Scheme == "wss")
{
if (Certificate == null)
{
throw new Exception("Cannot use secure mode 'wss' without a Certificate.");
}
if (EnabledSslProtocols == SslProtocols.None)
{
EnabledSslProtocols = SslProtocols.Tls;
Console.WriteLine("Using default TLS 1.0.");
}
}
ListenForClients();
}
// a new client is trying to connect
private void OnClientConnect(IAsyncResult ar)
{
Socket clientSocket = null;
try
{
clientSocket = ListenerSocket.EndAccept(ar);
}
catch
{
Log.Error("Listener socket is closed");
return;
}
var shaker = new HandshakeHandler(Origin, Location);
// shake hands - and provide a callback for when hands has been shaken
shaker.Shake(clientSocket, (handshake) =>
{
// instantiate the connection and subscribe to the events
var wsc = new WebSocketConnection(clientSocket, handshake);
// fire the connected event
if (OnConnect != null)
{
OnConnect(wsc);
}
// start looking for data
wsc.StartReceiving();
});
// listen some more
ListenForClients();
}
private void OnClientConnect(IAsyncResult asyn)
{
Console.WriteLine("WebSocketServer(): in OnClientConnect()..");
// create a new socket for the connection
var clientSocket = ListenerSocket.EndAccept(asyn);
// shake hands to give the new client a warm welcome
ShakeHands(clientSocket);
// keep track of the new guy
var clientConnection = new WebSocketConnection(clientSocket);
Connections.Add(clientConnection);
clientConnection.Disconnected += new WebSocketConnection.WebSocketDisconnectedEventHandler(ClientDisconnected);
// invoke the connection event
if (ClientConnected != null)
{
ClientConnected(clientConnection, EventArgs.Empty);
}
clientConnection.DataReceived += new WebSocketConnection.DataReceivedEventHandler(DataReceivedFromClient);
// listen for more clients
ListenForClients();
}
private void ListenForClients()
{
ListenerSocket.Accept(
OnClientConnect,
e => {
FleckLog.Error("Listener socket is closed", e);
if (RestartAfterListenError)
{
FleckLog.Info("Listener socket restarting");
try
{
ListenerSocket.Dispose();
var socket = new Socket(_locationIP.AddressFamily, SocketType.Stream, ProtocolType.IP);
ListenerSocket = new SocketWrapper(socket);
Start(_config);
FleckLog.Info("Listener socket restarted");
}
catch (Exception ex)
{
FleckLog.Error("Listener could not be restarted", ex);
}
}
}
);
}
private void ConnectToMasterButtonClick(object sender, EventArgs e)
{
//listen for master
listenerSocket = new ListenerSocket(port, this);
listenerSocket.StartListening();
ConnectToMasterButton.Enabled = false;
}
/// <summary>
/// A function for shutting down the server.
/// </summary>
public virtual void Shutdown()
{
//// Shutdown and end connection
ListenerSocket.Stop();
Console.WriteLine(" >> Server " + Id + " is shutting down...");
Console.ReadLine();
}
private void ListenForClients()
{
ListenerSocket.Accept(OnClientConnect, e => {
Console.WriteLine("Listener socket is closed. " + e.Message);
if (!RestartAfterListenError)
{
return;
}
Console.WriteLine("Listener socket restarting");
try
{
ListenerSocket.Dispose();
var socket = new Socket(BindIp.AddressFamily, SocketType.Stream, ProtocolType.IP);
ListenerSocket = new SocketWrapper(socket);
Start(_callbacks);
Console.WriteLine("Listener socket restarted");
}
catch (Exception ex)
{
Console.WriteLine("Listener could not be restarted. " + ex.Message);
}
});
}
public virtual void Stop()
{
if (ListenerSocket != null)
{
ListenerSocket.Dispose();
ListenerSocket = null;
}
}
public MainPage()
{
this.InitializeComponent();
ListenerSocket listener = NetworkingLibaryCore.GetListener(this);
listener.Start();
}
public void run()
{
ListenerSocket listener = NetworkingLibaryCore.GetListener(this);
listener.Start();
Console.ReadLine();
}
public ISocket Connect(Action <IConnection> config)
{
var ipLocal = new IPEndPoint(_locationIP, Port);
ListenerSocket.Connect(ipLocal);
_config = config;
return(ListenerSocket);
}
public void Stop()
{
if (ListenerSocket != null)
{
ListenerSocket.Dispose();
ListenerSocket = null;
}
//需全部入队操作
}
public void StopServer()
{
if (_socket != null)
{
_socket.Dispose();
}
_socket = null;
}
public void StartButtonCommand()
{
ListenerSocket tmp = new ListenerSocket(MyUnderlyingListenerPort, this);
listenerSockets.Add(tmp);
isStartConsoleButtonEnabled = false;
listenerSockets.ElementAt(0).StartListening();
viewShouldUpdate = true;
}
public void Start()
{
ListenerSocket.Bind(_ipEndPoint);
ListenerSocket.Listen(100);
FleckLog.Info("Policy-Server started at " + Location);
ListenForClients();
}
private void LocalHostDemo()
{
// start the listener socket
ListenerSocket listener = NetworkingLibaryCore.GetListener(this);
listener.Start();
SetUpConnection();
}
public void Shutdown()
{
AuthCommunicator?.Close();
AuthCommunicator = null;
ListenerSocket?.Close();
ListenerSocket = null;
Loop.Stop();
}
static void Run()
{
using (var server = new ListenerSocket(ServerPort))
{
server.Accept += ServerAccept;
server.Active = true;
Console.WriteLine("Color server is running. Press enter to quit.");
Console.ReadLine();
}
}
private void OnAccept(LengthedSocket newSocket)
{
ListenerSocket.AcceptAsync();
if (newSocket == null)
{
return;
}
LoginManager.LoginSocket(newSocket);
}
/// <summary>
/// 开始监听
/// </summary>
/// <param name="config"></param>
public void Start(Action <IConnection> config)
{
var ipLocal = new IPEndPoint(IPAddress.Any, Port);
ListenerSocket.Bind(ipLocal);
ListenerSocket.Listen(100);
Port = ((IPEndPoint)ListenerSocket.LocalEndPoint).Port;
ListenForClients();
byte[] buffer = new byte[245];
_config = config;
}
private void OnAccept(LengthedSocket newSocket)
{
ListenerSocket.AcceptAsync();
if (newSocket == null)
{
return;
}
lock (Clients)
Clients.Add(new Client(newSocket, this, _authUnitOfWorkFactory));
}
public void Start(Action <ISocketConnection> config)
{
this.config = config;
var ipLocal = new IPEndPoint(IPAddress.Any, Port);
ListenerSocket.Bind(ipLocal);
ListenerSocket.Listen(100);
Logger.Debug("Socket Server started");
ListenForClients();
}
private void TryRestart()
{
FleckLog.Info("Listener socket restarting");
try {
ListenerSocket.Dispose();
var socket = new Socket(_locationIP.AddressFamily, SocketType.Stream, ProtocolType.IP);
ListenerSocket = new SocketWrapper(socket);
Start(_config);
FleckLog.Info("Listener socket restarted");
} catch (Exception ex) {
FleckLog.Error("Listener socket could not be restarted", ex);
}
}
/// <summary>
/// Processes all incoming requests
/// </summary>
private void _RequestListener()
{
try
{
// Accept connection as long as stop request is not posted
while (!StopRequested)
{
// Check if we have a connection request pending
if (ListenerSocket.Pending())
{
try
{
// Accept the connection
TcpClient newConnection = ListenerSocket.AcceptTcpClient();
// Create a new connection
T connection = CreateConnection(newConnection);
// Assign a log
connection.EventLog = EventLog;
// Subscribe for notifications
connection.OnConnectionClosed += new ConnectionClosedEventHandler(_OnConnectionClosed);
// Start a connection
connection.Start();
// Synchronize access to connections collection
lock (Connections)
{
// Register a new connection
Connections.Add(connection);
}
}
catch (Exception ex)
{
Log(ex.ToString());
}
}
else
{
// Pause a bit
Thread.Sleep(10);
}
}
}
catch (Exception ex)
{
Log(ex.ToString());
}
}
internal void SomeoneIsConnecting(string IPaddress, string Name)
{
User1Label.Text = "User1 : " + Name + " has connected with an IP address of " + IPaddress;
SocketMessage socketMessage = new SocketMessage();
socketMessage.Port = (listenerSockets.Count + 12001).ToString();
socketMessage.MessageType = "PortInformation";
talkerSocket = new TalkerSocket(IPaddress, ClientUnderlyingListenerPort);
ListenerSocket newListenSocket = new ListenerSocket(Int32.Parse(socketMessage.Port), this);
listenerSockets.Add(newListenSocket);
listenerSockets.ElementAt(listenerSockets.Count - 1).StartListening();
talkerSocket.sendData(socketMessage);
}
void ListenForTcpMessages()
{
listener = new ListenerSocket("127.0.0.1", 4999, new ConfigMessagesDispatcher());
listener.Listen();
}
