/// <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);