/// <summary>
/// Processes to send a <see cref="Message"/> using the specified <see cref="SocketAsyncEventArgs"/>.
/// </summary>
/// <param name="AsyncEvent">The <see cref="SocketAsyncEventArgs"/> instance containing the event data.</param>
private static void ProcessSend(SocketAsyncEventArgs AsyncEvent)
{
NetworkToken Token = (NetworkToken)AsyncEvent.UserToken;
if (AsyncEvent.SocketError == SocketError.Success)
{
if (AsyncEvent.Count > AsyncEvent.BytesTransferred)
{
int Offset = AsyncEvent.Offset + AsyncEvent.BytesTransferred;
if (Token.IsConnected)
{
AsyncEvent.SetBuffer(Offset, AsyncEvent.Buffer.Length - Offset);
if (!Token.Socket.SendAsync(AsyncEvent))
{
NetworkTcp.ProcessSend(AsyncEvent);
}
return;
}
NetworkTcp.Disconnect(Token.AsyncEvent);
}
}
else
{
NetworkTcp.Disconnect(Token.AsyncEvent);
}
NetworkTcp.OnSendCompleted(null, AsyncEvent);
}
/// <summary>
/// Called when [receive completed].
/// </summary>
/// <param name="Sender">The sender.</param>
/// <param name="AsyncEvent">The <see cref="SocketAsyncEventArgs"/> instance containing the event data.</param>
private static void OnReceiveCompleted(object Sender, SocketAsyncEventArgs AsyncEvent)
{
if (AsyncEvent.SocketError == SocketError.Success)
{
NetworkTcp.ProcessReceive(AsyncEvent);
}
else
{
NetworkTcp.Disconnect(AsyncEvent);
}
}
/// <summary>
/// Called when the client has been connected.
/// </summary>
/// <param name="Sender">The sender.</param>
/// <param name="AsyncEvent">The <see cref="SocketAsyncEventArgs"/> instance containing the event data.</param>
private static void OnConnectCompleted(object Sender, SocketAsyncEventArgs AsyncEvent)
{
if (AsyncEvent.SocketError == SocketError.Success)
{
((ManualResetEventSlim)AsyncEvent.UserToken).Set();
}
else
{
NetworkTcp.Disconnect(AsyncEvent);
}
}
/// <summary>
/// Finalizes this instance.
/// </summary>
public void Process()
{
byte[] Buffer = this.Packet.ToArray();
if (Buffer.Length >= 7)
{
this.TcpProcess(Buffer);
}
else
{
NetworkTcp.Disconnect(this.AsyncEvent);
}
}
/// <summary>
/// Receives data from the specified client.
/// </summary>
/// <param name="AsyncEvent">The <see cref="SocketAsyncEventArgs"/> instance containing the event data.</param>
private static void ProcessReceive(SocketAsyncEventArgs AsyncEvent)
{
if (AsyncEvent.BytesTransferred == 0)
{
NetworkTcp.Disconnect(AsyncEvent);
}
if (AsyncEvent.SocketError != SocketError.Success)
{
NetworkTcp.Disconnect(AsyncEvent);
}
NetworkToken Token = (NetworkToken)AsyncEvent.UserToken;
if (Token.IsConnected)
{
Token.AddData();
try
{
if (Token.Socket.Available == 0)
{
Token.Process();
}
if (Token.IsFailing == false)
{
if (!Token.Socket.ReceiveAsync(AsyncEvent))
{
NetworkTcp.ProcessReceive(AsyncEvent);
}
}
else
{
NetworkTcp.Disconnect(AsyncEvent);
}
}
catch (Exception Exception)
{
Logging.Warning(typeof(NetworkTcp), Exception.GetType().Name + " thrown at ProcessReceive(" + AsyncEvent.RemoteEndPoint + ").");
NetworkTcp.Disconnect(AsyncEvent);
}
}
else
{
NetworkTcp.Disconnect(AsyncEvent);
}
}
/// <summary>
/// Sends the specified message.
/// </summary>
/// <param name="Buffer">The buffer.</param>
/// <param name="Token">The token.</param>
public static void Send(byte[] Buffer, NetworkToken Token)
{
if (Buffer == null)
{
throw new ArgumentNullException(nameof(Message), "Buffer == null at Send(Buffer, Token).");
}
if (Token == null)
{
throw new ArgumentNullException(nameof(Token), "Token == null at Send(Buffer, Token).");
}
if (Token.IsConnected)
{
SocketAsyncEventArgs WriteEvent = NetworkTcp.WritePool.Dequeue();
if (WriteEvent == null)
{
WriteEvent = new SocketAsyncEventArgs
{
DisconnectReuseSocket = false
};
}
WriteEvent.SetBuffer(Buffer, 0, Buffer.Length);
WriteEvent.AcceptSocket = Token.Socket;
WriteEvent.RemoteEndPoint = Token.Socket.RemoteEndPoint;
WriteEvent.UserToken = Token;
if (!Token.Socket.SendAsync(WriteEvent))
{
NetworkTcp.ProcessSend(WriteEvent);
}
}
else
{
NetworkTcp.Disconnect(Token.AsyncEvent);
}
}
/// <summary>
/// Receives the message.
/// </summary>
public void ReceiveMessage(short Type, short Version, byte[] Packet)
{
if (this.ReceiveEncrypter == null)
{
if (this.PepperInit.State == 0)
{
if (Type == 10101)
{
this.SendEncrypter = new Rc4Encrypter("fhsd6f86f67rt8fw78fw789we78r9789wer6re", "nonce");
this.ReceiveEncrypter = new Rc4Encrypter("fhsd6f86f67rt8fw78fw789we78r9789wer6re", "nonce");
Packet = this.ReceiveEncrypter.Decrypt(Packet);
}
else if (Type == 10100)
{
Packet = PepperCrypto.HandlePepperAuthentification(ref this.PepperInit, Packet);
}
else
{
Packet = null;
}
}
else
{
if (this.PepperInit.State == 2)
{
Packet = Type == 10101 ? PepperCrypto.HandlePepperLogin(ref this.PepperInit, Packet) : null;
}
else
{
Packet = null;
}
}
}
else
{
Packet = this.ReceiveEncrypter.Decrypt(Packet);
}
if (Packet != null)
{
if (this.Device.State != State.Logged)
{
if (Type != 10100 && Type != 10101)
{
if (++this.InvalidMessageStateCnt >= 5)
{
NetworkTcp.Disconnect(this.Device.Token.AsyncEvent);
}
return;
}
}
using (ByteStream Stream = new ByteStream(Packet))
{
Message Message = MessageFactory.CreateMessage(Type, Stream);
if (Message != null)
{
Logging.Info(this.GetType(), "Receiving " + Message.GetType().Name + ".");
if (this.RequestTime.CanHandleMessage(Message))
{
try
{
Message.Decode();
}
catch (Exception Exception)
{
Logging.Error(this.GetType(), "ReceiveMessage() - An error has been throwed when the message type " + Message.Type + " has been processed. " + Exception);
}
HandlerFactory.MessageHandle(this.Device, Message); // TODO : Probably call Task.Wait().
}
}
else
{
Logging.Info(this.GetType(), BitConverter.ToString(Stream.ReadBytes(Stream.BytesLeft)));
}
}
}
else
{
if (this.Device.State == State.Logged)
{
Logging.Error(this.GetType(), "Packet == null at ReceiveMessage().");
}
}
}
