private void OnClientConnect(ISocket clientSocket)
{
FleckLog.Debug("Client Connected");
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r, s => connection.OnMessage(s),
connection.Close));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(_x509Certificate,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null)
{
return; // socket closed
}
FleckLog.Trace($"Client connected from {clientSocket.RemoteIpAddress}:{clientSocket.RemotePort}");
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b),
b => connection.OnPing(b),
b => connection.OnPong(b)),
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
FleckLog.Debug("Attempting to secure connection...");
clientSocket.Authenticate(Certificate, EnabledSslProtocols, connection.StartReceiving, e => FleckLog.Error($"Cannot secure the connection: {e.Message}", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
Logger.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
SocketConnection connection = new SocketConnection(clientSocket);
if (config != null)
{
config(connection);
}
connection.SocketHandler = CreateHandler(connection);
if (IsSecure)
{
Logger.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
connection.StartReceiving,
e => Logger.Error("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null)
{
return; // socket closed
}
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b),
b => connection.OnPing(b),
b => connection.OnPong(b)),
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
clientSocket
.Authenticate(Certificate,
EnabledSslProtocols,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
FleckLog.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b)),
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null)
{
return; // socket closed
}
FleckLog.Debug($"Client connected from {clientSocket.RemoteIpAddress}:{clientSocket.RemotePort.ToString()}");
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
(c, r) => HandlerFactory.BuildHandler(r, c));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
EnabledSslProtocols,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null)
{
return; // socket closed
}
FleckLog.Debug(string.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => {
try {
return(HandlerFactory.BuildHandler(
r, s => connection.OnMessage(s), connection.Close, b => connection.OnBinary(b),
b => connection.OnPing(b), b => connection.OnPong(b)
));
} catch (WebSocketException) {
const string responseMsg = "HTTP/1.1 200 OK\r\n"
+ "Date: {0}\r\n"
+ "Server: SharpChat\r\n"
+ "Content-Length: {1}\r\n"
+ "Content-Type: text/html; charset=utf-8\r\n"
+ "Connection: close\r\n"
+ "\r\n"
+ "{2}";
string responseBody = File.Exists(@"http-motd.txt") ? File.ReadAllText(@"http-motd.txt") : @"SharpChat";
clientSocket.Stream.Write(Encoding.UTF8.GetBytes(string.Format(
responseMsg, DateTimeOffset.Now.ToString(@"r"), Encoding.UTF8.GetByteCount(responseBody), responseBody
)));
clientSocket.Close();
return(null);
}
},
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
EnabledSslProtocols,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null)
{
return; // socket closed
}
FleckLog.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b),
b => connection.OnPing(b),
b => connection.OnPong(b)),
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
Task client = clientSocket
.Authenticate(Certificate,
EnabledSslProtocols,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
if (client == null)
{
Console.WriteLine("SSL Fail to Authentication Admin Please check SSL.");
FleckLog.Debug("SSL Fail to Authentication Admin Please check SSL.");
connection.Close();
}
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null)
{
return; // socket closed
}
NTWebSocketLog.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
initialize: _config,
parseRequest: bytes => RequestParser.Parse(bytes, _scheme),
handlerFactory: r => HandlerFactory.BuildHandler(
request: r,
onMessage: s => connection.OnMessage(s),
onClose: connection.Close,
onBinary: b => connection.OnBinary(b),
onPing: b => connection.OnPing(b),
onPong: b => connection.OnPong(b)),
negotiateSubProtocol: s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
NTWebSocketLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
EnabledSslProtocols,
connection.StartReceiving,
e => NTWebSocketLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
this.ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(clientSocket, this.scheme);
connection.MessageReceived += new EventHandler <TextMessageHandledEventArgs>(this.ConnectionMessageReceivedEventHandler);
connection.BinaryMessageReceived += new EventHandler <BinaryMessageHandledEventArgs>(this.ConnectionBinaryMessageReceivedEventHandler);
connection.Opened += new EventHandler <ConnectionEventArgs>(this.ConnectionOpenedEventHandler);
connection.Closed += new EventHandler <ConnectionEventArgs>(this.ConnectionClosedEventHandler);
connection.ErrorReceived += new EventHandler <ErrorEventArgs>(this.ConnectionErrorEventHandler);
connection.StandardHttpRequestReceived += new EventHandler <StandardHttpRequestReceivedEventArgs>(this.ConnectionStandardHttpRequestReceivedEventHandler);
if (this.IsSecure)
{
clientSocket.Authenticated += new EventHandler(this.SocketAuthenticatedEventHandler);
clientSocket.Authenticate(this.authenticationX509Certificate);
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
FleckLog.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme, AccessPolicyServer, clientSocket),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b)));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
FleckLog.Debug("Client Connected");
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r, s => connection.OnMessage(s),
connection.Close));
_config(connection);
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(_x509Certificate,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
this.ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(clientSocket, this.scheme);
connection.MessageReceived += new EventHandler<TextMessageHandledEventArgs>(this.ConnectionMessageReceivedEventHandler);
connection.BinaryMessageReceived += new EventHandler<BinaryMessageHandledEventArgs>(this.ConnectionBinaryMessageReceivedEventHandler);
connection.Opened += new EventHandler<ConnectionEventArgs>(this.ConnectionOpenedEventHandler);
connection.Closed += new EventHandler<ConnectionEventArgs>(this.ConnectionClosedEventHandler);
connection.ErrorReceived += new EventHandler<ErrorEventArgs>(this.ConnectionErrorEventHandler);
connection.StandardHttpRequestReceived += new EventHandler<StandardHttpRequestReceivedEventArgs>(this.ConnectionStandardHttpRequestReceivedEventHandler);
if (this.IsSecure)
{
clientSocket.Authenticated += new EventHandler(this.SocketAuthenticatedEventHandler);
clientSocket.Authenticate(this.authenticationX509Certificate);
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null)
{
return; // socket closed
}
// experimental removed by wmp
//FleckLog.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
//Console.WriteLine(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
string rep = string.Empty;
bool failed = false;
try {
rep = clientSocket.RemoteIpAddress;
Console.WriteLine("Connecting: " + rep);
}
catch {
Console.WriteLine("Started but IP not available.");
failed = true;
}
//ListenForClients();
if (failed)
{
try{ clientSocket.Close(); }catch {}
try{ clientSocket.Stream.Close(); }catch {}
try{ clientSocket.Dispose(); }catch {}
return;
}
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b),
b => connection.OnPing(b),
b => connection.OnPong(b)),
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
EnabledSslProtocols,
() =>
{
Console.WriteLine("Authenticated {0}", rep);
Server.Firewall.Update(rep, Server.Firewall.UpdateEntry.AuthSuccess);
connection.StartReceiving();
}
, e =>
{
FleckLog.Warn("Failed to Authenticate " + rep, e);
// here we could add connection.Close() ! wmp
Server.Firewall.Update(rep, Server.Firewall.UpdateEntry.AuthFailure);
connection.Close();
});
}
else
{
Server.Firewall.Update(rep, Server.Firewall.UpdateEntry.AuthSuccess);
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
FleckLog.Debug("Client Connected");
ListenForClients();
var connection = new WebSocketConnection(clientSocket, new DefaultHandlerFactory(_scheme));
_config(connection);
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(_x509Certificate,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null) return; // socket closed
FleckLog.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b),
b => connection.OnPing(b),
b => connection.OnPong(b)),
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket
.Authenticate(Certificate,
EnabledSslProtocols,
connection.StartReceiving,
e => FleckLog.Warn("Failed to Authenticate", e));
}
else
{
connection.StartReceiving();
}
}
private void OnClientConnect(ISocket clientSocket)
{
FleckLog.Debug(String.Format("Client connected from {0}:{1}", clientSocket.RemoteIpAddress, clientSocket.RemotePort.ToString()));
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(
clientSocket,
_config,
bytes => RequestParser.Parse(bytes, _scheme),
r => HandlerFactory.BuildHandler(r,
s => connection.OnMessage(s),
connection.Close,
b => connection.OnBinary(b),
b => connection.OnPing(b),
b => connection.OnPong(b)),
s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
// Determine whether this is a ws or wss connection
try
{
// Wait up to 5 seconds for the first handshake byte
// (Only peek, so it's still in the buffer for the actual handshake handler)
byte[] buffer = new byte[1];
clientSocket.Socket.ReceiveTimeout = 5000;
int BytesRead = clientSocket.Socket.Receive(buffer, 1, SocketFlags.Peek);
clientSocket.Socket.ReceiveTimeout = 0;
if (BytesRead == 1)
{
if ((buffer[0] == 0x16) || (buffer[0] == 0x80))
{
// wss connection, ensure we have a certificate
if (IsSecure)
{
FleckLog.Info("Accepting wss:// Connection");
clientSocket
.Authenticate(Certificate,
connection.StartReceiving,
e =>
{
FleckLog.Warn("Failed to Authenticate", e);
connection.Close();
});
}
else
{
FleckLog.Warn("Rejecting wss:// connection (no certificate)");
connection.Close();
}
}
else
{
// ws connection
FleckLog.Info("Accepting ws:// Connection");
connection.StartReceiving();
}
}
else
{
connection.Close();
}
}
catch (Exception ex)
{
FleckLog.Error("Unable to read handshake byte from client", ex);
connection.Close();
}
}