public void MessageReceivedHandler(byte[] buffer)
{
using (var messageBuffer = MessageBuffer.Create(buffer.Length))
{
Buffer.BlockCopy(buffer, 0, messageBuffer.Buffer, 0, buffer.Length);
messageBuffer.Count = buffer.Length;
HandleMessageReceived(messageBuffer, SendMode.Reliable);
}
}
public void HandleEnetMessageReceived(Event netEvent, SendMode mode)
{
MessageBuffer message = MessageBuffer.Create(netEvent.Packet.Length);
netEvent.Packet.CopyTo(message.Buffer);
message.Offset = 0;
message.Count = netEvent.Packet.Length;
HandleMessageReceived(message, SendMode.Reliable);
}
private void OnReceivedByteArrayMessage(byte[] bytes)
{
using (var messageBuffer = MessageBuffer.Create(bytes.Length))
{
Buffer.BlockCopy(bytes, 0, messageBuffer.Buffer, 0, bytes.Length);
messageBuffer.Count = bytes.Length;
HandleMessageReceived(messageBuffer, SendMode.Reliable);
}
}
public void ProcessData(byte[] MessageData, int Length, bool reliable)
{
using (MessageBuffer buffer = MessageBuffer.Create(Length))
{
Buffer.BlockCopy(MessageData, 0, buffer.Buffer, 0, Length);
buffer.Count = Length;
HandleMessageReceived(buffer, reliable ? SendMode.Reliable : SendMode.Unreliable);
}
}
private void HandleEnetMessageReceived(Event netEvent, SendMode mode)
{
MessageBuffer message = MessageBuffer.Create(netEvent.Packet.Length);
netEvent.Packet.CopyTo(message.Buffer);
message.Offset = 0;
message.Count = netEvent.Packet.Length;
HandleMessageReceived(message, mode);
message.Dispose();
}
private void MessageReceivedHandler(byte[] buffer)
{
if (_connectionState != ConnectionState.Connected)
{
return;
}
using (var messageBuffer = MessageBuffer.Create(buffer.Length))
{
Buffer.BlockCopy(buffer, 0, messageBuffer.Buffer, 0, buffer.Length);
messageBuffer.Count = buffer.Length;
HandleMessageReceived(messageBuffer, SendMode.Reliable);
}
}
public void Update()
{
if (socket != null)
{
byte[] data = socket.Recv();
if (data == null || data.Length == 0)
{
return;
}
using (MessageBuffer buffer = MessageBuffer.Create(data.Length))
{
Buffer.BlockCopy(data, 0, buffer.Buffer, 0, data.Length);
buffer.Count = data.Length;
HandleMessageReceived(buffer, SendMode.Reliable);
}
}
}
/// <summary>
/// Called when a new UDP packet is received on the listening port.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void UdpMessageReceived(object sender, SocketAsyncEventArgs e)
{
//Copy over buffer and remote endpoint
bool completingAsync;
do
{
using (MessageBuffer buffer = MessageBuffer.Create(e.BytesTransferred))
{
Buffer.BlockCopy(e.Buffer, 0, buffer.Buffer, buffer.Offset, e.BytesTransferred);
buffer.Count = e.BytesTransferred;
EndPoint remoteEndPoint = e.RemoteEndPoint;
//Start listening again
try
{
completingAsync = UdpListener.ReceiveFromAsync(e);
}
catch (ObjectDisposedException)
{
return;
}
//Handle message or new connection
BichannelServerConnection connection;
bool exists;
lock (UdpConnections) // TODO remove lock please
exists = UdpConnections.TryGetValue(remoteEndPoint, out connection);
if (exists)
{
connection.HandleUdpMessage(buffer);
}
else
{
HandleUdpConnection(buffer, remoteEndPoint);
}
}
}while (!completingAsync);
}
/// <summary>
/// Called when a UDP message is received on the fallback system.
/// </summary>
/// <param name="result">The result of the operation.</param>
private void UdpMessageReceived(IAsyncResult result)
{
EndPoint remoteEndPoint = new IPEndPoint(Address.AddressFamily == AddressFamily.InterNetworkV6 ? IPAddress.IPv6Any : IPAddress.Any, 0);
int bytesReceived;
try
{
bytesReceived = UdpListener.EndReceiveFrom(result, ref remoteEndPoint);
}
catch (SocketException)
{
UdpListener.BeginReceiveFrom((byte[])result.AsyncState, 0, ushort.MaxValue, SocketFlags.None, ref remoteEndPoint, UdpMessageReceived, (byte[])result.AsyncState);
return;
}
//Copy over buffer and remote endpoint
using (MessageBuffer buffer = MessageBuffer.Create(bytesReceived))
{
Buffer.BlockCopy((byte[])result.AsyncState, 0, buffer.Buffer, buffer.Offset, bytesReceived);
buffer.Count = bytesReceived;
//Start listening again
UdpListener.BeginReceiveFrom((byte[])result.AsyncState, 0, ushort.MaxValue, SocketFlags.None, ref remoteEndPoint, UdpMessageReceived, (byte[])result.AsyncState);
//Handle message or new connection
BichannelServerConnection connection;
bool exists;
lock (UdpConnections)
exists = UdpConnections.TryGetValue(remoteEndPoint, out connection);
if (exists)
{
connection.HandleUdpMessage(buffer);
}
else
{
HandleUdpConnection(buffer, remoteEndPoint);
}
}
}
public void Update()
{
uint Length;
int Channel;
while (PacketAvailable(out Length, out Channel))
{
CSteamID Sender;
uint RealLength;
if (SteamNetworking.ReadP2PPacket(RecvData, Length, out RealLength, out Sender, Channel))
{
if (Sender.m_SteamID == LobbyOwner.m_SteamID)
{
using (MessageBuffer buffer = MessageBuffer.Create((int)RealLength))
{
Buffer.BlockCopy(RecvData, 0, buffer.Buffer, 0, (int)RealLength);
buffer.Count = (int)RealLength;
HandleMessageReceived(buffer, Channel == 1 ? SendMode.Reliable : SendMode.Unreliable);
}
}
}
}
}
