private void ListenLoop()
{
try
{
while (OscReceiver.State != OscSocketState.Closed)
{
// if we are in a state to receive
if (OscReceiver.State != OscSocketState.Connected)
{
continue;
}
// get the next message
// this will block until one arrives or the socket is closed
OscPacket packet = OscReceiver.Receive();
PacketReceived?.Invoke(packet);
if (packet.Error == OscPacketError.None)
{
OscAddressManager.Invoke(packet);
}
PacketProcessed?.Invoke(packet);
}
}
catch (Exception ex)
{
}
}
private void _processClientPackets()
{
if (_isClosing || !_doPacketProcess)
{
return;
}
_localRecvPackets = _localSecurity.TransferIncoming();
if (_localRecvPackets != null)
{
foreach (var packet in _localRecvPackets)
{
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000 || packet.Opcode == 0x2001)
{
continue;
}
//Send to PacketHandler
PacketReceived?.Invoke(packet);
}
}
_localSendBuffers = _localSecurity.TransferOutgoing();
if (_localSendBuffers == null)
{
return;
}
foreach (var buffer in _localSendBuffers)
{
PacketSend?.Invoke(buffer.Value);
Send(buffer.Key.Buffer);
}
}
private void OnReceiveData(IAsyncResult ar)
{
if (IsConnected)
{
try
{
if (_socket.Poll(0, SelectMode.SelectRead) && _socket.Available <= 0)
{
Disconnect(true);
}
else
{
byte[] data = _buffer;
if (_encryption != null)
{
data = _encryption.Decrypt(data);
}
PacketReceived?.Invoke(this, PBEPacketProcessor.CreatePacket(Battle, data));
BeginReceive();
}
}
catch (Exception ex)
{
NotifyError(ex);
Disconnect(true);
}
}
}
public bool TryReceive()
{
// if we are in a state to receive
if (OscReceiver?.State != OscSocketState.Connected)
{
return(false);
}
// try and get the next message
bool packetReceived = OscReceiver.TryReceive(out OscPacket packet);
if (packetReceived == false)
{
return(false);
}
PacketReceived?.Invoke(packet);
if (packet?.Error == OscPacketError.None)
{
OscAddressManager.Invoke(packet);
}
PacketProcessed?.Invoke(packet);
return(true);
}
/// <summary>
/// Async callback when a packet is received
/// </summary>
/// <param name="result"></param>
private void OnPacketReceived(IAsyncResult result)
{
try
{
// Recalls the state
var _state = result.AsyncState as StateObject;
// Grabs the numbber of bytes received and ends the receive
var bytes = _state.Socket.EndReceiveFrom(result, ref _state.RemoteEndpoint);
// Creates a temp byte array to put the received data
var packetData = new byte[bytes];
// Coppies the buffer passed in the stateobject to the temp byte array instantiated above
Array.Copy(_state.Buffer, 0, packetData, 0, packetData.Length);
// Fires the packet received event for Tcp.cs to handle
PacketReceived?.Invoke(new Packet(packetData));
// Restarts the async receive loop
_state.Socket.BeginReceiveFrom(_state.Buffer,
0,
_state.Buffer.Length,
SocketFlags.None,
ref _state.RemoteEndpoint,
OnPacketReceived,
new StateObject(_state.RemoteEndpoint, _state.Buffer, _state.Socket));
}
catch (Exception ex)
{
UdpError?.Invoke(ex);
}
}
public void ReceivePacket(int toReceive)
{
try
{
int len = networkStream.Read(receiveBuffer, 0, Math.Min(toReceive, receiveBuffer.Length));
if (len <= 0)
{
Close();
return;
}
toReceive -= len;
ms.Write(receiveBuffer, 0, len);
if (toReceive > 0)
{
ReceivePacket(toReceive);
return;
}
ms.Position = 0L;
PacketReceived?.Invoke(this, new PacketReceivedEventArgs(new BinaryReader(ms)));
ms.Close();
}
catch (SocketException) { Close(); }
catch (Exception) { /*Don't handle*/ }
networkStream.BeginRead(lenBuffer, 0, lenBuffer.Length, Receive, null);
}
public void ReceiveCallback(IAsyncResult ar)
{
var endpoint = new IPEndPoint(MulticastAddress, Port);
try
{
var receiveBytes = Client?.EndReceive(ar, ref endpoint);
PacketReceived?.Invoke(this, receiveBytes);
}
catch (ObjectDisposedException)
{
if (isQuitting)
{
return;
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
Console.WriteLine($"Endpoint: {endpoint}");
Client?.BeginReceive(ReceiveCallback, null);
}
private async void ListenForPackets(CancellationToken token)
{
try
{
while (!token.IsCancellationRequested)
{
while (!token.IsCancellationRequested && Available == 0)
{
await Task.Delay(10);
}
while (!token.IsCancellationRequested && Available > 0)
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
var data = Receive(ref endPoint);
PacketReceived?.Invoke(this, new PacketReceivedArgs(data));
}
}
}
catch (Exception e)
{
var ex = e;
while (ex != null)
{
Console.WriteLine($"TempestExceptions:{ex.GetType()}:{ex.Message}:{ex.StackTrace}");
ex = ex.InnerException;
}
}
}
private void OnReceive(string data)
{
if (String.IsNullOrEmpty(data))
{
return;
}
DataReceived?.Invoke(this, new AprsDataReceivedEventArgs(data));
if (PacketReceived == null)
{
return;
}
AprsMessage packetInfo;
try
{
packetInfo = PacketInfo.Parse(data);
}
catch (Exception ex)
{
Trace.TraceInformation(ex.ToString());
return;
}
// Usually the case when the packet is corrupt or something like that.
if (packetInfo == null)
{
return;
}
PacketReceived.Invoke(this, new PacketReceivedEventArgs(packetInfo));
}
private void ReceivePendingPackets()
{
bool hasReceived;
do
{
byte[] packet = null;
lock (_pendingPackets)
{
if (_pendingPackets.Count > 0)
{
packet = _pendingPackets.Dequeue();
}
}
hasReceived = false;
if (packet != null)
{
hasReceived = true;
using (MemoryStream stream = new MemoryStream(packet, false))
{
using (BinaryReader reader = new BinaryReader(stream))
{
PacketReceived?.Invoke(reader);
}
}
}
}while (hasReceived);
}
private void ThreadFunc()
{
Count = 0;
try
{
Client = new UdpClient(Port);
}
catch (Exception e)
{
MessageBox.Show(e.ToString(), nameof(UdpCli), MessageBoxButton.OK, MessageBoxImage.Error);
}
try
{
while (Running)
{
IPEndPoint ep = null;
byte[] bts = Client.Receive(ref ep);
DateTime now = DateTime.Now;
string data = Encoding.UTF8.GetString(bts);
PacketReceived?.Invoke(now, Count, data);
Count++;
}
}
catch (ThreadAbortException) { }
catch (SocketException) { }
catch (Exception e)
{
MessageBox.Show(e.ToString(), nameof(UdpCli), MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
Client?.Dispose();
}
}
protected void Receive()
{
try
{
byte[] buffer = new byte[DataBufferSize];
client.GetStream().BeginRead(buffer, 0, buffer.Length, (result) =>
{
try
{
int byteLength = client.GetStream().EndRead(result);
Receive();
byte[] buffer = (byte[])result.AsyncState;
PacketReceived?.Invoke(this, new Packet {
Bytes = buffer.Take(byteLength).ToArray()
});
}
catch (Exception e)
{
Dispose();
Disconnected?.Invoke(this, new DisconnectedEventArgs(e, 0));
}
}, buffer);
}
catch (Exception e)
{
Dispose();
Disconnected?.Invoke(this, new DisconnectedEventArgs(e, 0));
}
}
protected override void OnPacketsReceived(object[] packets)
{
foreach (var item in packets)
{
PacketReceived?.Invoke(this, new PacketReceivedEventArgs(item));
}
}
public async void BeginReadData()
{
try
{
int bytesread = await _stream.ReadAsync(_buffer, 0, BUFFERSIZE);
while (bytesread > 0)
{
int offset = 0;
do
{
var packet = _decoder.GetFromBytes(_buffer, ref offset);
if (packet != null)
{
PacketReceived?.Invoke(packet);
}
else if (offset < bytesread)
{
_dataoffset = bytesread - offset;
Array.Copy(_buffer, offset, _buffer, 0, _dataoffset);
break;
}
} while (offset < bytesread);
bytesread = await _stream.ReadAsync(_buffer, _dataoffset, BUFFERSIZE - _dataoffset);
}
}
catch
{
Console.WriteLine("Client Read Aborted");
}
Console.WriteLine("DONE");
}
private void ProcessReceive(UdpPacket packet)
{
if (IsDisposed)
{
packet.Return();
return;
}
ReceivePacket();
try
{
if (packet.EndReceive())
{
try
{
PacketReceived?.Invoke(this, packet);
}
catch
{
// What now?
}
}
else
{
// Ignore bad receive
}
}
finally
{
packet.Return();
}
}
/// <summary>
/// Extracts packets from the DataBuffer
/// </summary>
private void ProcessRawData(int received)
{
int total = received + BufferOffset;
int offset = 0;
if (!Handshaken)
{
offset += ParseHandshake();
}
while (total - offset > RegularHeaderLength)
{
int length = GetPacketLength(DataBuffer, offset);
if ((total - offset) < length)
{
byte[] leftover = new ArraySegment <byte>(DataBuffer, offset, (total - offset)).ToArray();
Buffer.BlockCopy(leftover, 0, DataBuffer, 0, leftover.Length);
BufferOffset = leftover.Length;
return;
}
offset += RegularHeaderLength;
byte[] packetData = new ArraySegment <byte>(DataBuffer, offset, length).ToArray();
RemoteCipher.Decrypt(ref packetData);
offset += length;
PacketReceived?.Invoke(new PacketReader(ref packetData, IncomingPacketType.DynamicHeader));
}
}
private void SpPollTimer_Tick(object sender, System.Timers.ElapsedEventArgs e)
{
if (inSpPoll)
{
return;
}
inSpPoll = true;
if (Channel == null)
{
inSpPoll = false;
return;
}
while (Channel != null && ReceiveEnabled)
{
if (!Channel.IsOpen)
{
break;
}
int toRead = 0;
try
{
toRead = Channel.BytesToRead;
}
catch
{
disconnectSP();
inSpPoll = false;
return;
}
if (toRead >= 3)
{
var com = new PacketCommandMini();
var resp = ProtocolError.Unknown;
try
{
resp = PacketCommandMini.FromStream(ref com, Channel, 10, flushTB);
}
catch (Exception ex)
{
disconnectSP();
inSpPoll = false;
return;
}
Application.DoEvents();
if (resp == ProtocolError.None)
{
bool bkp = ReceiveEnabled;
ReceiveEnabled = false;
PacketReceived?.Invoke(com);
ReceiveEnabled = bkp;
}
}
else
{
break;
}
}
inSpPoll = false;
}
private void ReadCallback(IAsyncResult ar)
{
try
{
ClientPlayer player = (ClientPlayer)ar.AsyncState;
Socket client = player.socket;
// Read data from the remote device.
int bytesRead = client.EndReceive(ar);
if (bytesRead > 0)
{
var currentBytes = new byte[bytesRead];
Buffer.BlockCopy(player.buffer, 0, currentBytes, 0, bytesRead);
player.accumulatedBytes.AddRange(currentBytes);
if (player.accumulatedBytes.Count >= Packet.packetHeaderSize)
{
//If we're not at the start of a packet, increment our position until we are, or we run out of bytes
var accumulatedBytes = player.accumulatedBytes.ToArray();
while (accumulatedBytes.Length >= Packet.packetHeaderSize && !Packet.StreamIsAtPacket(accumulatedBytes))
{
player.accumulatedBytes.RemoveAt(0);
accumulatedBytes = player.accumulatedBytes.ToArray();
}
while (accumulatedBytes.Length >= Packet.packetHeaderSize && Packet.PotentiallyValidPacket(accumulatedBytes))
{
Packet readPacket = null;
try
{
readPacket = Packet.FromBytes(accumulatedBytes);
PacketReceived?.Invoke(readPacket);
}
catch (Exception e)
{
Console.WriteLine(e);
}
//Remove the bytes which we've already used from the accumulated List
//If the packet failed to parse, skip the header so that the rest of the packet is consumed by the above vailidity check on the next run
player.accumulatedBytes.RemoveRange(0, readPacket?.Size ?? Packet.packetHeaderSize);
accumulatedBytes = player.accumulatedBytes.ToArray();
}
}
// Get the rest of the data.
client.BeginReceive(player.buffer, 0, ClientPlayer.BufferSize, 0, new AsyncCallback(ReadCallback), player);
}
}
catch (ObjectDisposedException)
{
ServerDisconnected_Internal();
}
catch (Exception e)
{
Logger.Debug(e.ToString());
ServerDisconnected_Internal();
}
}
private void ReceivePayloadStreamCallback(IAsyncResult ar)
{
try {
//Attempt to finish the async read.
var read = socket.EndReceive(ar);
//Same as above
if (read <= 0)
{
throw new SocketException((int)SocketError.ConnectionAborted);
}
CheckFlood();
//Subtract what we read from the payload size.
dataExpected -= read;
//Write the data to the payload stream.
payloadStream.Write(buffer, 0, read);
ReceiveProgressChanged?.Invoke(this, (int)payloadStream.Length, dataExpected);
//Update global how many bytes we have received.
TotalBytesReceived += read;
//If there is more data to receive, keep the loop going.
if (dataExpected > 0)
{
//See how much data we need to receive like the initial receive.
int receiveSize = dataExpected > ClientOptions.BufferSize ?
ClientOptions.BufferSize : dataExpected;
socket.BeginReceive(buffer, 0, receiveSize, 0,
ReceivePayloadStreamCallback, null);
//If we received everything
}
else
{
//Close the payload stream
payloadStream.Close();
//Get the full payload
byte[] payload = payloadStream.ToArray();
//Dispose the stream
payloadStream = null;
//Start receiving size header again
BeginReceive();
//Call the event method
PacketReceived?.Invoke(this, new PacketReceivedEventArgs(payload));
}
} catch (NullReferenceException) {
return;
} catch (ObjectDisposedException) {
return;
} catch (Exception ex) {
HandleDisconnect(ex);
}
}
private void FireMessageReceivedEvent(Message message)
{
PacketReceivedEventArgs args = new PacketReceivedEventArgs {
Message = message
};
PacketReceived?.Invoke(this, args);
}
private IOperation ReceiveSetup()
{
IOperation operation = new ReceiveOperation();
operation.PacketReceived += (s, e) => PacketReceived?.Invoke(this, e);
_context.Data = new List <byte>();
return(operation);
}
protected virtual void OnPacketReceived(byte[] incomingPacket, CSteamID remoteId)
{
PacketReceived?.Invoke(this, new PacketReceiveArgs()
{
Packet = incomingPacket,
RemoteId = remoteId
});
}
public void StartListening()
{
StopListening();
this.Client = new UdpClient(Port);
Task.Run(async() => {
var endpoint = new IPEndPoint(IPAddress.Any, Port);
try
{
//TODO: this is an initial version, i feel like this can be done more elegant? (atleast async, not thread blocking like now)
while (true)
{
try
{
var result = await Client.ReceiveAsync();
var bytes = result.Buffer;
var message = OscPacket.GetPacket(bytes) as OscMessage;
var musePacket = ParsePacket(message);
if (musePacket.Address == SignalAddress.Unknown)
{
Console.WriteLine($"unknown packet with address '{message.Address}', skipping it...");
continue;
}
PacketReceived?.Invoke(this, musePacket);
}
catch (ObjectDisposedException)
{
Console.WriteLine("disposed early");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"Corrupt packet received: '{ex.Message}'");
}
}
}
catch (ObjectDisposedException) {
//is fine, atm this is the escape condition when the listener needs to stop listening to the port. far from elegant but it works i suppose :)
Console.WriteLine("exited");
}
catch (SocketException e)
{
Console.WriteLine(e);
}
catch (Exception ex)
{
Console.WriteLine("something else threw an exception... " + ex.Message);
}
finally
{
this.Client?.Dispose();
this.Client = null;
}
});
}
internal override byte[] ReadPacket()
{
var buffer = new List <byte>();
buffer.Add((byte)_stream.ReadByte());
var identifier = buffer[0];
switch (identifier)
{
case 0x26:
buffer.AddRange(ReadBytes(11));
buffer.AddRange(GetChatPacket(buffer));
break;
case 0x5b:
buffer.AddRange(ReadBytes(2));
buffer.AddRange(ReadBytes(BitConverter.ToInt16(buffer.ToArray(), 1) - 3));
break;
case 0x94:
buffer.AddRange(ReadBytes(1));
buffer.AddRange(ReadBytes((buffer[1] * 3) + 4));
break;
case 0xa8:
case 0xaa:
buffer.AddRange(ReadBytes(6));
buffer.AddRange(ReadBytes(buffer[6] - 7));
break;
case 0xac:
buffer.AddRange(ReadBytes(12));
buffer.AddRange(ReadBytes(buffer[12] - 13));
break;
case 0xae:
buffer.AddRange(ReadBytes(2));
buffer.AddRange(ReadBytes(BitConverter.ToInt16(buffer.ToArray(), 1)));
break;
case 0x9c:
case 0x9d:
buffer.AddRange(ReadBytes(2));
buffer.AddRange(ReadBytes(buffer[2] - 3));
break;
default:
if (identifier >= PacketSizes.Length)
{
throw new D2GSPacketException("Unable to determine packet size");
}
buffer.AddRange(ReadBytes(PacketSizes[identifier] - 1));
break;
}
PacketReceived?.Invoke(this, new D2gsPacket(buffer));
return(buffer.ToArray());
}
public static void Start()
{
int length = _recorder.Packets.Count;
for (int i = 0; i < length; i++)
{
PacketReceived?.Invoke(_recorder.Packets[i]);
}
}
internal void GatherPendingData(IAsyncResult result)
{
try
{
// Keep reading data into the small buffer and then moving it into the big buffer
var bytesReceived = 0;
if (Socket != null)
{
bytesReceived = Socket.EndReceive(result);
if (bytesReceived > 0)
{
for (var i = 0; i < bytesReceived; i++)
{
largeBuffer.Add(smallBuffer[i]);
}
}
}
// Handle the case where there is no data, a special case for connected sockets that are disconnecting
if (bytesReceived == 0)
{
return;
}
// Do we have a complete packet available?
if (largeBuffer.Count > 0)
{
var packet = (Packet)null;
do
{
packet = DecodeBuffer();
if (packet != null)
{
PacketReceived?.Invoke(packet);
}
}while (packet != null);
}
// Ask for additional data if the last packet wasn't a disconnection that set Socket to null
if (Socket != null)
{
Socket.BeginReceive(smallBuffer, 0, BufferSize, 0, GatherPendingData, null);
}
}
catch (ObjectDisposedException)
{
// "Standard practise", Microsoft says, for when the application is closing and the socket is closed
return;
}
catch (Exception ex)
{
// When errors occur, we must disconnect the client for stability reasons
Disconnect(4000, ex.Message);
var disconnectionPacket = new Packet(RemoteEndPoint, WebSocketAction.Disconnect, ex.Message);
PacketReceived?.Invoke(disconnectionPacket);
}
}
protected virtual void OnBinaryPacketReceived(IPacket packet, int transferred)
{
try {
PacketReceived?.Invoke(this, new PacketEventArgs(packet, WebSocketMessageType.Binary, transferred));
}
catch (Exception ex) {
OnException(ex);
}
}
#pragma warning disable CS1998 // 异步方法缺少 "await" 运算符，将以同步方式运行
private async Task ReadWorker_DoWork(CancellationToken token)
#pragma warning restore CS1998 // 异步方法缺少 "await" 运算符，将以同步方式运行
{
Action cleanup = () =>
{
_client?.Dispose();
_client = null;
};
token.Register(cleanup);
while (!token.IsCancellationRequested && _client.Client != null)
{
Packet packet = null;
try
{
packet = ReadPacket();
}
catch (SocketException se)
{
//如果是网络异常，退出。
#if DEBUG
//Env1.Instance.ShowMessage($"desc={se.Message}\nStack={se.StackTrace}");
#endif
//如果在事件句柄里面DisposeTcpChannel，它会wait这个循环结束。而这里又在等待这个事件句柄执行完毕，所以就死锁了。
#pragma warning disable 4014
Task.Run(() =>
{
ErrorHappened?.Invoke(ErrorType.SocketError);
}, token);
#pragma warning restore 4014
break;
}
catch (Exception ex)
{
Env.ShowMessage($"desc={ex.Message}\nStack={ex.StackTrace}");
}
if (packet != null)
{
try
{
//Env.Logger.Log($"Packet received {packet}");
PacketReceived?.Invoke(packet);
}
catch (Exception e)
{
#if DEBUG
Env.ShowMessage("逻辑层处理消息异常。请检查\n" + e.Message + "\n" + e.StackTrace);
#else
Env.Logger.Log(e.StackTrace);
#endif
}
}
} //end while
cleanup();
Env.Logger.Log("ReceiveMessage: Receiving thread end...");
}
private void StartListening()
{
Logger.Debug("Starting with listening");
try
{
var buffer = new byte[RxBufferSize];
var bufferOffset = 0;
while (tcpClient?.Connected ?? false)
{
if (tcpClient?.Available > 0)
{
var read = stream.Read(buffer, bufferOffset, buffer.Length - bufferOffset);
var packetCollection = packetsFactory.GetPackets(buffer, 0, read + bufferOffset);
foreach (var packet in packetCollection)
{
Logger.Debug("Received packet from server: {packet}", packet);
PacketReceived?.Invoke(this, packet);
}
var leftover = read + bufferOffset - packetCollection.BytesUsed;
if (leftover > 0)
{
Array.Copy(buffer, packetCollection.BytesUsed, buffer, 0, leftover);
bufferOffset = leftover;
}
else
{
bufferOffset = 0;
}
}
else
{
Thread.Sleep(TimeSpan.FromTicks(100));
}
}
stream = null;
if (tcpClient != null && tcpClient.Connected)
{
tcpClient.Close();
}
Disconnected?.Invoke(this, EventArgs.Empty);
}
catch (Exception ex)
{
Logger.Error("Got an exceptions while listening to the server");
Logger.Error(ex);
Logger.Warn("Disconnecting");
stream?.Close();
stream = null;
if (tcpClient != null && tcpClient.Connected)
{
tcpClient.Close();
Disconnected?.Invoke(this, EventArgs.Empty);
}
}
}
protected override void ProcessPacket(RailPacketIncoming packetBase, Tick localTick)
{
base.ProcessPacket(packetBase, localTick);
RailPacketFromClient clientPacket = (RailPacketFromClient)packetBase;
Scope.IntegrateAcked(clientPacket.View);
PacketReceived?.Invoke(this, clientPacket);
}
public void RegisterHandler(PacketReceived handler)
{
_masterLayer.AddHandler(handler);
}
public void AddHandler(PacketReceived handler)
{
_service.UdpPacketReceived += handler;
}
public void RegisterMatchLobbyHandler(PacketReceived handler)
{
_layer.AddHandler(handler);
}
