| public EndConnect ( IAsyncResult asyncResult ) : void | ||
| asyncResult | IAsyncResult | |
| Результат | void | |
/// <summary>
/// Methode callback appelée lorsque la connexion est effective.
/// </summary>
/// <param name="result"></param>
private void OnConnect(IAsyncResult result)
{
try
{
_tcpClient.EndConnect(result);
_connected = true;
NetworkStream stream = _tcpClient.GetStream();
if (stream != null)
{
stream.BeginRead(_buffer, 0, _buffer.Length, OnDataReceived, this);
if (this.ReferenceDelegate != null)
{
this.ReferenceDelegate.OnConnect(this);
}
}
}
catch (Exception e)
{
if (this.ReferenceDelegate != null)
{
this.ReferenceDelegate.OnError(e, this);
}
}
}
//This method uses TCPClient to check the validity of the domain name and returns true if domain exists, and false if it doesn't
private static bool IsDomainAlive(string aDomain, int aTimeoutSeconds)
{
System.Uri uri = new Uri(aDomain);
string uriWithoutScheme = uri.Host.TrimEnd('/');
try
{
using (TcpClient client = new TcpClient())
{
var result = client.BeginConnect(uriWithoutScheme, 80, null, null);
var success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(aTimeoutSeconds));
if (!success)
{
// Console.Write(aDomain + " ---- No such domain exists\n");
return false;
}
// we have connected
client.EndConnect(result);
return true;
}
}
catch (Exception ex)
{
// Console.Write(aDomain + " ---- " + ex.Message + "\n");
}
return false;
}
public void Connect()
{
try
{
Close();
}
catch (Exception) { }
client = new TcpClient();
client.NoDelay = true;
IAsyncResult ar = client.BeginConnect(Host, Port, null, null);
System.Threading.WaitHandle wh = ar.AsyncWaitHandle;
try
{
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(5), false))
{
client.Close();
throw new IOException("Connection timoeut.", new TimeoutException());
}
client.EndConnect(ar);
}
finally
{
wh.Close();
}
stream = client.GetStream();
stream.ReadTimeout = 10000;
stream.WriteTimeout = 10000;
}
/// <summary>
/// Begins the connection process to the server, including the sending of a handshake once connected.
/// </summary>
public void Connect()
{
try {
BaseSock = new TcpClient();
var ar = BaseSock.BeginConnect(ClientBot.Ip, ClientBot.Port, null, null);
using (ar.AsyncWaitHandle) {
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(5), false)) {
BaseSock.Close();
ClientBot.RaiseErrorMessage("Failed to connect: Timeout.");
return;
}
BaseSock.EndConnect(ar);
}
} catch (Exception e) {
ClientBot.RaiseErrorMessage("Failed to connect: " + e.Message);
return;
}
ClientBot.RaiseInfoMessage("Connected to server.");
BaseStream = BaseSock.GetStream();
WSock = new ClassicWrapped.ClassicWrapped {_Stream = BaseStream};
DoHandshake();
_handler = new Thread(Handle);
_handler.Start();
_timeoutHandler = new Thread(Timeout);
_timeoutHandler.Start();
}
private static bool IsPortOpen(IPAddress ipAddress, int currentPort, int connectTimeout)
{
bool portIsOpen = false;
using (var tcp = new TcpClient())
{
IAsyncResult ar = tcp.BeginConnect(ipAddress, currentPort, null, null);
using (ar.AsyncWaitHandle)
{
//Wait connectTimeout ms for connection.
if (ar.AsyncWaitHandle.WaitOne(connectTimeout, false))
{
try
{
tcp.EndConnect(ar);
portIsOpen = true;
//Connect was successful.
}
catch
{
//Server refused the connection.
}
}
}
}
return portIsOpen;
}
public static bool IsPortOpen(string host, int port, int timeout = 2000, int retry = 1)
{
var retryCount = 0;
while (retryCount < retry)
{
// Logical delay without blocking the current thread.
if (retryCount > 0)
{
System.Threading.Tasks.Task.Delay(timeout).Wait();
}
var client = new System.Net.Sockets.TcpClient();
try
{
var result = client.BeginConnect(host, port, null, null);
var success = result.AsyncWaitHandle.WaitOne(timeout);
if (success)
{
client.EndConnect(result);
return(true);
}
}
catch
{
// ignored
}
finally
{
client.Close();
retryCount++;
}
}
return(false);
}
public Boolean Connect(IPAddress hostAddr, Int32 hostPort, Int32 timeout)
{
// Create new instance of TCP client
_Client = new TcpClient();
var result = _Client.BeginConnect(hostAddr, hostPort, null, null);
_TransmitThread = null;
result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(timeout));
if (!_Client.Connected)
{
return false;
}
// We have connected
_Client.EndConnect(result);
EventHandler handler = OnConnected;
if(handler != null)
{
handler(this, EventArgs.Empty);
}
// Now we are connected --> start async read operation.
NetworkStream networkStream = _Client.GetStream();
byte[] buffer = new byte[_Client.ReceiveBufferSize];
networkStream.BeginRead(buffer, 0, buffer.Length, OnDataReceivedHandler, buffer);
// Start thread to manage transmission of messages
_TransmitThreadEnd = false;
_TransmitThread = new Thread(TransmitThread);
_TransmitThread.Start();
return true;
}
public SensorState DoCheckState(Server target)
{
try
{
using (TcpClient client = new TcpClient())
{
var result = client.BeginConnect(target.FullyQualifiedHostName, Port, null, null);
var success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(2));
if (!success)
return SensorState.Error;
client.EndConnect(result);
}
return SensorState.OK;
}
catch (SocketException)
{
//TODO: Check for Status
return SensorState.Error;
}
catch (Exception)
{
return SensorState.Error;
}
}
public static bool Ping(string host, int port, TimeSpan timeout, out TimeSpan elapsed)
{
using (TcpClient tcp = new TcpClient())
{
DateTime start = DateTime.Now;
IAsyncResult result = tcp.BeginConnect(host, port, null, null);
WaitHandle wait = result.AsyncWaitHandle;
bool ok = true;
try
{
if (!result.AsyncWaitHandle.WaitOne(timeout, false))
{
tcp.Close();
ok = false;
}
tcp.EndConnect(result);
}
catch
{
ok = false;
}
finally
{
wait.Close();
}
DateTime stop = DateTime.Now;
elapsed = stop.Subtract(start);
return ok;
}
}
public bool Connect(string ip, int port)
{
try
{
Disconnect();
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
tcpClient = new TcpClient();
tcpClient.BeginConnect(ip,
port,
new AsyncCallback(
delegate(IAsyncResult asyncResult)
{
try
{
tcpClient.EndConnect(asyncResult);
}
catch { }
autoResetEvent.Set();
}
),
tcpClient);
if (!autoResetEvent.WaitOne())
throw new Exception();
networkStream = tcpClient.GetStream();
thread = new Thread(new ThreadStart(Read));
thread.IsBackground = true;
thread.Name = "ReadThread";
thread.Start();
return true;
}
catch (Exception e)
{
ICtrl.logger.Info("Connect(...) exception:");
ICtrl.logger.Info("ip: " + ip);
ICtrl.logger.Info("port: " + port);
ICtrl.logger.Info(e.Message);
ICtrl.logger.Info(e.Source);
ICtrl.logger.Info(e.StackTrace);
DBConnection.Instance.Disconnect();
Environment.Exit(0);
}
return false;
}
public bool Send(string hostName, int port = 80, bool throwOnError = true, int timeout = 100)
{
try
{
using (var tcpClient = new TcpClient())
{
var asyncResult = tcpClient.BeginConnect(hostName, port, null, null);
var asyncWaitHandle = asyncResult.AsyncWaitHandle;
try
{
if (!asyncResult.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(timeout), false))
{
tcpClient.Close();
if (throwOnError)
{
throw new TimeoutException();
}
return false;
}
try
{
tcpClient.EndConnect(asyncResult);
}
catch
{
if (throwOnError)
{
throw;
}
return false;
}
return true;
}
finally
{
asyncWaitHandle.Close();
}
}
}
catch
{
if (throwOnError)
{
throw;
}
return false;
}
}
/// <summary>
/// Checks, if a certain <paramref name="port"/> is opened on a given <paramref name="host"/>.
/// </summary>
/// <param name="host">IP-Address or host name to check for the port.</param>
/// <param name="port">The port-number to check.</param>
/// <param name="timeout">The timeout in seconds to wait for a reply.</param>
/// <param name="useUdp"><c>true</c> if a UDP port should be checked.</param>
/// <returns><c>True</c> if the port is opened, otherwise <c>false.</c></returns>
public static bool IsPortOpened(string host, int port, int timeout = 1, bool useUdp = false)
{
var result = false;
if (!useUdp)
{
// Use TCP
var client = new TcpClient();
try
{
client.ReceiveTimeout = timeout * 1000;
client.SendTimeout = timeout * 1000;
var asyncResult = client.BeginConnect(host, port, null, null);
var waitHandle = asyncResult.AsyncWaitHandle;
try
{
if (asyncResult.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(timeout), false))
{
// The result was positiv
result = client.Connected;
}
// ensure the ending-call
client.EndConnect(asyncResult);
}
finally
{
// Ensure to close the wait handle.
waitHandle.Close();
}
}
catch { }
finally
{
// wait handle didn't came back in time
client.Close();
}
}
else
{
// Use UDP
var client = new UdpClient();
try
{
client.Connect(host, port);
result = true;
}
catch { }
finally
{
// wait handle didn't came back in time
client.Close();
}
}
return result;
}
private void ConnectResult(IAsyncResult ar)
{
System.Net.Sockets.TcpClient socket = (System.Net.Sockets.TcpClient)ar.AsyncState;
if (socket.Client != null && socket.Connected)
{
socket.EndConnect(ar);
NetworkStream stream = socket.GetStream();
stream.BeginRead(recvBuffer, 0, recvBuffer.Length, ReadResult, socket);
Debug.Log("客户端连接成功!");
MsgManager.Instance.Enqueue(MsgID.ConnectSuccess, "客户端连接成功");
}
}
public static ISocket Open(IPAddress address, int port, TimeSpan connectTimeout) {
var timeout = new ManualResetEvent(false);
Exception connectFailure = null;
var tcpClient = new TcpClient();
var ar = tcpClient.BeginConnect(address, port, r => {
try {
tcpClient.EndConnect(r);
} catch(Exception e) {
connectFailure = e;
} finally {
timeout.Set();
}
}, null);
if(!timeout.WaitOne(connectTimeout)) {
tcpClient.EndConnect(ar);
throw new TimeoutException();
}
if(connectFailure != null) {
throw new ConnectException(connectFailure);
}
return new SocketAdapter(tcpClient);
}
public static Future<TcpClient> ConnectTo (string host, int port) {
var f = new Future<TcpClient>();
TcpClient client = new TcpClient();
client.BeginConnect(host, port, (ar) => {
try {
client.EndConnect(ar);
f.Complete(client);
} catch (FutureHandlerException) {
throw;
} catch (Exception ex) {
f.Fail(ex);
client.Close();
}
}, null);
return f;
}
public void CheckAvailable(int timeout)
{
TcpClient FClient = new TcpClient();
var result = FClient.BeginConnect(Server, Port, null, null);
bool success = result.AsyncWaitHandle.WaitOne(timeout, true);
if (success)
{
FClient.EndConnect(result);
FClient.Close();
Available = true;
}
else
{
FClient.Close();
Available = false;
}
}
//public bool ConnectLocking(string host, int port)
//{
// using (var tcp = new TcpClient())
// {
// //add time out here?
// tcp.Connect(host, port);
// return tcp.Connected;
// }
//}
public bool ConnectAPM(string host, int port)
{
using (var tcp = new TcpClient())
{
var ar = tcp.BeginConnect(host, port, null, null);
using (ar.AsyncWaitHandle)
{
//Wait 2 seconds for connection.
if (ar.AsyncWaitHandle.WaitOne(500, false))
{
tcp.EndConnect(ar);
return true;
//Connect was successful.
}
}
}
return false;
}
private static void ConnectTcpSocket(TcpClient client, string hostName, int port, TimeSpan timeout)
{
var ar = client.BeginConnect(hostName, port, null, null);
var wh = ar.AsyncWaitHandle;
try
{
if (!ar.AsyncWaitHandle.WaitOne(timeout, false))
{
client.Close();
throw new TimeoutException();
}
client.EndConnect(ar);
}
finally
{
wh.Close();
}
}
public static void TestUntilConnectionMade(string IPAdress, int port)
{
var client = new TcpClient();
while (!client.Connected)
{
var result = client.BeginConnect(IPAdress, port, null, null);
result.AsyncWaitHandle.WaitOne(500);
if (!client.Connected)
{
Console.WriteLine("Failed to connect.");
Thread.Sleep(5000);
continue;
}
client.EndConnect(result);
}
// we have connected
}
private void ConnectResult(IAsyncResult ar)
{
socket = (System.Net.Sockets.TcpClient)ar.AsyncState;
if (socket.Client != null && socket.Connected)
{
socket.EndConnect(ar);
NetworkStream stream = socket.GetStream();
stream.BeginRead(recvBuffer, 0, recvBuffer.Length, ReadResult, socket);
Debug.Log("客户端连接成功!");
IsConnected = true;
MsgManager.Instance.Dispatch(MsgID.ConnectSuccess, null);
}
else
{
Debug.LogError("客户端连接失败!");
IsConnected = false;
MsgManager.Instance.Dispatch(MsgID.ConnectFailed, null);
}
IsConnecting = false;
}
public static IConnector ConnectSSL(string host, int port, Factory factory, object contextFactory, int timeout, string bindAddress)
{
TcpClient client = new TcpClient();
IAsyncResult ar = client.BeginConnect(host, port, null, null);
WaitHandle wh = ar.AsyncWaitHandle;
try
{
if (!wh.WaitOne(TimeSpan.FromMilliseconds(timeout), false))
{
client.Close();
throw new TimeoutException();
}
client.EndConnect(ar);
}
finally
{
wh.Close();
}
return new SSLConnector(client, factory);
}
private bool SendDTO(ResultDTO dto)
{
if (m_LostConnection) return false;
#if UTT_SOCKETS_SUPPORTED
try
{
using (var tcpClient = new TcpClient())
{
var result = tcpClient.BeginConnect(m_Ip, m_Port, null, null);
var success = result.AsyncWaitHandle.WaitOne(m_ConnectionTimeout);
if (!success)
{
return false;
}
try
{
tcpClient.EndConnect(result);
}
catch (SocketException)
{
m_LostConnection = true;
return false;
}
var bf = new DTOFormatter();
bf.Serialize(tcpClient.GetStream(), dto);
tcpClient.GetStream().Close();
tcpClient.Close();
Debug.Log("Sent " + dto.messageType);
}
}
catch (SocketException e)
{
Debug.LogException(e);
m_LostConnection = true;
return false;
}
#endif // if UTT_SOCKETS_SUPPORTED
return true;
}
private bool SendDTO(ResultDTO dto)
{
if (lostConnection) return false;
#if !UNITY_METRO
try
{
using (var tcpClient = new TcpClient())
{
var result = tcpClient.BeginConnect (ip, port, null, null);
var success = result.AsyncWaitHandle.WaitOne(ConnectionTimeout);
if (!success)
{
return false;
}
try
{
tcpClient.EndConnect (result);
}
catch (SocketException)
{
lostConnection = true;
return false;
}
var bf = new BinaryFormatter();
bf.Serialize(tcpClient.GetStream(), dto);
tcpClient.GetStream().Close ();
tcpClient.Close();
UnityEngine.Debug.Log ("Sent " + dto.messageType);
}
}
catch (SocketException e)
{
UnityEngine.Debug.LogException (e);
lostConnection = true;
return false;
}
#endif
return true;
}
/// <summary>
/// Starts the network handler. (Connects to a minecraft server)
/// </summary>
public void Start() {
try {
_baseSock = new TcpClient();
var ar = _baseSock.BeginConnect(_mainMc.ServerIp, _mainMc.ServerPort, null, null);
using (var wh = ar.AsyncWaitHandle) {
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(5), false)) {
_baseSock.Close();
RaiseSocketError(this, "Failed to connect: Connection Timeout");
return;
}
_baseSock.EndConnect(ar);
}
} catch (Exception e) {
RaiseSocketError(this, "Failed to connect: " + e.Message);
return;
}
_mainMc.Running = true;
RaiseSocketInfo(this, "Connected to server.");
RaiseSocketDebug(this, string.Format("IP: {0} Port: {1}", _mainMc.ServerIp, _mainMc.ServerPort.ToString()));
// -- Create our Wrapped socket.
_baseStream = _baseSock.GetStream();
WSock = new Wrapped(_baseStream);
RaiseSocketDebug(this, "Socket Created");
DoHandshake();
_packetHandlers = new PacketEventHandler(this);
// -- Start network parsing.
_handler = new Thread(NetworkPacketHandler);
_handler.Start();
RaiseSocketDebug(this, "Handler thread started");
}
void ConnectCallback(IAsyncResult ar)
{
try
{
lock (tcpClient)
tcpClient.EndConnect(ar);
BeginReceive();
Status = TcpClientStatus.Connected;
connectEvent.Set();
if (OnConnect != null)
{
OnConnect(this);
}
}
catch (SocketException ex)
{
OnErrorInternal(ex);
}
}
public static bool IsPortOpen(string host, int port, int timeout)
{
try
{
using (var client = new TcpClient())
{
var result = client.BeginConnect(host, port, null, null);
var success = result.AsyncWaitHandle.WaitOne(timeout);
if (!success)
{
return false;
}
client.EndConnect(result);
}
}
catch
{
return false;
}
return true;
}
private static void CallBackMethod(IAsyncResult asyncresult)
{
try
{
IsConnected = false;
TCP.TcpClient tcpclient = asyncresult.AsyncState as TCP.TcpClient;
if (tcpclient.Client != null)
{
tcpclient.EndConnect(asyncresult);
IsConnected = true;
}
}
catch (Exception ex)
{
IsConnected = false;
socketexception = ex;
}
finally
{
tcpConnector.Set();
}
}
private static TcpClient Connect(string host)
{
var timeoutObject = new ManualResetEvent(false);
var connected = false;
Exception exception = null;
var client = new TcpClient();
client.BeginConnect(host, 23, ar =>
{
try
{
connected = false;
if (client.Client != null)
{
client.EndConnect(ar);
connected = true;
}
}
catch (Exception ex)
{
connected = false;
exception = ex;
}
finally
{
timeoutObject.Set();
}
}, null);
if (timeoutObject.WaitOne(5000, false))
{
if (connected) return client;
throw new TelnetException(host, exception.Message);
}
client.Close();
throw new TelnetException(host, "The connection timed out.");
}
protected override TcpClient connectSpecific()
{
TcpClient client = null;
client = new TcpClient();
IAsyncResult result = client.BeginConnect(System.Net.IPAddress.Parse(hostIP), Global.WIFI_PORT, null, null);
do
{
System.Diagnostics.Debug.WriteLine("TCPClient connecting with: " + hostIP);
System.Threading.Thread.Sleep(200);
} while (!result.IsCompleted && isAlive);
if (!isAlive)
client = null;
else
{
try { client.EndConnect(result); }
catch (SocketException) {
client = null;
connectionTimeout = true;
}
}
return client;
}
public bool Connect(string address, int port)
{
_client = new TcpClient();
IAsyncResult result = _client.BeginConnect(address, port, null, null);
WaitHandle timeoutHandler = result.AsyncWaitHandle;
try
{
if (!result.AsyncWaitHandle.WaitOne(2000, false))
{
_client.Close();
return false;
}
_client.EndConnect(result);
}
catch (Exception)
{
return false;
}
finally
{
timeoutHandler.Close();
}
return true;
}
private void Connect(TcpClient socket, AmqpTcpEndpoint endpoint, int timeout)
{
IAsyncResult ar = null;
try
{
ar = socket.BeginConnect(endpoint.HostName, endpoint.Port, null, null);
if (!ar.AsyncWaitHandle.WaitOne(timeout, false))
{
socket.Close();
throw new TimeoutException("Connection to " + endpoint + " timed out");
}
socket.EndConnect(ar);
}
catch (ArgumentException e)
{
throw new ConnectFailureException("Connection failed", e);
}
catch (SocketException e)
{
throw new ConnectFailureException("Connection failed", e);
}
finally
{
if (ar != null)
ar.AsyncWaitHandle.Close();
}
}
/// <summary>
/// Establish a connection to the server.
/// </summary>
public void Connect()
{
if (IsConnected)
{
Logger?.Invoke(_Header + "already connected");
return;
}
else
{
Logger?.Invoke(_Header + "initializing client");
InitializeClient(_Ssl, _PfxCertFilename, _PfxPassword);
Logger?.Invoke(_Header + "connecting to " + ServerIpPort);
}
_TokenSource = new CancellationTokenSource();
_Token = _TokenSource.Token;
IAsyncResult ar = _Client.BeginConnect(_ServerIp, _ServerPort, null, null);
WaitHandle wh = ar.AsyncWaitHandle;
try
{
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(_Settings.ConnectTimeoutMs), false))
{
_Client.Close();
throw new TimeoutException("Timeout connecting to " + ServerIpPort);
}
_Client.EndConnect(ar);
_NetworkStream = _Client.GetStream();
if (_Ssl)
{
if (_Settings.AcceptInvalidCertificates)
{
_SslStream = new SslStream(_NetworkStream, false, new RemoteCertificateValidationCallback(AcceptCertificate));
}
else
{
_SslStream = new SslStream(_NetworkStream, false);
}
_SslStream.AuthenticateAsClient(_ServerIp, _SslCertCollection, SslProtocols.Tls12, !_Settings.AcceptInvalidCertificates);
if (!_SslStream.IsEncrypted)
{
throw new AuthenticationException("Stream is not encrypted");
}
if (!_SslStream.IsAuthenticated)
{
throw new AuthenticationException("Stream is not authenticated");
}
if (_Settings.MutuallyAuthenticate && !_SslStream.IsMutuallyAuthenticated)
{
throw new AuthenticationException("Mutual authentication failed");
}
}
if (_Keepalive.EnableTcpKeepAlives)
{
EnableKeepalives();
}
}
catch (Exception)
{
throw;
}
finally
{
wh.Close();
}
_IsConnected = true;
_LastActivity = DateTime.Now;
_IsTimeout = false;
_Events.HandleConnected(this, new ClientConnectedEventArgs(ServerIpPort));
_DataReceiver = Task.Run(() => DataReceiver(_Token), _Token);
_IdleServerMonitor = Task.Run(() => IdleServerMonitor(), _Token);
}
/// <summary>
/// Establish the connection to the server.
/// </summary>
/// <param name="RemoteIP">The server IP address.</param>
/// <param name="Port">The TCP port on which to connect.</param>
/// <param name="ConnectionTimeout">The timeout for this operation in milliseonds</param>
public void Connect(IPAddress RemoteIP, int Port, int ConnectionTimeout = 5000)
{
Logger.Log(Logger.Level.Info, "Attempting connection to the remote socket");
try
{
if (Port < 0)
{
throw new ArgumentException("Negative values not supported.", nameof(Port));
}
if (ConnectionTimeout < 0)
{
throw new ArgumentException("ConnectionTimeout must be zero or greater.", nameof(ConnectionTimeout));
}
this.RemoteIP = RemoteIP ?? throw new ArgumentNullException("Null values are not supported", nameof(RemoteIP));
this.Port = Port;
TokenSource = new CancellationTokenSource();
Client = new System.Net.Sockets.TcpClient();
Logger.Log(Logger.Level.Debug, $"Timeout: {ConnectionTimeout}");
Logger.Log(Logger.Level.Debug, "Beginning socket connection");
var ar = Client.BeginConnect(RemoteIP, Port, null, null);
try
{
if (!ar.AsyncWaitHandle.WaitOne(ConnectionTimeout, false))
{
Client.Close();
throw new TimeoutException($"Timeout connecting to {this.RemoteIP}:{this.Port}");
}
Client.EndConnect(ar);
Logger.Log(Logger.Level.Info, "Connection to remote socket succeeded");
NetworkStream = Client.GetStream();
Connected = true;
}
catch (Exception)
{
throw;
}
finally
{
ar.AsyncWaitHandle.Close();
}
Logger.Log(Logger.Level.Info, $"Raising the {nameof(ConnectedEvent)} event");
var args = new object[] { this, EventArgs.Empty };
ConnectedEvent.RaiseEventSafe(ref args);
Logger.Log(Logger.Level.Info, $"Starting socket monitoring");
DataReceiverLoop = Task.Run(() => DataReceiver(Token), Token);
}
catch (Exception ex)
{
Logger.Log(Logger.Level.Error, $"Failed to connect to the remote socket.\n\n{ex.Message}");
throw;
}
}
/// <summary>
/// 数据Socket连接服务器的回调函数
/// </summary>
/// <param name="asy"></param>
public void connect_callBack(IAsyncResult asy)
{
#if DEBUG
OESClient.logForm.InsertMsg("In [DataPort.connect_callBack]");
#endif
dataTrans = (TcpClient)asy.AsyncState;
dataTrans.EndConnect(asy);
data_ns = dataTrans.GetStream();
if (ConnectedDataPort != null)
{
ConnectedDataPort(this, null);
}
if (IsSend)
{
SendData();
}
else
{
ReceiveData();
}
}
/// <summary>
/// Establish the connection to the server.
/// </summary>
public void Connect()
{
IAsyncResult ar = _TcpClient.BeginConnect(_ServerIp, _Port, null, null);
WaitHandle wh = ar.AsyncWaitHandle;
try
{
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(_ConnectTimeoutSeconds), false))
{
_TcpClient.Close();
throw new TimeoutException("Timeout connecting to " + _ServerIp + ":" + _Port);
}
_TcpClient.EndConnect(ar);
_NetworkStream = _TcpClient.GetStream();
if (_Ssl)
{
if (AcceptInvalidCertificates)
{
// accept invalid certs
_SslStream = new SslStream(_NetworkStream, false, new RemoteCertificateValidationCallback(AcceptCertificate));
}
else
{
// do not accept invalid SSL certificates
_SslStream = new SslStream(_NetworkStream, false);
}
_SslStream.AuthenticateAsClient(_ServerIp, _SslCertCollection, SslProtocols.Tls12, !AcceptInvalidCertificates);
if (!_SslStream.IsEncrypted)
{
throw new AuthenticationException("Stream is not encrypted");
}
if (!_SslStream.IsAuthenticated)
{
throw new AuthenticationException("Stream is not authenticated");
}
if (MutuallyAuthenticate && !_SslStream.IsMutuallyAuthenticated)
{
throw new AuthenticationException("Mutual authentication failed");
}
}
_Connected = true;
}
catch (Exception)
{
throw;
}
finally
{
wh.Close();
}
if (Connected != null)
{
Task.Run(() => Connected());
}
Task.Run(() => DataReceiver(_Token), _Token);
}
internal void IdentificaComunicacaoAplicacaoLocalRemota()
{
try
{
CaseBusiness.Framework.BancoDados.Entidade.Configuracao conf = null;
CaseBusiness.Framework.BancoDados.Processo.Configuracao confProcesso = new CaseBusiness.Framework.BancoDados.Processo.Configuracao();
conf = confProcesso.BuscarStringConexao(CaseBusiness.Framework.Configuracao.Configuracao.BancoPrincipal);
Boolean conexaoViaIP = true;
if (conf != null)
{
IPAddress ipAddr = null;
String ipOuNome = "";
String host = "";
String[] pIP = null;
Int32 ipOut = Int32.MinValue;
Byte[] ip = new Byte[4];
if (conf.Servidor.IndexOf(@"\") > -1)
{
ipOuNome = conf.Servidor.Remove(conf.Servidor.IndexOf(@"\")).Replace(".", "");
}
else
{
ipOuNome = conf.Servidor.Replace(".", "");
}
if (Int32.TryParse(ipOuNome, out ipOut))
{
if (conf.Servidor.IndexOf(@"\") > -1)
{
pIP = conf.Servidor.Remove(conf.Servidor.IndexOf(@"\")).Split('.');
}
else
{
pIP = conf.Servidor.Split('.');
}
ip[0] = Convert.ToByte(pIP[0]);
ip[1] = Convert.ToByte(pIP[1]);
ip[2] = Convert.ToByte(pIP[2]);
ip[3] = Convert.ToByte(pIP[3]);
ipAddr = new IPAddress(ip);
conexaoViaIP = true;
}
else
{
conexaoViaIP = false;
if (conf.Servidor.IndexOf(@"\") > -1)
{
host = conf.Servidor.Remove(conf.Servidor.IndexOf(@"\"));
}
else
{
host = conf.Servidor;
}
}
using (System.Net.Sockets.TcpClient tcpSocket = new System.Net.Sockets.TcpClient())
{
IAsyncResult async = null;
if (conexaoViaIP)
{
async = tcpSocket.BeginConnect(ipAddr, Convert.ToInt32(conf.Porta), new AsyncCallback(Result), null);
}
else
{
async = tcpSocket.BeginConnect(host, Convert.ToInt32(conf.Porta), new AsyncCallback(Result), null);
}
DateTime startTime = DateTime.Now;
do
{
System.Threading.Thread.Sleep(500);
if (async.IsCompleted)
{
break;
}
}while (DateTime.Now.Subtract(startTime).TotalSeconds < 5);
if (async.IsCompleted)
{
tcpSocket.EndConnect(async);
CaseBusiness.Framework.Configuracao.Configuracao._tipoComunicacao = TipoComunicacao.Local;
}
tcpSocket.Close();
if (!async.IsCompleted)
{
//DataSet ds = null;
//CaseWSFramework.FrameworkSoapClient fWS = new CaseWSFramework.FrameworkSoapClient();
//CaseWSFramework.App app = CaseWSFramework.App.CaseManagerCliente;
//ds = fWS.BuscarConfiguracao(app);
//CaseBusiness.Framework.Configuracao.Configuracao._tipoComunicacao = TipoComunicacao.Remota;
}
}
}
}
catch (SocketException)
{
//DataSet ds = null;
//CaseWSFramework.FrameworkSoapClient fWS = new CaseWSFramework.FrameworkSoapClient();
//CaseWSFramework.App app = CaseWSFramework.App.CaseManagerCliente;
//ds = fWS.BuscarConfiguracao(app);
//CaseBusiness.Framework.Configuracao.Configuracao._tipoComunicacao = TipoComunicacao.Remota;
}
catch (System.Exception ex)
{
CaseBusiness.Framework.Configuracao.Configuracao._erroInicializacao = "Erro: " + ex.Message;
CaseBusiness.Framework.Log.Log.LogarArquivo("Erro: " + ex.Message + " " + ex.StackTrace, CaseBusiness.Framework.Log.TipoEventoLog.Erro, "Case Framework");
if (ex.InnerException != null)
{
CaseBusiness.Framework.Log.Log.LogarArquivo("Erro: " + ex.InnerException.ToString() + " " + ex.StackTrace, CaseBusiness.Framework.Log.TipoEventoLog.Erro, "Case Framework");
}
throw;
}
}
static void Main(string[] args)
{
try
{
if (args.Length == 2)
{
int port = 0;
string host = args[0];
try
{
port = Convert.ToInt32(args[1]);
}
catch (FormatException)
{
Console.WriteLine("");
Console.WriteLine("Could not parse port number.");
Console.WriteLine("");
Environment.Exit(2);
}
System.Net.Sockets.TcpClient tcpclient = new System.Net.Sockets.TcpClient();
IAsyncResult connection = tcpclient.BeginConnect(host, port, null, null);
System.Threading.WaitHandle waithandle = connection.AsyncWaitHandle;
tcpclient.SendTimeout = 3000;
try
{
if (!connection.AsyncWaitHandle.WaitOne(tcpclient.SendTimeout, false))
{
tcpclient.Close();
throw new TimeoutException();
}
tcpclient.EndConnect(connection);
Console.WriteLine("");
Console.WriteLine("Successfully connected to server.");
Console.WriteLine("");
Environment.Exit(1);
}
catch (TimeoutException)
{
Console.WriteLine("");
Console.WriteLine("The connection attempt timed out.");
Console.WriteLine("");
Environment.Exit(2);
}
catch (SocketException)
{
Console.WriteLine("");
Console.WriteLine("Connection actively refused.");
Console.WriteLine("");
}
finally
{
waithandle.Close();
}
}
else
{
throw new ArgumentOutOfRangeException();
}
}
catch (ArgumentOutOfRangeException)
{
Console.WriteLine("");
Console.WriteLine("Invalid arguments");
Console.WriteLine("");
Environment.Exit(2);
}
}
void connect()
{
client = new TcpClient();
//Notify we are connecting
var eoc = this.OnConnecting;
if (eoc != null)
eoc(this.appleSettings.Host, this.appleSettings.Port);
try
{
var connectDone = new AutoResetEvent(false);
//Connect async so we can utilize a connection timeout
connectAsyncResult = client.BeginConnect(
appleSettings.Host, appleSettings.Port,
new AsyncCallback(
delegate(IAsyncResult ar)
{
if (connectAsyncResult != ar)
return;
try
{
client.EndConnect(ar);
//Set keep alive on the socket may help maintain our APNS connection
//client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
//Really not sure if this will work on MONO....
try { client.SetSocketKeepAliveValues(20 * 60 * 1000, 30 * 1000); }
catch { }
Interlocked.Increment(ref reconnects);
//Trigger the reset event so we can continue execution below
connectDone.Set();
}
catch (Exception ex)
{
Log.Error("APNS Connect Callback Failed: " + ex);
}
}
), client
);
if (!connectDone.WaitOne(appleSettings.ConnectionTimeout))
{
throw new TimeoutException("Connection to Host Timed Out!");
}
}
catch (Exception ex)
{
throw new ConnectionFailureException("Connection to Host Failed", ex);
}
if (appleSettings.SkipSsl)
{
networkStream = client.GetStream();
}
else
{
RemoteCertificateValidationCallback userCertificateValidation;
if (appleSettings != null && appleSettings.ValidateServerCertificate)
{
userCertificateValidation = ValidateRemoteCertificate;
}
else
{
userCertificateValidation = (sender, cert, chain, sslPolicyErrors) => true; //Don't validate remote cert
}
stream = new SslStream(client.GetStream(), false,
userCertificateValidation,
(sender, targetHost, localCerts, remoteCert, acceptableIssuers) => certificate);
try
{
stream.AuthenticateAsClient(this.appleSettings.Host, this.certificates, System.Security.Authentication.SslProtocols.Ssl3, false);
//stream.AuthenticateAsClient(this.appleSettings.Host);
}
catch (System.Security.Authentication.AuthenticationException ex)
{
throw new ConnectionFailureException("SSL Stream Failed to Authenticate as Client", ex);
}
if (!stream.IsMutuallyAuthenticated)
throw new ConnectionFailureException("SSL Stream Failed to Authenticate", null);
if (!stream.CanWrite)
throw new ConnectionFailureException("SSL Stream is not Writable", null);
networkStream = stream;
}
//Start reading from the stream asynchronously
Reader();
}
public void Connect(Uri address)
{
IPAddress ip;
if (address.HostNameType == UriHostNameType.Dns)
ip = LookupDNS(address.Host);
else
ip = IPAddress.Parse(address.Host);
if (ip == null)
throw new HttpFetchException("No DNS for " + address.Host);
//TODO: loop for all dns ips on connect failures
var tcp = new TcpClient();
var result = tcp.BeginConnect(ip, address.Port, null, null);
if (!result.AsyncWaitHandle.WaitOne(ConnectTimeout, true))
{
tcp.Close();
throw new HttpFetchException("Timeout connecting to " + ip);
}
tcp.EndConnect(result);
socket = tcp.Client;
stream = tcp.GetStream();
if (address.Scheme == "https")
{
//Broken in mono with newer ciphers
/*
var ssl = new SslStream(stream, false, VerifyCert);
ssl.AuthenticateAsClient(address.Host);
stream = ssl;*/
var handler = new TlsClientProtocol(stream, new SecureRandom());
handler.Connect(new MyTlsClient(address.Host));
stream = handler.Stream;
}
reader = new StreamLineReader(stream);
Console.WriteLine("Connected to " + socket.RemoteEndPoint + "(" + address.Host + ")");
}
private IEnumerator<int> SendInternal(AsyncEnumerator ae)
{
try
{
using (var client = new TcpClient())
{
try
{
client.BeginConnect(Destination.Host, Destination.Port,
ae.End(),
null);
}
catch (Exception exception)
{
logger.WarnFormat("Failed to connect to {0} because {1}", Destination, exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
client.EndConnect(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Failed to connect to {0} because {1}", Destination, exception);
Failure(exception);
yield break;
}
logger.DebugFormat("Successfully connected to {0}", Destination);
using (var stream = client.GetStream())
{
var buffer = Messages.Serialize();
var bufferLenInBytes = BitConverter.GetBytes(buffer.Length);
logger.DebugFormat("Writing length of {0} bytes to {1}", buffer.Length, Destination);
try
{
stream.BeginWrite(bufferLenInBytes, 0, bufferLenInBytes.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
logger.DebugFormat("Writing {0} bytes to {1}", buffer.Length, Destination);
try
{
stream.BeginWrite(buffer, 0, buffer.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Could not write to {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
logger.DebugFormat("Successfully wrote to {0}", Destination);
var recieveBuffer = new byte[ProtocolConstants.RecievedBuffer.Length];
var readConfirmationEnumerator = new AsyncEnumerator();
try
{
readConfirmationEnumerator.BeginExecute(
StreamUtil.ReadBytes(recieveBuffer, stream, readConfirmationEnumerator, "recieve confirmation", false), ae.End());
}
catch (Exception exception)
{
logger.WarnFormat("Could not read confirmation from {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
readConfirmationEnumerator.EndExecute(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Could not read confirmation from {0} because {1}", Destination,
exception);
Failure(exception);
yield break;
}
var recieveRespone = Encoding.Unicode.GetString(recieveBuffer);
if (recieveRespone == ProtocolConstants.QueueDoesNotExists)
{
logger.WarnFormat(
"Response from reciever {0} is that queue does not exists",
Destination);
Failure(new QueueDoesNotExistsException());
yield break;
}
else if(recieveRespone!=ProtocolConstants.Recieved)
{
logger.WarnFormat(
"Response from reciever {0} is not the expected one, unexpected response was: {1}",
Destination, recieveRespone);
Failure(null);
yield break;
}
try
{
stream.BeginWrite(ProtocolConstants.AcknowledgedBuffer, 0,
ProtocolConstants.AcknowledgedBuffer.Length, ae.End(), null);
}
catch (Exception exception)
{
logger.WarnFormat("Failed to write acknowledgement to reciever {0} because {1}",
Destination, exception);
Failure(exception);
yield break;
}
yield return 1;
try
{
stream.EndWrite(ae.DequeueAsyncResult());
}
catch (Exception exception)
{
logger.WarnFormat("Failed to write acknowledgement to reciever {0} because {1}",
Destination, exception);
Failure(exception);
yield break;
}
var bookmarks = Success();
buffer = new byte[ProtocolConstants.RevertBuffer.Length];
var readRevertMessage = new AsyncEnumerator(ae.ToString());
bool startingToReadFailed = false;
try
{
readRevertMessage.BeginExecute(
StreamUtil.ReadBytes(buffer, stream, readRevertMessage, "revert", true), ae.End());
}
catch (Exception)
{
//more or less expected
startingToReadFailed = true;
}
if (startingToReadFailed)
yield break;
yield return 1;
try
{
readRevertMessage.EndExecute(ae.DequeueAsyncResult());
var revert = Encoding.Unicode.GetString(buffer);
if (revert == ProtocolConstants.Revert)
{
logger.Warn("Got back revert message from receiver, reverting send");
Revert(bookmarks);
}
}
catch (Exception)
{
// expected, there is nothing to do here, the
// reciever didn't report anything for us
}
}
}
}
finally
{
var completed = SendCompleted;
if (completed != null)
completed();
}
}
private TcpClient CreateTcpConnection(string host, int port)
{
TcpClient tcpClient;
if (_currentProxy == null)
{
#region Создание подключения
tcpClient = new TcpClient();
Exception connectException = null;
var connectDoneEvent = new ManualResetEventSlim();
try
{
tcpClient.BeginConnect(host, port, new AsyncCallback(
(ar) =>
{
try
{
tcpClient.EndConnect(ar);
}
catch (Exception ex)
{
connectException = ex;
}
connectDoneEvent.Set();
}), tcpClient
);
}
#region Catch's
catch (Exception ex)
{
tcpClient.Close();
if (ex is SocketException || ex is SecurityException)
{
throw NewHttpException(Resources.HttpException_FailedConnect, ex, HttpExceptionStatus.ConnectFailure);
}
throw;
}
#endregion
if (!connectDoneEvent.Wait(_connectTimeout))
{
tcpClient.Close();
throw NewHttpException(Resources.HttpException_ConnectTimeout, null, HttpExceptionStatus.ConnectFailure);
}
if (connectException != null)
{
tcpClient.Close();
if (connectException is SocketException)
{
throw NewHttpException(Resources.HttpException_FailedConnect, connectException, HttpExceptionStatus.ConnectFailure);
}
throw connectException;
}
if (!tcpClient.Connected)
{
tcpClient.Close();
throw NewHttpException(Resources.HttpException_FailedConnect, null, HttpExceptionStatus.ConnectFailure);
}
#endregion
tcpClient.SendTimeout = _readWriteTimeout;
tcpClient.ReceiveTimeout = _readWriteTimeout;
}
else
{
try
{
tcpClient = _currentProxy.CreateConnection(host, port);
}
catch (ProxyException ex)
{
throw NewHttpException(Resources.HttpException_FailedConnect, ex, HttpExceptionStatus.ConnectFailure);
}
}
return tcpClient;
}
/// <summary>
/// Establish the connection to the server.
/// </summary>
public void Connect(int timeoutSeconds)
{
if (timeoutSeconds < 1)
{
throw new ArgumentException("TimeoutSeconds must be greater than zero seconds.");
}
IAsyncResult ar = _TcpClient.BeginConnect(_ServerIp, _ServerPort, null, null);
WaitHandle wh = ar.AsyncWaitHandle;
try
{
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(timeoutSeconds), false))
{
_TcpClient.Close();
throw new TimeoutException("Timeout connecting to " + _ServerIp + ":" + _ServerPort);
}
_TcpClient.EndConnect(ar);
_NetworkStream = _TcpClient.GetStream();
if (_Ssl)
{
if (AcceptInvalidCertificates)
{
// accept invalid certs
_SslStream = new SslStream(_NetworkStream, false, new RemoteCertificateValidationCallback(AcceptCertificate));
}
else
{
// do not accept invalid SSL certificates
_SslStream = new SslStream(_NetworkStream, false);
}
_SslStream.AuthenticateAsClient(_ServerIp, _SslCertCollection, SslProtocols.Tls12, !AcceptInvalidCertificates);
if (!_SslStream.IsEncrypted)
{
throw new AuthenticationException("Stream is not encrypted");
}
if (!_SslStream.IsAuthenticated)
{
throw new AuthenticationException("Stream is not authenticated");
}
if (MutuallyAuthenticate && !_SslStream.IsMutuallyAuthenticated)
{
throw new AuthenticationException("Mutual authentication failed");
}
}
}
catch (Exception)
{
throw;
}
finally
{
wh.Close();
}
Stats = new Statistics();
Logger?.Invoke("Starting connection monitor for: " + _ServerIp + ":" + _ServerPort);
Task unawaited = Task.Run(() => ClientConnectionMonitor());
ClientConnected?.Invoke(this, EventArgs.Empty);
_IsConnected = true;
}