public virtual ENetInterceptionResult Intercept(Native.ENetAddress *address, byte **buffer, UIntPtr *count, Native.ENetEvent *e)
{
throw new NotImplementedException();
}
private ENetInterceptionResult InterceptCallback(IntPtr host, Native.ENetEvent *e)
{
if (Interceptor.Method == ENetInterceptor.InterceptionMethod.Unmanaged)
{
return(Interceptor.Intercept(m_pReceivedAddress, (byte **)m_pReceivedData, m_pReceivedDataLength, e));
}
if (Interceptor.Method == ENetInterceptor.InterceptionMethod.Managed)
{
IPEndPoint endPoint = (*m_pReceivedAddress).ToEndPoint();
byte[] buffer = new byte[(*m_pReceivedDataLength).ToUInt32()];
fixed(byte *dest = buffer)
{
Platform.Current.MemoryCopy((IntPtr)dest, *m_pReceivedData, *m_pReceivedDataLength);
}
byte[] bufferRef = buffer;
var result = Interceptor.Intercept(endPoint, ref bufferRef, out ENetEvent @event);
if (result == ENetInterceptionResult.Error)
{
return(result);
}
if (bufferRef == buffer)
{
fixed(byte *src = bufferRef)
{
Platform.Current.MemoryCopy((IntPtr)src, *m_pReceivedData, *m_pReceivedDataLength);
}
}
else if (bufferRef != null)
{
Marshal.FreeHGlobal(*m_pReceivedData);
var bufferPtr = Marshal.AllocHGlobal(bufferRef.Length);
* m_pReceivedData = bufferPtr;
* m_pReceivedDataLength = (UIntPtr)bufferRef.Length;
fixed(byte *src = bufferRef)
{
Platform.Current.MemoryCopy((IntPtr)src, bufferPtr, (UIntPtr)bufferRef.Length);
}
}
if (result == ENetInterceptionResult.Ignore)
{
return(result);
}
if (@event == null)
{
e->Type = ENetEventType.None;
return(result);
}
if (@event is ENetConnectEventArgs)
{
var connect = @event as ENetConnectEventArgs;
e->Type = ENetEventType.Connect;
e->Peer = connect.Peer.Unsafe;
e->Data = connect.Data;
return(result);
}
if (@event is ENetDisconnectEventArgs)
{
var disconnect = @event as ENetConnectEventArgs;
e->Type = ENetEventType.Disconnect;
e->Peer = disconnect.Peer.Unsafe;
e->Data = disconnect.Data;
return(result);
}
if (@event is ENetReceiveEventArgs)
{
var receive = @event as ENetReceiveEventArgs;
e->Type = ENetEventType.Receive;
e->Peer = receive.Peer.Unsafe;
e->ChannelID = receive.Packet.Channel;
fixed(byte *data = receive.Packet.m_Payload)
{
e->Packet = LibENet.PacketCreate((IntPtr)data, (UIntPtr)receive.Packet.m_Payload.Length, receive.Packet.Flags & ~ENetPacketFlags.NoAllocate);
}
return(result);
}
}
throw new NotImplementedException(Interceptor.Method.ToString());
}
