private static void ValidateReceive(TcpServerConnection <int> serverData, int expectedValue)
{
int val;
serverData.TryReceive(out val).Should().BeTrue();
expectedValue.Should().Be(val);
}
/// <summary>
/// Accepts the new TCP connections until cancelled.
/// </summary>
private async Task AcceptLoopAsync()
{
while (true)
{
TcpClient client;
try
{
client = await Listener.AcceptTcpClientAsync();
}
catch
{
if (!CancellationTokenSource.IsCancellationRequested)
{
await Session.RemoveTunnelAsync(this);
}
break;
}
var connection = new TcpServerConnection(Id, Session, client);
try
{
await Session.AddConnection(connection, CancellationTokenSource.Token);
await connection.StartAsync();
}
catch
{
System.Diagnostics.Debug.WriteLine("Failed to add connection for new TCP client.");
}
}
}
/// <summary>
/// Handle upgrade to websocket
/// </summary>
private async Task handleWebSocketUpgrade(SessionEventArgs args,
HttpClientStream clientStream, TcpServerConnection serverConnection,
CancellationTokenSource cancellationTokenSource, CancellationToken cancellationToken)
{
await serverConnection.Stream.WriteRequestAsync(args.HttpClient.Request, cancellationToken);
var httpStatus = await serverConnection.Stream.ReadResponseStatus(cancellationToken);
var response = args.HttpClient.Response;
response.HttpVersion = httpStatus.Version;
response.StatusCode = httpStatus.StatusCode;
response.StatusDescription = httpStatus.Description;
await HeaderParser.ReadHeaders(serverConnection.Stream, response.Headers,
cancellationToken);
if (!args.IsTransparent)
{
await clientStream.WriteResponseAsync(response, cancellationToken);
}
// If user requested call back then do it
if (!args.HttpClient.Response.Locked)
{
await onBeforeResponse(args);
}
await TcpHelper.SendRaw(clientStream, serverConnection.Stream, BufferPool,
args.OnDataSent, args.OnDataReceived, cancellationTokenSource, ExceptionFunc);
}
private void OnConnect(TcpServerConnection connection)
{
string ipAndPort = GetAlias(connection);
serverWindow.PrintLine("<" + ipAndPort + "> connected.");
TrySendMessage(connection, "OK|HELLO");
}
private int SendRandomData(TcpServerConnection <int> data)
{
var itemToBeSent = _random.Next(0, 1000);
data.Send(itemToBeSent);
return(itemToBeSent);
}
private async Task <RetryResult> handleHttpSessionRequest(string httpCmd, SessionEventArgs args,
TcpServerConnection serverConnection, SslApplicationProtocol sslApplicationProtocol,
CancellationToken cancellationToken, CancellationTokenSource cancellationTokenSource)
{
//a connection generator task with captured parameters via closure.
Func <Task <TcpServerConnection> > generator = () =>
tcpConnectionFactory.GetServerConnection(this, args, isConnect: false,
applicationProtocol: sslApplicationProtocol,
noCache: false, cancellationToken: cancellationToken);
//for connection pool, retry fails until cache is exhausted.
return(await retryPolicy <ServerConnectionException>().ExecuteAsync(async(connection) =>
{
args.TimeLine["Connection Ready"] = DateTime.Now;
if (args.HttpClient.Request.UpgradeToWebSocket)
{
// if upgrading to websocket then relay the request without reading the contents
await handleWebSocketUpgrade(httpCmd, args, args.HttpClient.Request,
args.HttpClient.Response, args.ProxyClient.ClientStream, args.ProxyClient.ClientStreamWriter,
connection, cancellationTokenSource, cancellationToken);
return false;
}
// construct the web request that we are going to issue on behalf of the client.
await handleHttpSessionRequest(connection, args);
return true;
}, generator, serverConnection));
}
/// <summary>
/// Handle upgrade to websocket
/// </summary>
private async Task handleWebSocketUpgrade(string httpCmd,
SessionEventArgs args, Request request, Response response,
CustomBufferedStream clientStream, HttpResponseWriter clientStreamWriter,
TcpServerConnection serverConnection,
CancellationTokenSource cancellationTokenSource, CancellationToken cancellationToken)
{
// prepare the prefix content
await serverConnection.StreamWriter.WriteLineAsync(httpCmd, cancellationToken);
await serverConnection.StreamWriter.WriteHeadersAsync(request.Headers,
cancellationToken : cancellationToken);
string httpStatus;
try
{
httpStatus = await serverConnection.Stream.ReadLineAsync(cancellationToken);
if (httpStatus == null)
{
throw new ServerConnectionException("Server connection was closed.");
}
}
catch (Exception e) when(!(e is ServerConnectionException))
{
throw new ServerConnectionException("Server connection was closed.", e);
}
Version responseVersion;
int responseStatusCode;
string responseStatusDescription;
Response.ParseResponseLine(httpStatus, out responseVersion,
out responseStatusCode,
out responseStatusDescription);
response.HttpVersion = responseVersion;
response.StatusCode = responseStatusCode;
response.StatusDescription = responseStatusDescription;
await HeaderParser.ReadHeaders(serverConnection.Stream, response.Headers,
cancellationToken);
if (!args.IsTransparent)
{
await clientStreamWriter.WriteResponseAsync(response,
cancellationToken : cancellationToken);
}
// If user requested call back then do it
if (!args.WebSession.Response.Locked)
{
await invokeBeforeResponse(args);
}
await TcpHelper.SendRaw(clientStream, serverConnection.Stream, BufferPool, BufferSize,
(buffer, offset, count) => { args.OnDataSent(buffer, offset, count); },
(buffer, offset, count) => { args.OnDataReceived(buffer, offset, count); },
cancellationTokenSource, ExceptionFunc);
}
private string GetAlias(TcpServerConnection connection)
{
if (aliases.ContainsKey(connection))
{
return(aliases[connection]);
}
return((connection.Socket.Client.RemoteEndPoint as IPEndPoint)?.ToString() ?? "<unknown>");
}
void OnDataAvailable(TcpServerConnection connection)
{
NetworkStream stream = connection.Socket.GetStream();
ClientRequest req = ClientRequest.ReceiveFrom(stream);
ServerResponse resp = ProcessRequest(req);
resp.SendTo(stream);
}
//before retry clear connection
private async Task disposeConnection()
{
if (currentConnection != null)
{
//close connection on error
await tcpConnectionFactory.Release(currentConnection, true);
currentConnection = null;
}
}
//public event EventHandler<DataInfo> OnNewClient;
//Dictionary<int, CommandAction> m_action;
#endregion
/**
* constructor
*/
public ImageServer(IImageController m, ILoggingService m_logging1, int port)
{
this.m_controller = m;
this.m_logging = m_logging1;
this.port = 8001;
this.tcpServer = new TcpServerConnection(this.m_controller, m_logging);
this.tcpServer.Sh.CommandRecieved += sendCmd;
// this.OnNewClient += this.tcpServer.onNewClient;
handlers = new List <IDirectoryHandler>();
}
private void Connection2_OnConnect(TcpServerConnection connection)
{
client_count++;
NotifierHelper.Notify("Connection.ClientIn");
//if (client_count > 0)
{
UpdateClientStatus();
}
}
//before retry clear connection
private async Task onRetry(Exception ex, int attempt)
{
if (currentConnection != null)
{
//close connection on error
await tcpConnectionFactory.Release(currentConnection, true);
currentConnection = null;
}
}
private void _server_OnConnect(TcpServerConnection connection)
{
_server.Send($"Welcome!{_nl}");
InvokeDelegate del = () =>
{
EndPoint ep = connection.Socket.Client.RemoteEndPoint;
handleInput($"Remote endpoint : {ep}{_nl}");
};
Invoke(del);
}
private void OnDisconnect(TcpServerConnection connection)
{
string alias = GetAlias(connection);
bool removed = aliases.TryRemove(connection, out _);
serverWindow.PrintLine("<" + alias + "> disconnected.");
if (removed)
{
TrySendMessage("USER_DISCONNECTED|" + alias);
}
UpdateUserList();
}
private void Server_ClientConnected(object sender, TcpServerEventArgs e)
{
if (InvokeRequired)
{
BeginInvoke(new TCPMethod(Server_ClientConnected), new object[] { sender, e });
return;
}
tcpClient = e.Client;
e.Client.BytesReceived += Client_BytesReceived;
e.Client.BytesSent += Client_BytesSent;
LogInfo(tcpServerLog, "Client Connected: " + tcpClient.ClientIPAddress);
}
private void OnDataAvailable(TcpServerConnection connection)
{
byte[] data = ReadStream(connection.Socket);
if (data == null)
{
return;
}
string dataStr = Encoding.UTF8.GetString(data);
HandleMessage(connection, dataStr);
}
public void DiscoveryServerOnDataAvailable(TcpServerConnection connection)
{
Logger.Trace("DiscoveryServer.OnDataAvailable: {0}", connection.ClientAddress.ToString());
var client = connection.Socket;
using (var stream = client.GetStream())
using (var sw = new StreamWriter(stream))
{
if (stream.DataAvailable)
{
var data = new byte[5013];
try
{
var bytesRead = stream.Read(data, 0, data.Length);
Logger.Debug("{1} Bytes Received: {0}", bytesRead, connection.ClientAddress);
var request = new EncoderRequest();
request.Deserialize(ref data);
foreach (var device in _settings.Devices)
{
foreach (var tuner in device.Tuners)
{
if (tuner.Enabled)
{
var response = new EncoderResponse
{
Name = tuner.Name,
Length = tuner.Name.Length,
Prefix = request.Prefix,
Version = "210",
Port = (uint)tuner.ListenerPort
};
Logger.Debug("Sending:{0}", response);
sw.Write(response);
}
}
}
connection.ForceDisconnect();
}
catch (IOException ex)
{
Logger.Warn("IOException while reading stream", ex);
}
}
}
}
public static void tcpServer_OnDataAvailable(TcpServerConnection connection)
{
var data = readStream(connection.Socket);
if (data == null)
{
return;
}
string reply = ParseCheckResult(data);
connection.sendData(reply);
}
//get the policy
private Policy getRetryPolicy()
{
return(Policy.Handle <T>()
.RetryAsync(retries,
onRetryAsync: async(ex, i, context) =>
{
if (currentConnection != null)
{
//close connection on error
await tcpConnectionFactory.Release(currentConnection, true);
currentConnection = null;
}
}));
}
/// <summary>
/// Handle upgrade to websocket
/// </summary>
private async Task handleWebSocketUpgrade(string requestHttpMethod, string requestHttpUrl, Version requestVersion,
SessionEventArgs args, Request request, Response response,
CustomBufferedStream clientStream, HttpResponseWriter clientStreamWriter,
TcpServerConnection serverConnection,
CancellationTokenSource cancellationTokenSource, CancellationToken cancellationToken)
{
// prepare the prefix content
var headerBuilder = new HeaderBuilder();
headerBuilder.WriteRequestLine(requestHttpMethod, requestHttpUrl, requestVersion);
headerBuilder.WriteHeaders(request.Headers);
await serverConnection.StreamWriter.WriteHeadersAsync(headerBuilder, cancellationToken);
string httpStatus;
try
{
httpStatus = await serverConnection.Stream.ReadLineAsync(cancellationToken)
?? throw new ServerConnectionException("Server connection was closed.");
}
catch (Exception e) when(!(e is ServerConnectionException))
{
throw new ServerConnectionException("Server connection was closed.", e);
}
Response.ParseResponseLine(httpStatus, out var responseVersion,
out int responseStatusCode,
out string responseStatusDescription);
response.HttpVersion = responseVersion;
response.StatusCode = responseStatusCode;
response.StatusDescription = responseStatusDescription;
await HeaderParser.ReadHeaders(serverConnection.Stream, response.Headers,
cancellationToken);
if (!args.IsTransparent)
{
await clientStreamWriter.WriteResponseAsync(response,
cancellationToken : cancellationToken);
}
// If user requested call back then do it
if (!args.HttpClient.Response.Locked)
{
await onBeforeResponse(args);
}
await TcpHelper.SendRaw(clientStream, serverConnection.Stream, BufferPool,
args.OnDataSent, args.OnDataReceived, cancellationTokenSource, ExceptionFunc);
}
void OnConnect(TcpServerConnection connection)
{
NetworkStream stream = connection.Socket.GetStream();
ClientRequest req = null;
try
{
req = ClientRequest.ReceiveFrom(stream);
}
catch
{
return;
}
if (req.Purpose == RequestPurpose.Login)
{
if (FreeSlots > 0 && CurrentGame.Phase == GamePhase.Lobby)
{
ServersideClientInfo client = new ServersideClientInfo();
client.Connection = connection;
client.PlayerName = (string)req.Data[0];
client.CharacterToString = (string)req.Data[1];
client.ClientID = Clients.Count;
Clients.Add(client);
ServerResponse toSend = new ServerResponse();
toSend.Purpose = ResponseType.LoginAccepted;
toSend.Data = new object[] { client.ClientID, ClientsideServerInfo.FromServer(this) };
toSend.SendTo(stream);
}
else
{
ServerResponse toSend = new ServerResponse();
toSend.Purpose = ResponseType.ActionDenied;
toSend.Data = new object[] { "" };
if (FreeSlots == 0)
{
toSend.Data[0] = "Server full";
}
else
{
toSend.Data[0] = "Game in progress";
}
toSend.SendTo(stream);
server.Connections.Remove(connection);
}
}
}
private async Task handleHttpSessionRequest(TcpServerConnection connection, SessionEventArgs args)
{
var cancellationToken = args.CancellationTokenSource.Token;
var request = args.HttpClient.Request;
request.Locked = true;
var body = request.CompressBodyAndUpdateContentLength();
// set the connection and send request headers
args.HttpClient.SetConnection(connection);
await args.HttpClient.SendRequest(Enable100ContinueBehaviour, args.IsTransparent,
cancellationToken);
// If a successful 100 continue request was made, inform that to the client and reset response
if (request.ExpectationSucceeded)
{
var clientStreamWriter = args.ProxyClient.ClientStreamWriter;
var response = args.HttpClient.Response;
var headerBuilder = new HeaderBuilder();
headerBuilder.WriteResponseLine(response.HttpVersion, response.StatusCode, response.StatusDescription);
headerBuilder.WriteHeaders(response.Headers);
await clientStreamWriter.WriteHeadersAsync(headerBuilder, cancellationToken);
await args.ClearResponse(cancellationToken);
}
// send body to server if available
if (request.HasBody)
{
if (request.IsBodyRead)
{
var writer = args.HttpClient.Connection.StreamWriter;
await writer.WriteBodyAsync(body !, request.IsChunked, cancellationToken);
}
else if (!request.ExpectationFailed)
{
// get the request body unless an unsuccessful 100 continue request was made
HttpWriter writer = args.HttpClient.Connection.StreamWriter !;
await args.CopyRequestBodyAsync(writer, TransformationMode.None, cancellationToken);
}
}
args.TimeLine["Request Sent"] = DateTime.Now;
// parse and send response
await handleHttpSessionResponse(args);
}
public ServerConnectionVM(TcpServerConnection connection)
{
Rooms = new ObservableCollection <string>();
_tcpConnection = connection;
_tcpConnection.IsConnectedChanged += TcpConnection_OnConnectedChanged;
_control = new ServerConnectionView {
DataContext = this
};
_control.ConnectButton.Click += ConnectButton_Click;
_control.AddressTextBox.KeyDown += AddressTextBox_KeyDown;
_control.RefreshRoomsButton.Click += (s, e) => _tcpConnection.RefreshRooms(Rooms);
_control.CreateNewRoom.Click += (s, e) => _tcpConnection.CreateRoom(_control.NewRoomName.Text, _control.NewRoomPassword.Text);
_control.ConnectToRoomButton.Click += ConnectToRoomButton_Click;
}
private void send_response(string response, TcpServerConnection connection)
{
try
{
NetworkStream stream = connection.Socket.GetStream();
byte[] bytes;
bytes = Encoding.UTF8.GetBytes(response.ToCharArray(), 0, response.Length);
stream.Write(bytes, 0, response.Length);
}
catch (Exception e)
{
OnLog(new LogEventArgs("Error sending response: " + e.Message));
}
}
private void _server_OnDataAvailable(TcpServerConnection connection)
{
byte[] data = ReadStream(connection.Socket);
if (data != null)
{
string dataStr = Encoding.ASCII.GetString(data);
InvokeDelegate del = () =>
{
handleInput($"{dataStr}{_nl}");
};
Invoke(del);
data = null;
}
}
public void SendingDatawithTCPServerIsReceivedCorrectly()
{
using (var server = CreateServer())
{
var resetEvent = new ManualResetEvent(false);
TcpServerConnection <int> data = null;
server.ConnectionStarted += (sender, serverData) =>
{
data = serverData;
resetEvent.Set();
};
var tcpClient = Connect(resetEvent);
SendRandomData(data);
ReceiveToTcpClient(tcpClient);
}
}
private void runListener()
{
while (m_isOpen && m_port >= 0)
{
try
{
if (listener.Pending())
{
TcpClient socket = listener.AcceptTcpClient();
TcpServerConnection conn = new TcpServerConnection(socket, m_encoding);
if (OnConnect != null)
{
lock (activeThreadsLock)
{
activeThreads++;
}
conn.CallbackThread = new Thread(() =>
{
OnConnect(conn);
});
conn.CallbackThread.Start();
}
lock (connections)
{
connections.Add(conn);
}
}
else
{
System.Threading.Thread.Sleep(m_idleTime);
}
}
catch (ThreadInterruptedException) { } //thread is interrupted when we quit
catch (Exception e)
{
if (m_isOpen && OnError != null)
{
OnError(this, e);
}
}
}
}
private void _tcpServer_OnDataAvailable(TcpServerConnection connection)
{
byte[] data = readStream(connection.Socket);
if (data != null)
{
//string dataStr = Encoding.ASCII.GetString(data);
try
{
invokeDelegate del = () =>
{
ParseSvsData(data);
};
Invoke(del);
data = null;
}
catch { }
}
}
public void OnDataAvailable(TcpServerConnection connection)
{
Logger.Trace("TcpServer.OnDataAvailable: {0}", connection.ClientAddress.ToString());
var client = connection.Socket;
using (var stream = client.GetStream())
using (var sw = new StreamWriter(stream))
{
if (stream.DataAvailable)
{
var data = new byte[5013];
var stringBuilder = new StringBuilder();
try
{
do
{
var bytesRead = stream.Read(data, 0, data.Length);
Logger.Debug("{1}:{2} Bytes Received: {0}", bytesRead, connection.ClientAddress, _tunerSettings.ListenerPort);
stringBuilder.Append(Encoding.UTF8.GetString(data, 0, bytesRead));
string str = stringBuilder.ToString();
if (!string.IsNullOrEmpty(str) && str.Length > 2 && str.Substring(str.Length - 2) == "\r\n")
{
var response = HandleRequest(stringBuilder.ToString().Trim());
Logger.Debug("Sending:{0}", response);
sw.Write(response + Environment.NewLine);
}
}while (client.Available > 0);
}
catch (IOException ex)
{
Logger.Warn("IOException while reading stream", ex);
}
}
}
}
