private void newListenerInstance_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
try
{
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Parse(args.Socket.Information.LocalAddress.DisplayName.ToString()), int.Parse(args.Socket.Information.LocalPort));
IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse(args.Socket.Information.RemoteAddress.DisplayName.ToString()), int.Parse(args.Socket.Information.RemotePort));
ConnectionInfo newConnectionInfo = new ConnectionInfo(ConnectionType.TCP, remoteEndPoint, localEndPoint, ApplicationLayerProtocol, this);
TCPConnection.GetConnection(newConnectionInfo, NetworkComms.DefaultSendReceiveOptions, args.Socket, true);
}
catch (ConfirmationTimeoutException)
{
//If this exception gets thrown its generally just a client closing a connection almost immediately after creation
}
catch (CommunicationException)
{
//If this exception gets thrown its generally just a client closing a connection almost immediately after creation
}
catch (ConnectionSetupException)
{
//If we are the server end and we did not pick the incoming connection up then tooo bad!
}
catch (SocketException)
{
//If this exception gets thrown its generally just a client closing a connection almost immediately after creation
}
catch (Exception ex)
{
//For some odd reason SocketExceptions don't always get caught above, so another check
if (ex.GetBaseException().GetType() != typeof(SocketException))
{
//Can we catch the socketException by looking at the string error text?
if (ex.ToString().StartsWith("System.Net.Sockets.SocketException"))
{
LogTools.LogException(ex, "ConnectionSetupError_SE");
}
else
{
LogTools.LogException(ex, "ConnectionSetupError");
}
}
}
}
/// <summary>
/// Internal <see cref="TCPConnection"/> creation which hides the necessary internal calls
/// </summary>
/// <param name="connectionInfo">ConnectionInfo to be used to create connection</param>
/// <param name="defaultSendReceiveOptions">Connection default SendReceiveOptions</param>
/// <param name="tcpClient">If this is an incoming connection we will already have access to the tcpClient, otherwise use null</param>
/// <param name="establishIfRequired">Establish during create if true</param>
/// <param name="sslOptions">SSL options that will be used with this connection.</param>
/// <returns>An existing connection or a new one</returns>
internal static TCPConnection GetConnection(ConnectionInfo connectionInfo, SendReceiveOptions defaultSendReceiveOptions, TcpClient tcpClient, bool establishIfRequired, SSLOptions sslOptions = null)
#endif
{
connectionInfo.ConnectionType = ConnectionType.TCP;
//If we have a tcpClient at this stage we must be server side
#if WINDOWS_PHONE || NETFX_CORE
if (socket != null)
{
connectionInfo.ServerSide = true;
}
#else
if (tcpClient != null)
{
connectionInfo.ServerSide = true;
}
if (sslOptions == null)
{
sslOptions = new SSLOptions();
}
#endif
//Set default connection options if none have been provided
if (defaultSendReceiveOptions == null)
{
defaultSendReceiveOptions = NetworkComms.DefaultSendReceiveOptions;
}
bool newConnection = false;
TCPConnection connection;
lock (NetworkComms.globalDictAndDelegateLocker)
{
List <Connection> existingConnections = NetworkComms.GetExistingConnection(connectionInfo.RemoteIPEndPoint, connectionInfo.LocalIPEndPoint, connectionInfo.ConnectionType, connectionInfo.ApplicationLayerProtocol);
//Check to see if a connection already exists, if it does return that connection, if not return a new one
if (existingConnections.Count > 0)
{
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace("Attempted to create new TCPConnection to connectionInfo='" + connectionInfo + "' but there is an existing connection. Existing connection will be returned instead.");
}
establishIfRequired = false;
connection = (TCPConnection)existingConnections[0];
}
else
{
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace("Creating new TCPConnection to connectionInfo='" + connectionInfo + "'." + (establishIfRequired ? " Connection will be established." : " Connection will not be established."));
}
if (connectionInfo.ConnectionState == ConnectionState.Establishing)
{
throw new ConnectionSetupException("Connection state for connection " + connectionInfo + " is marked as establishing. This should only be the case here due to a bug.");
}
//If an existing connection does not exist but the info we are using suggests it should we need to reset the info
//so that it can be reused correctly. This case generally happens when using Comms in the format
//TCPConnection.GetConnection(info).SendObject(packetType, objToSend);
if (connectionInfo.ConnectionState == ConnectionState.Established || connectionInfo.ConnectionState == ConnectionState.Shutdown)
{
connectionInfo.ResetConnectionInfo();
}
//We add a reference to networkComms for this connection within the constructor
#if WINDOWS_PHONE || NETFX_CORE
connection = new TCPConnection(connectionInfo, defaultSendReceiveOptions, socket);
#else
connection = new TCPConnection(connectionInfo, defaultSendReceiveOptions, tcpClient, sslOptions);
#endif
newConnection = true;
}
}
if (newConnection && establishIfRequired)
{
connection.EstablishConnection();
}
else if (!newConnection)
{
connection.WaitForConnectionEstablish(NetworkComms.ConnectionEstablishTimeoutMS);
}
if (!NetworkComms.commsShutdown)
{
TriggerConnectionKeepAliveThread();
}
return(connection);
}
/// <summary>
/// Internal <see cref="TCPConnection"/> creation which hides the necessary internal calls
/// </summary>
/// <param name="connectionInfo">ConnectionInfo to be used to create connection</param>
/// <param name="defaultSendReceiveOptions">Connection default SendReceiveOptions</param>
/// <param name="tcpClient">If this is an incoming connection we will already have access to the tcpClient, otherwise use null</param>
/// <param name="establishIfRequired">Establish during create if true</param>
/// <param name="sslOptions">SSL options that will be used with this connection.</param>
/// <returns>An existing connection or a new one</returns>
internal static TCPConnection GetConnection(ConnectionInfo connectionInfo, SendReceiveOptions defaultSendReceiveOptions, TcpClient tcpClient, bool establishIfRequired, SSLOptions sslOptions = null)
#endif
{
connectionInfo.ConnectionType = ConnectionType.TCP;
//If we have a tcpClient at this stage we must be server side
#if WINDOWS_PHONE || NETFX_CORE
if (socket != null) connectionInfo.ServerSide = true;
#else
if (tcpClient != null) connectionInfo.ServerSide = true;
if (sslOptions == null) sslOptions = new SSLOptions();
#endif
//Set default connection options if none have been provided
if (defaultSendReceiveOptions == null) defaultSendReceiveOptions = NetworkComms.DefaultSendReceiveOptions;
bool newConnection = false;
TCPConnection connection;
lock (NetworkComms.globalDictAndDelegateLocker)
{
List<Connection> existingConnections = NetworkComms.GetExistingConnection(connectionInfo.RemoteIPEndPoint, connectionInfo.LocalIPEndPoint, connectionInfo.ConnectionType, connectionInfo.ApplicationLayerProtocol);
//Check to see if a connection already exists, if it does return that connection, if not return a new one
if (existingConnections.Count > 0)
{
if (NetworkComms.LoggingEnabled)
NetworkComms.Logger.Trace("Attempted to create new TCPConnection to connectionInfo='" + connectionInfo + "' but there is an existing connection. Existing connection will be returned instead.");
establishIfRequired = false;
connection = (TCPConnection)existingConnections[0];
}
else
{
if (NetworkComms.LoggingEnabled)
NetworkComms.Logger.Trace("Creating new TCPConnection to connectionInfo='" + connectionInfo + "'." + (establishIfRequired ? " Connection will be established." : " Connection will not be established."));
if (connectionInfo.ConnectionState == ConnectionState.Establishing)
throw new ConnectionSetupException("Connection state for connection " + connectionInfo + " is marked as establishing. This should only be the case here due to a bug.");
//If an existing connection does not exist but the info we are using suggests it should we need to reset the info
//so that it can be reused correctly. This case generally happens when using Comms in the format
//TCPConnection.GetConnection(info).SendObject(packetType, objToSend);
if (connectionInfo.ConnectionState == ConnectionState.Established || connectionInfo.ConnectionState == ConnectionState.Shutdown)
connectionInfo.ResetConnectionInfo();
//We add a reference to networkComms for this connection within the constructor
#if WINDOWS_PHONE || NETFX_CORE
connection = new TCPConnection(connectionInfo, defaultSendReceiveOptions, socket);
#else
connection = new TCPConnection(connectionInfo, defaultSendReceiveOptions, tcpClient, sslOptions);
#endif
newConnection = true;
}
}
if (newConnection && establishIfRequired) connection.EstablishConnection();
else if (!newConnection) connection.WaitForConnectionEstablish(NetworkComms.ConnectionEstablishTimeoutMS);
if (!NetworkComms.commsShutdown) TriggerConnectionKeepAliveThread();
return connection;
}
/// <summary>
/// Async method for handling up new incoming TCP connections
/// </summary>
private void TCPConnectionReceivedAsync(IAsyncResult ar)
{
if (!IsListening)
{
return;
}
try
{
TcpClient newTCPClient = listenerInstance.EndAcceptTcpClient(ar);
ConnectionInfo newConnectionInfo = new ConnectionInfo(ConnectionType.TCP, (IPEndPoint)newTCPClient.Client.RemoteEndPoint, (IPEndPoint)newTCPClient.Client.LocalEndPoint, ApplicationLayerProtocol, this);
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Info("New incoming TCP connection from " + newConnectionInfo);
}
//We have to use our own thread pool here as the performance of the .Net one is awful
NetworkComms.IncomingConnectionEstablishThreadPool.EnqueueItem(QueueItemPriority.Normal, new WaitCallback((obj) =>
{
#region Pickup The New Connection
try
{
TCPConnection.GetConnection(newConnectionInfo, ListenerDefaultSendReceiveOptions, newTCPClient, true, SSLOptions);
}
catch (ConfirmationTimeoutException)
{
//If this exception gets thrown its generally just a client closing a connection almost immediately after creation
}
catch (CommunicationException)
{
//If this exception gets thrown its generally just a client closing a connection almost immediately after creation
}
catch (ConnectionSetupException)
{
//If we are the server end and we did not pick the incoming connection up then tooo bad!
}
catch (SocketException)
{
//If this exception gets thrown its generally just a client closing a connection almost immediately after creation
}
catch (Exception ex)
{
//For some odd reason SocketExceptions don't always get caught above, so another check
if (ex.GetBaseException().GetType() != typeof(SocketException))
{
//Can we catch the socketException by looking at the string error text?
if (ex.ToString().StartsWith("System.Net.Sockets.SocketException"))
{
LogTools.LogException(ex, "ConnectionSetupError_SE");
}
else
{
LogTools.LogException(ex, "ConnectionSetupError");
}
}
}
#endregion Pickup The New Connection
}), null);
}
catch (SocketException)
{
//If this exception gets thrown its generally just a client closing a connection almost immediately after creation
}
catch (Exception ex)
{
//For some odd reason SocketExceptions don't always get caught above, so another check
if (ex.GetBaseException().GetType() != typeof(SocketException))
{
//Can we catch the socketException by looking at the string error text?
if (ex.ToString().StartsWith("System.Net.Sockets.SocketException"))
{
LogTools.LogException(ex, "ConnectionSetupError_SE");
}
else
{
LogTools.LogException(ex, "ConnectionSetupError");
}
}
}
finally
{
listenerInstance.BeginAcceptTcpClient(TCPConnectionReceivedAsync, null);
}
}
