/// <summary>
/// Inicia o recebimento de dados assincrono.
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public override CommunicationResult BeginReceive(Action <byte[], System.Net.IPEndPoint> action)
{
CommunicationResult success = CommunicationResult.Success;
lock (this._lockObject)
{
CommunicationResult result2 = Bind(LocalEndPoint);
if (result2 == 0)
{
return(result2);
}
_isReceiving = true;
_actionCallBack = action;
try
{
_udpClient.BeginReceive(new AsyncCallback(UdpClientReceive), _udpClient);
}
catch (SocketException exception)
{
success = new CommunicationResult(exception.ErrorCode);
}
catch (InvalidOperationException)
{
success = CommunicationResult.Closed;
}
}
return(HandleResult(success));
}
/// <summary>
/// Despacha os dados para o endPoint informado.
/// </summary>
/// <param name="data"></param>
/// <param name="size"></param>
/// <param name="remoteEndPoint"></param>
/// <returns></returns>
private CommunicationResult Dispatch(byte[] data, int size, System.Net.IPEndPoint remoteEndPoint)
{
CommunicationResult success = CommunicationResult.Success;
lock (_lockObject)
{
CommunicationResult result2 = Bind(LocalEndPoint);
if (result2 == 0)
{
return(result2);
}
try
{
_udpClient.Send(data, size, remoteEndPoint);
}
catch (ArgumentNullException)
{
success = CommunicationResult.SendFailed;
}
catch (ObjectDisposedException)
{
success = CommunicationResult.Closed;
}
catch (InvalidOperationException)
{
success = CommunicationResult.SendFailed;
}
catch (SocketException exception)
{
success = new CommunicationResult(exception.ErrorCode);
}
}
return(HandleResult(success));
}
/// <summary>
/// Vincula o EndPoint.
/// </summary>
/// <param name="localEndPoint"></param>
/// <returns></returns>
private CommunicationResult Bind(System.Net.IPEndPoint localEndPoint)
{
CommunicationResult success = CommunicationResult.Success;
lock (this._lockObject)
{
if (_udpClient != null)
{
if (!this._needBinding)
{
return(CommunicationResult.Success);
}
_udpClient.Close();
_udpClient = null;
}
try
{
_udpClient = new UdpClient(localEndPoint);
_needBinding = false;
}
catch (SocketException exception)
{
_udpClient = new UdpClient();
success = new CommunicationResult(exception.ErrorCode);
}
}
return(HandleResult(success));
}
/// <summary>
/// Recebe os dados de forma assincrona.
/// </summary>
/// <param name="receiveAction"></param>
/// <param name="timeoutAction"></param>
/// <param name="expectResponse"></param>
/// <returns></returns>
public override CommunicationResult ReceiveAsync(Action <byte[], System.Net.IPEndPoint> receiveAction, Action <System.Net.IPEndPoint> timeoutAction, bool expectResponse)
{
System.Threading.ThreadStart start = delegate {
byte[] data = null;
CommunicationResult result = CommunicationResult.ReceiveFailed;
int tcpTimeout = this.TcpTimeout;
while (true)
{
lock (_tcpLock)
{
if (Stream == null)
{
result = CommunicationResult.Closed;
break;
}
if (this.DataAvailable)
{
result = this.ReceiveBase(out data);
break;
}
}
if (tcpTimeout <= 0)
{
result = CommunicationResult.Timeout;
break;
}
System.Threading.Thread.Sleep(Math.Min(10, tcpTimeout));
tcpTimeout = Math.Max(tcpTimeout - 10, 0);
}
if (result == 0)
{
if ((result == CommunicationResult.Timeout) || (result == 0x274c))
{
timeoutAction(RemoteEndPoint);
}
if (expectResponse)
{
HandleResult(result);
}
}
else
{
receiveAction(data, this.RemoteEndPoint);
}
};
try
{
new System.Threading.Thread(start).Start();
}
catch (ArgumentNullException)
{
return(this.HandleResult(CommunicationResult.ReceiveFailed));
}
catch (System.Threading.ThreadStateException)
{
return(this.HandleResult(CommunicationResult.ReceiveFailed));
}
return(CommunicationResult.Success);
}
/// <summary>
/// Inicia o processo assincrono para recebimento dos dados.
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public CommunicationResult BeginReceive(Action <byte[]> action)
{
try
{
lock (_actionLock)
_actionCallBack = action;
LogAccessor.Log.Verbose("<TCP> Begin Receive");
this.ReadBuffer();
CommunicationResult success = CommunicationResult.Success;
lock (_tcpLock)
{
if (_receiving || ((_readResult != null) && !_readResult.IsCompleted))
{
LogAccessor.Log.Verbose("<TCP> Already Receiving=>Skip Begin Receive");
}
else if (this.Stream == null)
{
success = CommunicationResult.Closed;
LogAccessor.Log.Verbose("<TCP> Connection is Closed=>Skip Begin Receive");
}
else
{
byte[] data = new byte[1024];
TcpCommunicationState state = new TcpCommunicationState(data);
_receiving = true;
_readResult = Stream.BeginRead(data, 0, data.Length, new AsyncCallback(TcpStreamReceived), state);
}
}
return(HandleResult(success));
}
catch (System.IO.IOException)
{
_receiving = false;
return(this.HandleResult(CommunicationResult.Closed));
}
catch (ObjectDisposedException)
{
_receiving = false;
return(HandleResult(CommunicationResult.Closed));
}
catch (ArgumentException)
{
_receiving = false;
}
catch (NotSupportedException)
{
_receiving = false;
return(HandleResult(CommunicationResult.Closed));
}
catch (InvalidOperationException)
{
_receiving = false;
return(HandleResult(CommunicationResult.Closed));
}
return(HandleResult(CommunicationResult.ReceiveFailed));
}
/// <summary>
/// Envia os dados.
/// </summary>
/// <param name="data">Dados que serão enviados.</param>
/// <param name="size">Tamanho dos dados.</param>
/// <returns></returns>
public override CommunicationResult Send(byte[] data, int size)
{
CommunicationResult success = CommunicationResult.Success;
try
{
lock (_tcpLock)
{
if (Stream != null)
{
Stream.Write(data, 0, size);
Stream.Flush();
}
else
{
success = CommunicationResult.Closed;
}
}
if ((success != 0) && (base.RemoteEndPoint != null))
{
LogAccessor.Log.Verbose("<TCP>Sent to [{0}]: {1}", base.RemoteEndPoint.ToString(), BinaryTransformer.GetString(data, 0, size));
}
}
catch (ArgumentNullException)
{
return(this.HandleResult(CommunicationResult.SendFailed));
}
catch (ArgumentOutOfRangeException)
{
return(this.HandleResult(CommunicationResult.SendFailed));
}
catch (ArgumentException)
{
return(this.HandleResult(CommunicationResult.SendFailed));
}
catch (NotSupportedException)
{
return(this.HandleResult(CommunicationResult.SendFailed));
}
catch (ObjectDisposedException)
{
return(this.HandleResult(CommunicationResult.Closed));
}
catch (System.IO.IOException exception)
{
var innerException = exception.InnerException as System.Net.Sockets.SocketException;
if (innerException != null)
{
return(HandleResult(new CommunicationResult(innerException.ErrorCode)));
}
return(HandleResult(CommunicationResult.Closed));
}
return(HandleResult(success));
}
/// <summary>
/// Tranta o resultado.
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
private CommunicationResult HandleResult(CommunicationResult result)
{
if (result == 0)
{
this.LastError = result;
LogAccessor.Log.Info(result.GetDebugInfo());
if (ErrorOccurred != null)
{
ErrorOccurred(this, new CommunicationErrorEventArgs(CommunicationProtocol.Tcp, result));
}
}
return(result);
}
/// <summary>
/// Trata o resultado da comunicação.
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
private CommunicationResult HandleResult(CommunicationResult result)
{
if (result == 0)
{
if ((result != CommunicationResult.Closed) || this._isReceiving)
{
LogAccessor.Log.Info(result.GetDebugInfo());
}
if (ErrorOccurred != null)
{
ErrorOccurred(this, new CommunicationErrorEventArgs(CommunicationProtocol.Udp, result));
}
}
return(result);
}
/// <summary>
/// Recebe os dados.
/// </summary>
/// <param name="data">Buffer dos dados recebidos.</param>
/// <param name="expectedSize">Tamanho esperado.</param>
/// <returns></returns>
public CommunicationResult Receive(out byte[] data, int expectedSize)
{
CommunicationResult receiveFailed = CommunicationResult.ReceiveFailed;
lock (_tcpLock)
receiveFailed = _reader.ReadStream(this.Stream, out data, expectedSize);
if (receiveFailed == 0)
{
return(HandleResult(receiveFailed));
}
if (base.RemoteEndPoint != null)
{
LogAccessor.Log.Verbose("<TCP>Received from [{0}]: {1}", base.RemoteEndPoint.ToString(), BinaryTransformer.GetString(data, 0, data.Length));
}
return(receiveFailed);
}
/// <summary>
/// Construtor estático.
/// </summary>
static CommunicationResult()
{
Success = new CommunicationResult(0);
Closed = new CommunicationResult(2);
AlreadyOpen = new CommunicationResult(1);
OpenFailed = new CommunicationResult(3);
Timeout = new CommunicationResult(4);
SendFailed = new CommunicationResult(5);
ReceiveFailed = new CommunicationResult(6);
AddressUsed = new CommunicationResult(0x2740);
Dictionary <int, string> dictionary = new Dictionary <int, string>();
dictionary.Add(4, Properties.Resources.CommunicationReader_FormatErrorTimeout);
dictionary.Add(0x1c4, Properties.Resources.CommunicationReader_FormatErrorFtpDiskFull);
dictionary.Add(0x228, Properties.Resources.CommunicationReader_FormatErrorFtpDiskFull);
dictionary.Add(0x274c, Properties.Resources.CommunicationReader_FormatErrorTimeout);
dictionary.Add(0x3f0, Properties.Resources.CommunicationReader_FormatErrorNoOpFailed);
_resultDictionary = dictionary;
}
/// <summary>
/// Método base para recebimento dos dados.
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
private CommunicationResult ReceiveBase(out byte[] data)
{
CommunicationResult receiveFailed = CommunicationResult.ReceiveFailed;
data = null;
try
{
lock (_tcpLock)
{
if (_tcpClient == null)
{
receiveFailed = CommunicationResult.Closed;
}
else
{
_tcpClient.Client.Blocking = true;
receiveFailed = _reader.ReadStream(this.Stream, out data);
}
}
}
catch (System.Net.Sockets.SocketException exception)
{
receiveFailed = new CommunicationResult(exception.ErrorCode);
}
catch (ObjectDisposedException)
{
receiveFailed = CommunicationResult.Closed;
}
if ((receiveFailed != 0) && (base.RemoteEndPoint != null) && data != null)
{
LogAccessor.Log.Verbose("<TCP>Received from [{0}]: {1}", new object[] {
base.RemoteEndPoint.ToString(),
BinaryTransformer.GetString(data, 0, data.Length)
});
}
return(receiveFailed);
}
/// <summary>
/// Abrea a comunicação.
/// </summary>
/// <returns></returns>
public override CommunicationResult Open()
{
CommunicationResult result = CommunicationResult.OpenFailed;
try
{
lock (_tcpLock)
{
LastError = CommunicationResult.Success;
if ((_tcpClient == null) || (_tcpClient.Client == null))
{
_tcpClient = new System.Net.Sockets.TcpClient();
_receiving = false;
_readResult = null;
}
AsyncCallback callback2 = null;
using (var resetEvent = new System.Threading.ManualResetEvent(false))
{
if (callback2 == null)
{
callback2 = delegate(IAsyncResult asyncResult) {
result = TryOpen(asyncResult);
try
{
resetEvent.Set();
}
catch (NullReferenceException)
{
}
catch (ObjectDisposedException)
{
}
};
}
AsyncCallback requestCallback = callback2;
if ((_tcpClient == null) || (_tcpClient.Client == null))
{
return(CommunicationResult.OpenFailed);
}
_tcpClient.BeginConnect(RemoteEndPoint.Address, base.RemoteEndPoint.Port, requestCallback, _tcpClient);
if (!resetEvent.WaitOne(TcpTimeout, true))
{
try
{
_tcpClient.Close();
}
finally
{
result = CommunicationResult.OpenFailed;
}
}
}
}
}
catch (ArgumentNullException)
{
result = CommunicationResult.OpenFailed;
}
catch (ArgumentOutOfRangeException)
{
result = CommunicationResult.OpenFailed;
}
catch (ObjectDisposedException)
{
result = CommunicationResult.OpenFailed;
}
catch (System.Net.Sockets.SocketException exception)
{
if (exception.ErrorCode == 0x2748)
{
result = CommunicationResult.AlreadyOpen;
}
else
{
result = new CommunicationResult(exception.ErrorCode);
}
}
catch (InvalidOperationException)
{
result = CommunicationResult.OpenFailed;
}
catch (System.Security.SecurityException)
{
result = CommunicationResult.OpenFailed;
}
catch (System.Threading.AbandonedMutexException)
{
result = CommunicationResult.OpenFailed;
}
finally
{
if ((result.ErrorCode == 1) && !this.IsOpen)
{
result = CommunicationResult.OpenFailed;
}
if ((result != 0) || (result.ErrorCode == 1))
{
try
{
_tcpStream = _tcpClient.GetStream();
if (_tcpStream != null)
{
_tcpStream.WriteTimeout = TcpTimeout;
_tcpStream.ReadTimeout = TcpTimeout;
}
}
catch (ObjectDisposedException)
{
result = CommunicationResult.Closed;
}
catch (InvalidOperationException)
{
result = CommunicationResult.Closed;
}
}
else
{
_tcpClient = null;
HandleResult(result);
}
}
return(result);
}
/// <summary>
/// Método acionado quando dados forem recebidos da stream da conexão.
/// </summary>
/// <param name="result"></param>
private void TcpStreamReceived(IAsyncResult result)
{
CommunicationResult success = CommunicationResult.Success;
try
{
int length = 0;
try
{
lock (_tcpLock)
{
_receiving = false;
if (Stream == null)
{
return;
}
length = Stream.EndRead(result);
if (length == 0)
{
if (base.RemoteEndPoint != null)
{
LogAccessor.Log.Verbose("<TCP>Connection closed by remote host [{0}]", new object[] {
base.RemoteEndPoint.ToString()
});
}
success = CommunicationResult.Closed;
return;
}
TcpCommunicationState asyncState = (TcpCommunicationState)result.AsyncState;
if (_actionCallBack != null)
{
byte[] data = asyncState.GetData();
LogAccessor.Log.Verbose("<TCP> Packet: {0}", new object[] {
BinaryTransformer.GetString(data, 0, length, Encoding.ASCII)
});
success = _reader.RegisterBuffer(data, length);
}
}
}
catch (ArgumentNullException)
{
success = CommunicationResult.ReceiveFailed;
return;
}
catch (ArgumentException)
{
success = CommunicationResult.ReceiveFailed;
return;
}
catch (System.IO.IOException)
{
BeginReceive(_actionCallBack);
return;
}
catch (ObjectDisposedException)
{
return;
}
if (success != 0)
{
ReadBuffer();
BeginReceive(_actionCallBack);
}
}
finally
{
HandleResult(success);
}
}
/// <summary>
/// Método acionado quando for recebido uma mensagem do cliente UDP.
/// </summary>
/// <param name="result"></param>
private void UdpClientReceive(IAsyncResult result)
{
CommunicationResult success = CommunicationResult.Success;
try
{
byte[] buffer;
var remoteEP = new System.Net.IPEndPoint(System.Net.IPAddress.Any, 0);
lock (_lockObject)
{
if (base.RemoteEndPoint != null)
{
remoteEP = base.RemoteEndPoint;
}
buffer = _udpClient.EndReceive(result, ref remoteEP);
}
_actionCallBack(buffer, remoteEP);
lock (_lockObject)
{
if (_isReceiving)
{
if (_udpClient == null)
{
success = CommunicationResult.Closed;
}
else
{
_udpClient.BeginReceive(new AsyncCallback(UdpClientReceive), _udpClient);
}
}
}
}
catch (ArgumentNullException)
{
success = CommunicationResult.Closed;
}
catch (ArgumentException)
{
success = CommunicationResult.Closed;
}
catch (ObjectDisposedException)
{
success = CommunicationResult.Closed;
}
catch (InvalidOperationException)
{
success = CommunicationResult.Closed;
}
catch (SocketException exception)
{
success = new CommunicationResult(exception.ErrorCode);
}
catch (NullReferenceException)
{
success = CommunicationResult.Closed;
}
finally
{
HandleResult(success);
}
}
/// <summary>
/// Lê a stream.
/// </summary>
/// <param name="stream"></param>
/// <param name="data"></param>
/// <param name="expectedSize"></param>
/// <returns></returns>
public CommunicationResult ReadStream(Stream stream, out byte[] data, int expectedSize)
{
data = null;
try
{
if (stream == null)
{
return(CommunicationResult.Closed);
}
if (ReadBuffer(out data, expectedSize))
{
return(CommunicationResult.Success);
}
int bufferSize = 0;
byte[] buffer = new byte[1024];
var stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
while ((bufferSize = stream.Read(buffer, 0, 0x400)) != -1)
{
if (bufferSize <= 0)
{
if (stopwatch.Elapsed.TotalMilliseconds >= stream.ReadTimeout)
{
LogAccessor.Log.Verbose("<COMMUNICATION READER> Reading Timeout => Exiting Loop");
return(CommunicationResult.Timeout);
}
}
else
{
CommunicationResult result = RegisterBuffer(buffer, bufferSize);
if (result == 0)
{
return(result);
}
if (ReadBuffer(out data, expectedSize))
{
return(CommunicationResult.Success);
}
}
}
}
catch (ArgumentNullException)
{
return(CommunicationResult.ReceiveFailed);
}
catch (ArgumentOutOfRangeException)
{
return(CommunicationResult.ReceiveFailed);
}
catch (UnauthorizedAccessException)
{
return(CommunicationResult.Closed);
}
catch (ObjectDisposedException)
{
return(CommunicationResult.Closed);
}
catch (IOException exception)
{
var innerException = exception.InnerException as System.Net.Sockets.SocketException;
if (innerException != null)
{
return(new CommunicationResult(innerException.ErrorCode));
}
return(CommunicationResult.Timeout);
}
catch (NotSupportedException)
{
return(CommunicationResult.Closed);
}
catch (System.Net.Sockets.SocketException exception3)
{
return(new CommunicationResult(exception3.ErrorCode));
}
catch (TimeoutException)
{
return(CommunicationResult.Timeout);
}
return(CommunicationResult.ReceiveFailed);
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="protocol"></param>
/// <param name="result"></param>
public CommunicationErrorEventArgs(CommunicationProtocol protocol, CommunicationResult result)
{
Protocol = protocol;
Detail = result;
}
