public unsafe void Assert_GotConnectionRequest(NetworkEndPoint from, bool accept = false)
{
int length;
NetworkEndPoint remote;
m_LocalDataStream.Clear();
Assert.True(
IPCManager.Instance.PeekNext(Address, m_LocalDataStream.GetUnsafePtr(), out length, out remote) >=
sizeof(UdpCHeader));
m_LocalDataStream.WriteBytesWithUnsafePointer(length);
UdpCHeader header = new UdpCHeader();
var reader = new DataStreamReader(m_LocalDataStream, 0, sizeof(UdpCHeader));
var readerCtx = default(DataStreamReader.Context);
Assert.True(reader.IsCreated);
reader.ReadBytes(ref readerCtx, header.Data, sizeof(UdpCHeader));
Assert.True(header.Type == (int)UdpCProtocol.ConnectionRequest);
Assert.True(remote.Family == NetworkFamily.IPC);
//Assert.True(remote.ipc_handle == from.ipc_handle);
Assert.True(remote.Port == from.Port);
if (accept)
{
m_LocalDriver.ScheduleUpdate().Complete();
var con = m_LocalDriver.Accept();
ClientConnections.Add(con);
Assert.True(con != default(NetworkConnection));
}
}
unsafe int NativeReceive(ref UdpCHeader header, void *data, int length, ref network_address address)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (length <= 0)
{
throw new ArgumentException("Can't receive into 0 bytes or less of buffer memory");
}
#endif
var iov = stackalloc network_iovec[2];
fixed(byte *ptr = header.Data)
{
iov[0].buf = ptr;
iov[0].len = UdpCHeader.Length;
iov[1].buf = data;
iov[1].len = length;
}
int errorcode = 0;
var result = NativeBindings.network_recvmsg(socket, iov, 2, ref address, ref errorcode);
if (result == -1)
{
if (errorcode == 10035 || errorcode == 35 || errorcode == 11)
{
return(0);
}
receiver.ReceiveErrorCode = errorcode;
}
return(result);
}
public int Send(NetworkConnection id, IntPtr data, int len)
{
if (id.m_NetworkId < 0 || id.m_NetworkId >= m_ConnectionList.Length)
{
return(0);
}
var connection = m_ConnectionList[id.m_NetworkId];
if (connection.Version != id.m_NetworkVersion)
{
return(0);
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (connection.State == NetworkConnection.State.Connecting)
{
throw new InvalidOperationException("Cannot send data while connecting");
}
#endif
// update last attempt;
var header = new UdpCHeader
{
Type = (int)UdpCProtocol.Data,
SessionToken = connection.SendToken
};
unsafe
{
return(NativeSend(m_NetworkInterface, ref header, (void *)data, len, null, 0, connection.Address));
}
}
static unsafe int NativeSend(T networkInterface, ref UdpCHeader header, void *payload, int payloadSize,
void *footer, int footerLen, NetworkEndPoint remote)
{
var iov = stackalloc network_iovec[3];
int result;
fixed(byte *ptr = header.Data)
{
iov[0].buf = ptr;
iov[0].len = UdpCHeader.Length;
iov[1].buf = payload;
iov[1].len = payloadSize;
iov[2].buf = footer;
iov[2].len = footerLen;
result = networkInterface.SendMessage(iov, 3, ref remote);
}
if (result == -1)
{
int error = Marshal.GetLastWin32Error();
throw new SocketException(error);
}
return(result);
}
public unsafe void Assert_GotConnectionRequest(NetworkEndPoint from, bool accept = false)
{
int length;
NetworkEndPoint remote;
Assert.True(IPCManager.Instance.PeekNext(Address, m_LocalBitStream.GetUnsafePtr(), out length, out remote) == sizeof(UdpCHeader));
UdpCHeader header = new UdpCHeader();
var slice = m_LocalBitStream.GetBitSlice(0, sizeof(UdpCHeader));
Assert.True(slice.isValid);
slice.ReadBytes(header.Data, sizeof(UdpCHeader));
Assert.True(header.Type == (int)UdpCProtocol.ConnectionRequest);
Assert.True(remote.family == NetworkFamily.IPC);
Assert.True(*(int *)remote.address == *(int *)from.address);
Assert.True(remote.port == from.port);
if (accept)
{
m_LocalDriver.Update();
var con = m_LocalDriver.Accept();
ClientConnections.Add(con);
Assert.True(con != default(NetworkConnection));
}
}
public unsafe int ReceiveMessageEx(NetworkInterfaceEndPoint local, ref UdpCHeader header, void *payloadData, int payloadLen, ref NetworkInterfaceEndPoint remote)
{
IPCData data;
if (!m_IPCQueue.Peek(*(int *)local.data, out data))
{
return(0);
}
GetEndPointByHandle(data.from, out remote);
int totalLength = 0;
var curLength = Math.Min(UdpCHeader.Length, data.length - totalLength);
fixed(void *headerData = header.Data)
{
UnsafeUtility.MemCpy(headerData, data.data + totalLength, curLength);
}
totalLength += curLength;
curLength = Math.Min(payloadLen, data.length - totalLength);
UnsafeUtility.MemCpy(payloadData, data.data + totalLength, curLength);
totalLength += curLength;
if (totalLength < data.length)
{
return(-1);
}
m_IPCQueue.Dequeue(*(int *)local.data, out data);
return(totalLength);
}
unsafe int NativeReceive(ref UdpCHeader header, void *data, int length, ref NetworkEndPoint address)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (length <= 0)
{
Debug.LogError("Can't receive into 0 bytes or less of buffer memory");
return(0);
}
#endif
var iov = stackalloc network_iovec[2];
fixed(byte *ptr = header.Data)
{
iov[0].buf = ptr;
iov[0].len = UdpCHeader.Length;
iov[1].buf = data;
iov[1].len = length;
}
var result = NativeBindings.network_recvmsg(socket, iov, 2, ref address);
if (result == -1)
{
int err = Marshal.GetLastWin32Error();
if (err == 10035 || err == 35 || err == 11)
{
return(0);
}
Debug.LogError(string.Format("error on receive {0}", err));
throw new SocketException(err);
}
return(result);
}
public unsafe void Execute()
{
var address = new NetworkEndPoint {
length = sizeof(NetworkEndPoint)
};
var header = new UdpCHeader();
var stream = receiver.GetDataStream();
receiver.ReceiveCount = 0;
receiver.ReceiveErrorCode = 0;
while (true)
{
if (receiver.DynamicDataStreamSize())
{
while (stream.Length + NetworkParameterConstants.MTU >= stream.Capacity)
{
stream.Capacity *= 2;
}
}
else if (stream.Length >= stream.Capacity)
{
return;
}
var sliceOffset = stream.Length;
var result = NativeReceive(ref header, stream.GetUnsafePtr() + sliceOffset,
Math.Min(NetworkParameterConstants.MTU, stream.Capacity - stream.Length), ref address);
if (result <= 0)
{
return;
}
receiver.ReceiveCount += receiver.AppendPacket(address, header, result);
}
}
unsafe int NativeReceive(ref UdpCHeader header, void *data, int length, ref NetworkEndPoint address)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (length <= 0)
{
throw new ArgumentException("Can't receive into 0 bytes or less of buffer memory");
}
#endif
var iov = stackalloc network_iovec[2];
fixed(byte *ptr = header.Data)
{
iov[0].buf = ptr;
iov[0].len = UdpCHeader.Length;
iov[1].buf = data;
iov[1].len = length;
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (localEndPoint.Family != NetworkFamily.IPC || localEndPoint.nbo_port == 0)
{
throw new InvalidOperationException();
}
#endif
return(ipcManager.ReceiveMessageEx(localEndPoint, iov, 2, ref address));
}
public unsafe void Assert_GotConnectionRequest(NetworkEndPoint from, bool accept = false)
{
int length;
NetworkInterfaceEndPoint remote;
Assert.True(EndPoint.IsLoopback || EndPoint.IsAny);
Assert.True(from.IsLoopback || from.IsAny);
var localEndPoint = IPCManager.Instance.CreateEndPoint(EndPoint.Port);
var fromEndPoint = IPCManager.Instance.CreateEndPoint(from.Port);
Assert.True(
IPCManager.Instance.PeekNext(localEndPoint, m_LocalData.GetUnsafePtr(), out length, out remote) >=
sizeof(UdpCHeader));
UdpCHeader header = new UdpCHeader();
var reader = new DataStreamReader(m_LocalData.GetSubArray(0, sizeof(UdpCHeader)));
Assert.True(reader.IsCreated);
reader.ReadBytes(header.Data, sizeof(UdpCHeader));
Assert.True(header.Type == (int)UdpCProtocol.ConnectionRequest);
Assert.True(remote == fromEndPoint);
if (accept)
{
m_LocalDriver.ScheduleUpdate().Complete();
var con = m_LocalDriver.Accept();
ClientConnections.Add(con);
Assert.True(con != default(NetworkConnection));
}
}
public unsafe void Assert_GotDataRequest(NetworkEndPoint from, byte[] dataToCompare)
{
int length;
NetworkEndPoint remote;
Assert.True(IPCManager.Instance.RecvFrom(Address, m_LocalBitStream.GetUnsafePtr(), out length, out remote) == sizeof(UdpCHeader));
UdpCHeader header = new UdpCHeader();
var slice = m_LocalBitStream.GetBitSlice(0, sizeof(UdpCHeader));
Assert.True(slice.isValid);
slice.ReadBytes(header.Data, sizeof(UdpCHeader));
Assert.True(header.Type == (int)UdpCProtocol.Data);
Assert.True(remote.family == NetworkFamily.IPC);
Assert.True(*(int *)remote.address == *(int *)from.address);
Assert.True(remote.port == from.port);
Assert.True(IPCManager.Instance.RecvFrom(Address, m_LocalBitStream.GetUnsafePtr(), out length, out remote) == dataToCompare.Length);
slice = m_LocalBitStream.GetBitSlice(0, dataToCompare.Length);
var received = slice.ReadBytesAsArray(dataToCompare.Length);
for (int i = 0, n = dataToCompare.Length; i < n; ++i)
{
Assert.True(received[i] == dataToCompare[i]);
}
}
unsafe int NativeReceive(ref UdpCHeader header, void *data, int length, ref network_address address)
{
if (length <= 0)
{
Debug.LogError("Can't receive into 0 bytes or less of buffer memory");
return(0);
}
var iov = stackalloc network_iovec[2];
fixed(byte *ptr = header.Data)
{
iov[0].buf = ptr;
iov[0].len = UdpCHeader.Length;
iov[1].buf = data;
iov[1].len = length;
}
var result = m_NetworkInterface.ReceiveMessage(iov, 2, ref address);
if (result == -1)
{
int err = Marshal.GetLastWin32Error();
if (err == 10035 || err == 35 || err == 11)
{
return(0);
}
Debug.LogError(string.Format("error on receive {0}", err));
throw new SocketException(err);
}
if (result > 0)
{
DebugLog("NativeReceive Type=" + (UdpCProtocol)header.Type + " HdrLength=" + UdpCHeader.Length + " PayloadSize=" + length + " Result=" + result);
string dump = "(";
fixed(byte *ptr = header.Data)
{
for (int i = 0; i < UdpCHeader.Length; ++i)
{
dump += ptr[i].ToString("X");
}
}
dump += ") ";
for (int i = 0; i < result - UdpCHeader.Length; ++i)
{
dump += ((byte *)data)[i].ToString("X");
}
DebugLog("Dump=" + dump);
}
return(result);
}
int SendPacket(UdpCProtocol type, network_address address)
{
var header = new UdpCHeader
{
Type = (byte)type
};
unsafe
{
return(NativeSend(ref header, null, 0, address));
}
}
public unsafe void Assert_GotDataRequest(NetworkEndPoint from, byte[] dataToCompare)
{
NetworkEndPoint remote = default(NetworkEndPoint);
m_LocalDataStream.Clear();
network_iovec[] iovecs = new network_iovec[2];
iovecs[0].buf = m_LocalDataStream.GetUnsafePtr();
iovecs[0].len = sizeof(UdpCHeader);
iovecs[1].buf = m_LocalDataStream.GetUnsafePtr() + sizeof(UdpCHeader);
iovecs[1].len = NetworkParameterConstants.MTU;
int dataLen = 0;
fixed(network_iovec *iovptr = &iovecs[0])
{
dataLen = IPCManager.Instance.ReceiveMessageEx(Address, iovptr, 2, ref remote);
}
if (dataLen <= 0)
{
iovecs[0].len = iovecs[1].len = 0;
}
Assert.True(iovecs[0].len + iovecs[1].len == dataLen);
Assert.True(iovecs[0].len == sizeof(UdpCHeader));
m_LocalDataStream.WriteBytesWithUnsafePointer(iovecs[0].len);
UdpCHeader header = new UdpCHeader();
var reader = new DataStreamReader(m_LocalDataStream, 0, sizeof(UdpCHeader));
var readerCtx = default(DataStreamReader.Context);
Assert.True(reader.IsCreated);
reader.ReadBytes(ref readerCtx, header.Data, sizeof(UdpCHeader));
Assert.True(header.Type == (int)UdpCProtocol.Data);
Assert.True(remote.Family == NetworkFamily.IPC);
//Assert.True(remote.ipc_handle == from.ipc_handle);
Assert.True(remote.Port == from.Port);
Assert.True(iovecs[1].len == dataToCompare.Length);
m_LocalDataStream.WriteBytesWithUnsafePointer(iovecs[1].len);
reader = new DataStreamReader(m_LocalDataStream, iovecs[0].len, dataToCompare.Length);
readerCtx = default(DataStreamReader.Context);
var received = reader.ReadBytesAsArray(ref readerCtx, dataToCompare.Length);
for (int i = 0, n = dataToCompare.Length; i < n; ++i)
{
Assert.True(received[i] == dataToCompare[i]);
}
}
public unsafe void Assert_GotDataRequest(NetworkEndPoint from, byte[] dataToCompare)
{
NetworkInterfaceEndPoint remote = default;
network_iovec[] iovecs = new network_iovec[2];
iovecs[0].buf = m_LocalData.GetUnsafePtr();
iovecs[0].len = sizeof(UdpCHeader);
iovecs[1].buf = (byte *)m_LocalData.GetUnsafePtr() + sizeof(UdpCHeader);
iovecs[1].len = NetworkParameterConstants.MTU;
int dataLen = 0;
Assert.True(EndPoint.IsLoopback || EndPoint.IsAny);
Assert.True(from.IsLoopback || from.IsAny);
var localEndPoint = IPCManager.Instance.CreateEndPoint(EndPoint.Port);
var fromEndPoint = IPCManager.Instance.CreateEndPoint(from.Port);
fixed(network_iovec *iovptr = &iovecs[0])
{
dataLen = IPCManager.Instance.ReceiveMessageEx(localEndPoint, iovptr, 2, ref remote);
}
if (dataLen <= 0)
{
iovecs[0].len = iovecs[1].len = 0;
}
Assert.True(iovecs[0].len + iovecs[1].len == dataLen);
Assert.True(iovecs[0].len == sizeof(UdpCHeader));
UdpCHeader header = new UdpCHeader();
var reader = new DataStreamReader(m_LocalData.GetSubArray(0, sizeof(UdpCHeader)));
Assert.True(reader.IsCreated);
reader.ReadBytes(header.Data, sizeof(UdpCHeader));
Assert.True(header.Type == (int)UdpCProtocol.Data);
Assert.True(remote == fromEndPoint);
Assert.True(iovecs[1].len == dataToCompare.Length);
reader = new DataStreamReader(m_LocalData.GetSubArray(iovecs[0].len, dataToCompare.Length));
var received = new NativeArray <byte>(dataToCompare.Length, Allocator.Temp);
reader.ReadBytes(received);
for (int i = 0, n = dataToCompare.Length; i < n; ++i)
{
Assert.True(received[i] == dataToCompare[i]);
}
}
void SendConnectionRequest(Connection c)
{
var header = new UdpCHeader
{
Type = (int)UdpCProtocol.ConnectionRequest,
SessionToken = c.ReceiveToken
};
unsafe
{
// TODO: Actually use data part instead of header
if (NativeSend(m_NetworkInterface, ref header, null, 0, null, 0, c.Address) <= 0)
{
UnityEngine.Debug.LogError("Failed to send connect message");
}
}
}
public unsafe void Assert_GotDisconnectionRequest(NetworkEndPoint from)
{
int length;
NetworkEndPoint remote;
Assert.True(IPCManager.Instance.PeekNext(Address, m_LocalBitStream.GetUnsafePtr(), out length, out remote) == sizeof(UdpCHeader));
UdpCHeader header = new UdpCHeader();
var slice = m_LocalBitStream.GetBitSlice(0, sizeof(UdpCHeader));
Assert.True(slice.isValid);
slice.ReadBytes(header.Data, sizeof(UdpCHeader));
Assert.True(header.Type == (int)UdpCProtocol.Disconnect);
Assert.True(remote.family == NetworkFamily.IPC);
Assert.True(*(int *)remote.address == *(int *)from.address);
Assert.True(remote.port == from.port);
}
int SendPacket(UdpCProtocol type, Connection connection)
{
var header = new UdpCHeader
{
Type = (byte)type,
SessionToken = connection.SendToken
};
unsafe
{
if (connection.DidReceiveData == 0)
{
header.Flags = 1;
return(NativeSend(m_NetworkInterface, ref header, &connection.ReceiveToken, 2, null, 0, connection.Address));
}
return(NativeSend(m_NetworkInterface, ref header, null, 0, null, 0, connection.Address));
}
}
public unsafe void Assert_GotDataRequest(NetworkEndPoint from, byte[] dataToCompare)
{
NetworkInterfaceEndPoint remote = default;
var headerData = (UdpCHeader *)m_LocalData.GetUnsafePtr();
int headerLen = sizeof(UdpCHeader);
void *payloadData = (byte *)m_LocalData.GetUnsafePtr() + headerLen;
int payloadLen = NetworkParameterConstants.MTU;
int dataLen = 0;
Assert.True(EndPoint.IsLoopback || EndPoint.IsAny);
Assert.True(from.IsLoopback || from.IsAny);
var localEndPoint = IPCManager.Instance.CreateEndPoint(EndPoint.Port);
var fromEndPoint = IPCManager.Instance.CreateEndPoint(from.Port);
dataLen = IPCManager.Instance.ReceiveMessageEx(localEndPoint, ref *headerData, payloadData, payloadLen, ref remote);
payloadLen = dataLen - headerLen;
if (payloadLen <= 0)
{
payloadLen = 0;
}
UdpCHeader header = new UdpCHeader();
var reader = new DataStreamReader(m_LocalData.GetSubArray(0, headerLen));
Assert.True(reader.IsCreated);
reader.ReadBytes(header.Data, headerLen);
Assert.True(header.Type == (int)UdpCProtocol.Data);
Assert.True(remote == fromEndPoint);
Assert.True(payloadLen == dataToCompare.Length);
reader = new DataStreamReader(m_LocalData.GetSubArray(headerLen, dataToCompare.Length));
var received = new NativeArray <byte>(dataToCompare.Length, Allocator.Temp);
reader.ReadBytes(received);
for (int i = 0, n = dataToCompare.Length; i < n; ++i)
{
Assert.True(received[i] == dataToCompare[i]);
}
}
unsafe int NativeSend(ref UdpCHeader header, void *payload, int payloadSize, network_address remote)
{
var iov = stackalloc network_iovec[2];
int result;
fixed(byte *ptr = header.Data)
{
iov[0].buf = ptr;
iov[0].len = UdpCHeader.Length;
iov[1].buf = payload;
iov[1].len = payloadSize;
result = m_NetworkInterface.SendMessage(iov, 2, ref remote);
}
DebugLog("NativeSend Type=" + (UdpCProtocol)header.Type + " HdrLength=" + UdpCHeader.Length + " PayloadSize=" + payloadSize + " Result=" + result);
string dump = "(";
fixed(byte *ptr = header.Data)
{
for (int i = 0; i < UdpCHeader.Length; ++i)
{
dump += ptr[i].ToString("X");
}
}
dump += ") ";
for (int i = 0; i < payloadSize; ++i)
{
dump += ((byte *)payload)[i].ToString("X");
}
DebugLog("Dump=" + dump);
if (result == -1)
{
int error = Marshal.GetLastWin32Error();
throw new SocketException(error);
}
return(result);
}
public int Send(NetworkConnection id, BitStream bs)
{
Connection connection;
if ((connection = GetConnection(id)) == Connection.Null || connection.State == NetworkConnection.State.Destroyed)
{
return(0);
}
// update last attempt;
var header = new UdpCHeader
{
Type = (int)UdpCProtocol.Data
};
unsafe
{
return(NativeSend(ref header, bs.UnsafeDataPtr, bs.GetBytesWritten(), connection.Address));
}
}
public unsafe void Execute()
{
var address = new network_address {
length = network_address.Length
};
var header = new UdpCHeader();
var stream = receiver.GetDataStream();
receiver.ReceiveCount = 0;
receiver.ReceiveErrorCode = 0;
while (true)
{
int dataStreamSize = receiver.GetDataStreamSize();
if (receiver.DynamicDataStreamSize())
{
while (dataStreamSize + NetworkParameterConstants.MTU - UdpCHeader.Length >= stream.Length)
{
stream.ResizeUninitialized(stream.Length * 2);
}
}
else if (dataStreamSize >= stream.Length)
{
return;
}
var result = NativeReceive(ref header, (byte *)stream.GetUnsafePtr() + dataStreamSize,
Math.Min(NetworkParameterConstants.MTU - UdpCHeader.Length, stream.Length - dataStreamSize), ref address);
if (result <= 0)
{
return;
}
var endpoint = default(NetworkInterfaceEndPoint);
endpoint.dataLength = UnsafeUtility.SizeOf <network_address>();
UnsafeUtility.MemCpy(endpoint.data, &address, endpoint.dataLength);
receiver.ReceiveCount += receiver.AppendPacket(endpoint, header, result);
}
}
public unsafe void Assert_GotDisconnectionRequest(NetworkEndPoint from)
{
int length;
NetworkEndPoint remote;
m_LocalDataStream.Clear();
Assert.True(
IPCManager.Instance.PeekNext(Address, m_LocalDataStream.GetUnsafePtr(), out length, out remote) >=
sizeof(UdpCHeader));
m_LocalDataStream.WriteBytesWithUnsafePointer(length);
UdpCHeader header = new UdpCHeader();
var reader = new DataStreamReader(m_LocalDataStream, 0, sizeof(UdpCHeader));
var readerCtx = default(DataStreamReader.Context);
Assert.True(reader.IsCreated);
reader.ReadBytes(ref readerCtx, header.Data, sizeof(UdpCHeader));
Assert.True(header.Type == (int)UdpCProtocol.Disconnect);
Assert.True(remote.Family == NetworkFamily.IPC);
//Assert.True(remote.ipc_handle == from.ipc_handle);
Assert.True(remote.Port == from.Port);
}
public unsafe void Assert_GotDisconnectionRequest(NetworkEndPoint from)
{
int length;
NetworkInterfaceEndPoint remote;
Assert.True(EndPoint.IsLoopback || EndPoint.IsAny);
Assert.True(from.IsLoopback || from.IsAny);
var localEndPoint = IPCManager.Instance.CreateEndPoint(EndPoint.Port);
var fromEndPoint = IPCManager.Instance.CreateEndPoint(from.Port);
Assert.True(
IPCManager.Instance.PeekNext(localEndPoint, m_LocalData.GetUnsafePtr(), out length, out remote) >=
sizeof(UdpCHeader));
UdpCHeader header = new UdpCHeader();
var reader = new DataStreamReader(m_LocalData.GetSubArray(0, sizeof(UdpCHeader)));
Assert.True(reader.IsCreated);
reader.ReadBytes(header.Data, sizeof(UdpCHeader));
Assert.True(header.Type == (int)UdpCProtocol.Disconnect);
Assert.True(remote == fromEndPoint);
}
/// <summary>
/// AppendPacket is where we parse the data from the network into easy to handle events.
/// </summary>
/// <param name="address">The address of the endpoint we received data from.</param>
/// <param name="header">The header data indicating what type of packet it is. <see cref="UdpCHeader"/> for more information.</param>
/// <param name="dataLen">The size of the payload, if any.</param>
/// <returns></returns>
public int AppendPacket(NetworkInterfaceEndPoint address, UdpCHeader header, int dataLen)
{
return(m_Driver.AppendPacket(address, header, dataLen));
}
public unsafe int AppendPacket(NetworkEndPoint address, UdpCHeader header, int dataLen)
{
int count = 0;
switch ((UdpCProtocol)header.Type)
{
case UdpCProtocol.ConnectionRequest:
{
if (!Listening)
{
return(0);
}
Connection c;
if ((c = GetNewConnection(address, header.SessionToken)) == Connection.Null || c.State == NetworkConnection.State.Disconnected)
{
int id;
var sessionId = m_SessionIdCounter[0];
m_SessionIdCounter[0] = (ushort)(m_SessionIdCounter[0] + 1);
if (!m_FreeList.TryDequeue(out id))
{
id = m_ConnectionList.Length;
m_ConnectionList.Add(new Connection {
Id = id, Version = 1
});
}
int ver = m_ConnectionList[id].Version;
c = new Connection
{
Id = id,
Version = ver,
ReceiveToken = sessionId,
SendToken = header.SessionToken,
State = NetworkConnection.State.Connected,
Address = address,
Attempts = 1,
LastAttempt = m_updateTime
};
SetConnection(c);
m_NetworkAcceptQueue.Enqueue(id);
count++;
}
else
{
c.Attempts++;
c.LastAttempt = m_updateTime;
SetConnection(c);
}
SendPacket(UdpCProtocol.ConnectionAccept,
new NetworkConnection {
m_NetworkId = c.Id, m_NetworkVersion = c.Version
});
}
break;
case UdpCProtocol.ConnectionReject:
{
// m_EventQ.Enqueue(Id, (int)NetworkEvent.Connect);
}
break;
case UdpCProtocol.ConnectionAccept:
{
if (header.Flags != 1)
{
UnityEngine.Debug.LogError("Accept message received without flag set");
return(0);
}
Connection c = GetConnection(address, header.SessionToken);
if (c != Connection.Null)
{
c.DidReceiveData = 1;
if (c.State == NetworkConnection.State.Connected)
{
//DebugLog("Dropping connect request for an already connected endpoint [" + address + "]");
return(0);
}
if (c.State == NetworkConnection.State.Connecting)
{
var sliceOffset = m_DataStream.Length;
m_DataStream.WriteBytesWithUnsafePointer(2);
var dataStreamReader = new DataStreamReader(m_DataStream, sliceOffset, 2);
var context = default(DataStreamReader.Context);
c.SendToken = dataStreamReader.ReadUShort(ref context);
m_DataStream.WriteBytesWithUnsafePointer(-2);
c.State = NetworkConnection.State.Connected;
UpdateConnection(c);
AddConnection(c.Id);
count++;
}
}
}
break;
case UdpCProtocol.Disconnect:
{
Connection c = GetConnection(address, header.SessionToken);
if (c != Connection.Null)
{
if (RemoveConnection(c))
{
AddDisconnection(c.Id);
}
count++;
}
}
break;
case UdpCProtocol.Data:
{
Connection c = GetConnection(address, header.SessionToken);
if (c == Connection.Null)
{
return(0);
}
c.DidReceiveData = 1;
c.LastAttempt = m_updateTime;
UpdateConnection(c);
var length = dataLen - UdpCHeader.Length;
if (c.State == NetworkConnection.State.Connecting)
{
if (header.Flags != 1)
{
UnityEngine.Debug.LogError("Received data without connection (no send token)");
return(0);
}
var tokenOffset = m_DataStream.Length + length - 2;
m_DataStream.WriteBytesWithUnsafePointer(length);
var dataStreamReader = new DataStreamReader(m_DataStream, tokenOffset, 2);
var context = default(DataStreamReader.Context);
c.SendToken = dataStreamReader.ReadUShort(ref context);
m_DataStream.WriteBytesWithUnsafePointer(-length);
c.State = NetworkConnection.State.Connected;
UpdateConnection(c);
Assert.IsTrue(!Listening);
AddConnection(c.Id);
count++;
}
if (header.Flags == 1)
{
length -= 2;
}
var sliceOffset = m_DataStream.Length;
m_DataStream.WriteBytesWithUnsafePointer(length);
m_EventQueue.PushEvent(new NetworkEvent
{
connectionId = c.Id,
type = NetworkEvent.Type.Data,
offset = sliceOffset,
size = length
});
count++;
} break;
}
return(count);
}
unsafe int ProcessPackets(BitStream bs)
{
var address = new network_address();
address.length = sizeof(network_address);
var header = new UdpCHeader();
while (true)
{
if (bs.WriteCapacity <= 0)
{
return(0);
}
var sliceOffset = bs.GetBytesWritten();
var result = NativeReceive(ref header, bs.UnsafeDataPtr + sliceOffset,
Math.Min(NetworkParameterConstants.MTU, bs.WriteCapacity), ref address);
if (result <= 0)
{
return(result);
}
switch ((UdpCProtocol)header.Type)
{
case UdpCProtocol.ConnectionRequest:
{
if (!Listening)
{
continue;
}
Connection c;
if ((c = GetConnection(address)) == Connection.Null || c.State == NetworkConnection.State.Destroyed)
{
int id;
if (!m_FreeList.AquireConnectionId(out id))
{
SendPacket(UdpCProtocol.ConnectionReject, address);
continue;
}
int ver = m_ConnectionList[id].Version;
c = new Connection()
{
Id = id,
Version = ver,
State = NetworkConnection.State.Connected,
Address = address,
Attempts = 1,
LastAttempt = Timer.ElapsedMilliseconds
};
SetConnection(c);
AddConnection(c.Id);
}
else
{
c.Attempts++;
c.LastAttempt = Timer.ElapsedMilliseconds;
SetConnection(c);
}
SendPacket(UdpCProtocol.ConnectionAccept, new NetworkConnection {
m_NetworkId = c.Id, m_NetworkVersion = c.Version
});
}
break;
case UdpCProtocol.ConnectionReject:
{
// m_EventQ.Enqueue(Id, (int)NetworkEvent.Connect);
}
break;
case UdpCProtocol.ConnectionAccept:
{
Connection c = GetConnection(address);
if (c != Connection.Null)
{
if (c.State == NetworkConnection.State.Connected)
{
//DebugLog("Dropping connect request for an already connected endpoint [" + address + "]");
continue;
}
if (c.State == NetworkConnection.State.Connecting)
{
c.State = NetworkConnection.State.Connected;
UpdateConnection(c);
AddConnection(c.Id);
}
}
}
break;
case UdpCProtocol.Disconnect:
{
DebugLog("Disconnect packet received from " + address);
Connection c = GetConnection(address);
if (c != Connection.Null)
{
RemoveConnection(c);
AddDisconnection(c.Id);
}
}
break;
case UdpCProtocol.Data:
{
Connection c = GetConnection(address);
if (c == Connection.Null)
{
continue;
}
c.LastAttempt = Timer.ElapsedMilliseconds;
UpdateConnection(c);
if (c.State == NetworkConnection.State.Connecting)
{
c.State = NetworkConnection.State.Connected;
UpdateConnection(c);
AddConnection(c.Id);
}
var length = result - UdpCHeader.Length;
bs.IncreaseWritePtr(length);
m_EventQueue.PushEvent(new NetworkEvent
{
connectionId = c.Id,
type = NetworkEvent.Type.Data,
offset = sliceOffset,
size = length
});
}
break;
}
}
}
