/// <summary>
/// Creates a interface endpoint.
/// </summary>
/// <value>NetworkInterfaceEndPoint</value>
public unsafe int CreateInterfaceEndPoint(NetworkEndPoint address, out NetworkInterfaceEndPoint endpoint)
{
var slice = m_LocalAndTempEndpoint.AtIndexAsSlice(0, (uint)Binding.Baselib_RegisteredNetwork_Endpoint_MaxSize);
var error = default(ErrorState);
endpoint = default(NetworkInterfaceEndPoint);
NetworkEndpoint local;
local = Binding.Baselib_RegisteredNetwork_Endpoint_Create(
(Binding.Baselib_NetworkAddress *) & address.rawNetworkAddress,
slice,
&error);
if (error.code != ErrorCode.Success)
{
return((int)error.code);
}
endpoint.dataLength = (int)local.slice.size;
fixed(void *ptr = endpoint.data)
{
UnsafeUtility.MemCpy(ptr, (void *)local.slice.data, endpoint.dataLength);
}
return((int)Error.StatusCode.Success);
}
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);
}
public unsafe int ReceiveMessageEx(NetworkInterfaceEndPoint local, network_iovec *iov, int iov_len, ref NetworkInterfaceEndPoint remote)
{
IPCData data;
if (!m_IPCQueue.Peek(*(int *)local.data, out data))
{
return(0);
}
GetEndPointByHandle(data.from, out remote);
int totalLength = 0;
for (int i = 0; i < iov_len; i++)
{
var curLength = Math.Min(iov[i].len, data.length - totalLength);
UnsafeUtility.MemCpy(iov[i].buf, data.data + totalLength, curLength);
totalLength += curLength;
iov[i].len = curLength;
}
if (totalLength < data.length)
{
return(-1);
}
m_IPCQueue.Dequeue(*(int *)local.data, out data);
return(totalLength);
}
public unsafe NetworkEndPoint GetGenericEndPoint(NetworkInterfaceEndPoint endpoint)
{
// Set to a valid address so length is set correctly
var address = NetworkEndPoint.LoopbackIpv4;
UnsafeUtility.MemCpy(&address.rawNetworkAddress, endpoint.data, endpoint.dataLength);
return(address);
}
private unsafe void GetEndPointByHandle(int handle, out NetworkInterfaceEndPoint endpoint)
{
var temp = default(NetworkInterfaceEndPoint);
temp.dataLength = 4;
*(int *)temp.data = handle;
endpoint = temp;
}
public int CreateInterfaceEndPoint(NetworkEndPoint address, out NetworkInterfaceEndPoint endpoint)
{
if (address.Family != NetworkFamily.Ipv4)
{
throw new ArgumentException("Invalid family type");
}
endpoint = ParseNetworkAddress(address);
return(0);
}
internal unsafe void Update(NetworkInterfaceEndPoint local, NativeQueue <QueuedSendMessage> queue)
{
QueuedSendMessage val;
while (queue.TryDequeue(out val))
{
var ipcData = new IPCData();
UnsafeUtility.MemCpy(ipcData.data, val.Data, val.DataLength);
ipcData.length = val.DataLength;
ipcData.from = *(int *)local.data;
m_IPCQueue.Enqueue(*(int *)val.Dest.data, ipcData);
}
}
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]);
}
}
public unsafe NetworkEndPoint GetGenericEndPoint(NetworkInterfaceEndPoint endpoint)
{
// Set to a valid address so length is set correctly
var address = NetworkEndPoint.LoopbackIpv4;
var error = default(ErrorState);
var slice = m_LocalAndTempEndpoint.AtIndexAsSlice(0, (uint)Binding.Baselib_RegisteredNetwork_Endpoint_MaxSize);
NetworkEndpoint local;
local.slice = slice;
local.slice.size = (uint)endpoint.dataLength;
UnsafeUtility.MemCpy((void *)local.slice.data, endpoint.data, endpoint.dataLength);
Binding.Baselib_RegisteredNetwork_Endpoint_GetNetworkAddress(local, &address.rawNetworkAddress, &error);
if (error.code != ErrorCode.Success)
{
return(default);
public unsafe int Bind(NetworkInterfaceEndPoint endpoint)
{
long newSocket;
int ret = CreateAndBindSocket(out newSocket, *(network_address *)endpoint.data);
if (ret != 0)
{
return(ret);
}
Close();
m_UserData[0] = newSocket;
return(0);
}
public int CreateInterfaceEndPoint(NetworkEndPoint address, out NetworkInterfaceEndPoint endpoint)
{
if (!address.IsLoopback && !address.IsAny)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
throw new ArgumentException("IPC network driver can only handle loopback addresses");
#else
endpoint = default(NetworkInterfaceEndPoint);
return((int)Error.StatusCode.NetworkArgumentMismatch);
#endif
}
endpoint = IPCManager.Instance.CreateEndPoint(address.Port);
return((int)Error.StatusCode.Success);
}
public unsafe NetworkEndPoint GetGenericEndPoint(NetworkInterfaceEndPoint endpoint)
{
var address = NetworkEndPoint.AnyIpv4;
var addr = (network_address *)endpoint.data;
var sai = (sockaddr_in *)addr->data;
address.RawPort = sai->sin_port;
if (sai->sin_addr.s_addr != 0)
{
var bytes = new NativeArray <byte>(4, Allocator.Temp);
UnsafeUtility.MemCpy(bytes.GetUnsafePtr(), UnsafeUtility.AddressOf(ref sai->sin_addr.s_addr), 4);
address.SetRawAddressBytes(bytes);
}
return(address);
}
public unsafe bool GetEndPointPort(NetworkInterfaceEndPoint ep, out ushort port)
{
ManagerAccessHandle.Complete();
int id = *(int *)ep.data;
var values = m_IPCChannels.GetValueArray(Allocator.Temp);
var keys = m_IPCChannels.GetKeyArray(Allocator.Temp);
port = 0;
for (var i = 0; i < m_IPCChannels.Count(); ++i)
{
if (values[i] == id)
{
port = keys[i];
return(true);
}
}
return(false);
}
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]);
}
}
public unsafe int PeekNext(NetworkInterfaceEndPoint local, void *slice, out int length, out NetworkInterfaceEndPoint from)
{
ManagerAccessHandle.Complete();
IPCData data;
from = default(NetworkInterfaceEndPoint);
length = 0;
if (m_IPCQueue.Peek(*(int *)local.data, out data))
{
UnsafeUtility.MemCpy(slice, data.data, data.length);
length = data.length;
}
GetEndPointByHandle(data.from, out from);
return(length);
}
private static unsafe NetworkInterfaceEndPoint ParseNetworkAddress(NetworkEndPoint endPoint)
{
NetworkInterfaceEndPoint ep = default(NetworkInterfaceEndPoint);
var addr = (network_address *)ep.data;
var sai = (sockaddr_in *)addr->data;
#if (UNITY_EDITOR_OSX || ((UNITY_STANDALONE_OSX || UNITY_IOS) && !UNITY_EDITOR))
sai->sin_family.sa_family = (byte)NetworkFamily.Ipv4;
sai->sin_family.sa_len = (byte)sizeof(sockaddr_in);
#else
sai->sin_family.sa_family = (ushort)NetworkFamily.Ipv4;
#endif
sai->sin_port = endPoint.RawPort;
var bytes = endPoint.GetRawAddressBytes();
sai->sin_addr.s_addr = *(uint *)bytes.GetUnsafeReadOnlyPtr();
addr->length = sizeof(sockaddr_in);
ep.dataLength = sizeof(network_address);
return(ep);
}
public unsafe void Initialize(params INetworkParameter[] param)
{
//if (!Binding.Baselib_RegisteredNetwork_SupportsNetwork())
// throw new Exception("Baselib does not support networking");
m_Baselib = new NativeArray <BaselibData>(1, Allocator.Persistent);
var baselib = default(BaselibData);
rxQueueSize = k_defaultRxQueueSize;
txQueueSize = k_defaultTxQueueSize;
maximumPayloadSize = NetworkParameterConstants.MTU;
for (int i = 0; i < param.Length; ++i)
{
if (param[i] is BaselibNetworkParameter)
{
var config = (BaselibNetworkParameter)param[i];
rxQueueSize = config.receiveQueueCapacity;
txQueueSize = config.sendQueueCapacity;
maximumPayloadSize = config.maximumPayloadSize;
}
}
m_PayloadsTx = new Payloads(txQueueSize, maximumPayloadSize);
m_PayloadsRx = new Payloads(rxQueueSize, maximumPayloadSize);
m_LocalAndTempEndpoint = new UnsafeBaselibNetworkArray(2 * (int)Binding.Baselib_RegisteredNetwork_Endpoint_MaxSize);
baselib.m_PayloadsTx = m_PayloadsTx;
m_Baselib[0] = baselib;
// Emulate current interface behavior
NetworkInterfaceEndPoint ep = CreateInterfaceEndPoint(NetworkEndPoint.AnyIpv4);
if (Bind(ep) != 0)
{
throw new Exception("Could not bind socket");
}
}
public unsafe int Bind(NetworkInterfaceEndPoint endpoint)
{
var baselib = m_Baselib[0];
if (m_Baselib[0].m_Socket.handle != IntPtr.Zero)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AllSockets.OpenSockets.Remove(new SocketList.SocketId
{
socket = m_Baselib[0].m_Socket
});
#endif
Binding.Baselib_RegisteredNetwork_Socket_UDP_Close(m_Baselib[0].m_Socket);
baselib.m_Socket.handle = IntPtr.Zero;
// Recreate the payloads to make sure we do not loose any items from the queue
m_PayloadsRx.Dispose();
m_PayloadsRx = new Payloads(rxQueueSize, maximumPayloadSize);
}
var slice = m_LocalAndTempEndpoint.AtIndexAsSlice(0, (uint)Binding.Baselib_RegisteredNetwork_Endpoint_MaxSize);
UnsafeUtility.MemCpy((void *)slice.data, endpoint.data, endpoint.dataLength);
var error = default(ErrorState);
NetworkEndpoint local;
local.slice = slice;
Binding.Baselib_NetworkAddress localAddress;
Binding.Baselib_RegisteredNetwork_Endpoint_GetNetworkAddress(local, &localAddress, error.NativeErrorStatePtr);
baselib.m_Socket = Binding.Baselib_RegisteredNetwork_Socket_UDP_Create(
&localAddress,
Binding.Baselib_NetworkAddress_AddressReuse.Allow,
checked ((uint)txQueueSize),
checked ((uint)rxQueueSize),
error.NativeErrorStatePtr);
if (error.ErrorCode != ErrorCode.Success)
{
m_Baselib[0] = baselib;
return(-1);
}
// Schedule receive right away so we do not loose packets received before the first call to update
int count = 0;
var requests = stackalloc Binding.Baselib_RegisteredNetwork_Request[m_PayloadsRx.Capacity];
while (m_PayloadsRx.InUse < m_PayloadsRx.Capacity)
{
int handle = m_PayloadsRx.AcquireHandle();
requests[count] = m_PayloadsRx.GetRequestFromHandle(handle);
requests[count].requestUserdata = (IntPtr)handle + 1;
++count;
}
if (count > 0)
{
Binding.Baselib_RegisteredNetwork_Socket_UDP_ScheduleRecv(
baselib.m_Socket,
requests,
(uint)count,
error.NativeErrorStatePtr);
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AllSockets.OpenSockets.Add(new SocketList.SocketId
{
socket = baselib.m_Socket
});
#endif
m_Baselib[0] = baselib;
return(0);
}
public static unsafe int EndSendMessage(ref NetworkInterfaceSendHandle handle, ref NetworkInterfaceEndPoint address, IntPtr userData, ref NetworkSendQueueHandle sendQueue)
{
network_iovec iov;
iov.buf = (void *)handle.data;
iov.len = handle.size;
int errorcode = 0;
var addr = address;
return(NativeBindings.network_sendmsg(*(long *)userData, &iov, 1, ref *(network_address *)addr.data, ref errorcode));
}
/// <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));
}
private static unsafe int EndSendMessage(ref NetworkInterfaceSendHandle handle, ref NetworkInterfaceEndPoint address, IntPtr userData, ref NetworkSendQueueHandle sendQueueHandle)
{
var baselib = (BaselibData *)userData;
int index = handle.id;
var message = baselib->m_PayloadsTx.GetRequestFromHandle(index);
message.requestUserdata = (IntPtr)(index + 1);
message.payload.size = (uint)handle.size;
var addr = address;
UnsafeUtility.MemCpy((void *)message.remoteEndpoint.slice.data, addr.data, address.dataLength);
NetworkRequest *messagePtr = &message;
var error = default(ErrorState);
var count = (int)Binding.Baselib_RegisteredNetwork_Socket_UDP_ScheduleSend(
baselib->m_Socket,
messagePtr,
1u,
error.NativeErrorStatePtr);
if (error.ErrorCode != ErrorCode.Success)
{
baselib->m_PayloadsTx.ReleaseHandle(index);
return(-1);
}
return(handle.size);
}
public NetworkEndPoint GetGenericEndPoint(NetworkInterfaceEndPoint endpoint)
{
if (!IPCManager.Instance.GetEndPointPort(endpoint, out var port))
{
return(default);
