public static void Create_Set_Invalid() { IPEndPoint ep = new IPEndPoint(testIpV41, 500); AssertExtensions.Throws <ArgumentException>("socketAddress", () => ep.Create(new SocketAddress(Sockets.AddressFamily.InterNetworkV6))); //Different address families AssertExtensions.Throws <ArgumentException>("socketAddress", () => ep.Create(new SocketAddress(Sockets.AddressFamily.InterNetwork, 7))); // }
// helper function to create an ACTUAL new IPEndPoint from this. // server needs it to store new connections as unique IPEndPoints. public IPEndPoint DeepCopyIPEndPoint() { // we need to create a new IPEndPoint from 'temp' SocketAddress. // there is no 'new IPEndPoint(SocketAddress) constructor. // so we need to be a bit creative... // allocate a placeholder IPAddress to copy // our SocketAddress into. // -> needs to be the same address family. IPAddress ipAddress; if (temp.Family == AddressFamily.InterNetworkV6) { ipAddress = IPAddress.IPv6Any; } else if (temp.Family == AddressFamily.InterNetwork) { ipAddress = IPAddress.Any; } else { throw new Exception($"Unexpected SocketAddress family: {temp.Family}"); } // allocate a placeholder IPEndPoint // with the needed size form IPAddress. // (the real class. not NonAlloc) IPEndPoint placeholder = new IPEndPoint(ipAddress, 0); // the real IPEndPoint's .Create function can create a new IPEndPoint // copy from a SocketAddress. return((IPEndPoint)placeholder.Create(temp)); }
/// <summary> /// Reads the unmanaged sockaddr structure returned by a WinAPI function /// </summary> /// <param name="pSockaddrStructure">pointer to the unmanaged sockaddr structure</param> /// <returns>IP address and port number</returns> private static IPEndPoint ReadSockAddrStorageStructure(SOCKADDR_STORAGE sockAddrStorageStructure) { short sAddressFamily = sockAddrStorageStructure.ss_family; AddressFamily addressFamily = (AddressFamily)sAddressFamily; int sockAddrSructureSize; IPEndPoint ipEndPointAny; switch (addressFamily) { case AddressFamily.InterNetwork: // IP v4 address sockAddrSructureSize = 8; var socketAddress = new SocketAddress(AddressFamily.InterNetwork, sockAddrSructureSize); socketAddress[0] = 2; socketAddress[1] = 0; for (int i = 2; i < sockAddrSructureSize; i++) { socketAddress[i] = sockAddrStorageStructure.__ss_pad1[i - 2]; } ipEndPointAny = new IPEndPoint(IPAddress.Any, 0); return((IPEndPoint)ipEndPointAny.Create(socketAddress)); default: throw new ArgumentOutOfRangeException(nameof(sockAddrStorageStructure), "Unknown address family"); } }
static internal bool CheckEndPoint(SocketAddress sa) { if (!System.Environment.SocketSecurityEnabled) { return(true); } try { //weird, why is EndPoint.Create not static? Making a temp instance to be able to call the function var temp = new IPEndPoint(IPAddress.Loopback, 123); var endpoint = (IPEndPoint)temp.Create(sa); if (check_socket_policy == null) { check_socket_policy = GetUnityCrossDomainHelperMethod("CheckSocketEndPoint"); } return((bool)check_socket_policy.Invoke(null, new object [2] { endpoint.Address.ToString(), endpoint.Port })); } catch (Exception e) { Console.WriteLine("Unexpected error while trying to CheckEndPoint() : " + e); return(false); } }
public static void Create_InvalidSize_ThrowsArgumentException(IPAddress address, int size) { var endPoint = new IPEndPoint(address, 500); var socketAddress = new SocketAddress(Sockets.AddressFamily.InterNetwork, size); AssertExtensions.Throws <ArgumentException>("socketAddress", () => endPoint.Create(socketAddress)); }
public static IPEndPoint QueryRoutingInterface(string remoteAddress, int port) { var remoteEndPoint = new IPEndPoint(IPAddress.Parse(remoteAddress), port); var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); var address = remoteEndPoint.Serialize(); var remoteAddrBytes = new byte[address.Size]; for (int i = 0; i < address.Size; i++) { remoteAddrBytes[i] = address[i]; } var outBytes = new byte[remoteAddrBytes.Length]; socket.IOControl( IOControlCode.RoutingInterfaceQuery, remoteAddrBytes, outBytes); for (int i = 0; i < address.Size; i++) { address[i] = outBytes[i]; } return((IPEndPoint)remoteEndPoint.Create(address)); }
public void CreateAndSerialize() { SocketAddress addr = endPoint1.Serialize(); EndPoint endPoint3 = endPoint2.Create(addr); Assert.IsTrue(endPoint1.Equals(endPoint3), "#1"); IPAddress ipAddress = IPAddress.Parse("255.255.255.255"); IPEndPoint endPoint4 = new IPEndPoint(ipAddress, MyMaxPort); addr = endPoint4.Serialize(); EndPoint endPoint5 = endPoint2.Create(addr); Assert.IsTrue(endPoint4.Equals(endPoint5), "#2"); Assert.AreEqual(endPoint5.ToString(), "255.255.255.255:" + MyMaxPort, "#3"); }
public static IPEndPoint QueryRoutingInterface(Socket socket, IPEndPoint remoteEP) { ValidateHelper.CheckNullArgument("sock", socket); ValidateHelper.CheckNullArgument("remoteEP", remoteEP); SocketAddress socketAddress = remoteEP.Serialize(); byte[] optionInValue = new byte[socketAddress.Size]; for (int i = 0; i < socketAddress.Size; i++) { optionInValue[i] = socketAddress[i]; } byte[] optionOutValue = new byte[optionInValue.Length]; socket.IOControl(IOControlCode.RoutingInterfaceQuery, optionInValue, optionOutValue); for (int j = 0; j < socketAddress.Size; j++) { socketAddress[j] = optionOutValue[j]; } IPEndPoint point = (IPEndPoint)remoteEP.Create(socketAddress); point.Port = ((IPEndPoint)socket.LocalEndPoint).Port; return(point); }
// Taken From: https://searchcode.com/codesearch/view/7464800/ private static IPEndPoint QueryRoutingInterface( Socket socket, IPEndPoint remoteEndPoint) { SocketAddress address = remoteEndPoint.Serialize(); byte[] remoteAddrBytes = new byte[address.Size]; for (int i = 0; i < address.Size; i++) { remoteAddrBytes[i] = address[i]; } byte[] outBytes = new byte[remoteAddrBytes.Length]; socket.IOControl( IOControlCode.RoutingInterfaceQuery, remoteAddrBytes, outBytes); for (int i = 0; i < address.Size; i++) { address[i] = outBytes[i]; } EndPoint ep = remoteEndPoint.Create(address); return((IPEndPoint)ep); }
internal static unsafe IPEndPoint GetLocalEndPoint(IntPtr memoryBlob, IntPtr originalAddress) { if (NetEventSource.IsEnabled) { NetEventSource.Enter(null); } SocketAddress v4address = new SocketAddress(AddressFamily.InterNetwork, IPv4AddressSize); SocketAddress v6address = new SocketAddress(AddressFamily.InterNetworkV6, IPv6AddressSize); byte * pMemoryBlob = (byte *)memoryBlob; HTTP_REQUEST *request = (HTTP_REQUEST *)pMemoryBlob; IntPtr address = request->Address.pLocalAddress != null ? (IntPtr)(pMemoryBlob - (byte *)originalAddress + (byte *)request->Address.pLocalAddress) : IntPtr.Zero; CopyOutAddress(address, ref v4address, ref v6address); IPEndPoint endpoint = null; if (v4address != null) { endpoint = s_any.Create(v4address) as IPEndPoint; } else if (v6address != null) { endpoint = s_ipv6Any.Create(v6address) as IPEndPoint; } if (NetEventSource.IsEnabled) { NetEventSource.Exit(null); } return(endpoint); }
public static void SerializeCreate_Compare_Equal() { //Serializing an IPEndPoint from a SocketAddress should produce the same output as creating one from a SocketAddress IPEndPoint ep = new IPEndPoint(testIpV41, 500); SocketAddress sa = ep.Serialize(); EndPoint ep2 = ep.Create(sa); Assert.Equal(ep, ep2); }
public static void Create_DefaultAddress_Success(IPAddress address, int size, IPAddress expectedAddress) { var endPoint = new IPEndPoint(address, 500); var socketAddress = new SocketAddress(address.AddressFamily, size); IPEndPoint createdEndPoint = Assert.IsType <IPEndPoint>(endPoint.Create(socketAddress)); Assert.NotSame(endPoint, createdEndPoint); Assert.Equal(expectedAddress, createdEndPoint.Address); Assert.Equal(expectedAddress.AddressFamily, createdEndPoint.AddressFamily); Assert.Equal(0, createdEndPoint.Port); }
internal static IPEndPoint /*!*/ UnpackSockAddr(MutableString /*!*/ stringAddress) { byte[] bytes = stringAddress.ConvertToBytes(); SocketAddress addr = new SocketAddress(AddressFamily.InterNetwork, bytes.Length); for (int i = 0; i < bytes.Length; ++i) { addr[i] = bytes[i]; } IPEndPoint ep = new IPEndPoint(0, 0); return((IPEndPoint)ep.Create(addr)); }
public static void Serialize_Create_ReturnsEqual(IPAddress address, int expectedSize) { var endPoint = new IPEndPoint(address, 500); SocketAddress serializedAddress = endPoint.Serialize(); Assert.Equal(address.AddressFamily, serializedAddress.Family); Assert.Equal(expectedSize, serializedAddress.Size); IPEndPoint createdEndPoint = Assert.IsType <IPEndPoint>(endPoint.Create(serializedAddress)); Assert.NotSame(endPoint, createdEndPoint); Assert.Equal(endPoint, createdEndPoint); }
public void Ctor_IPAddressInt() { Assert.Throws <ArgumentNullException> (delegate { new IPEndPoint(null, 80); }, "IPEndPoint(null,int)"); IPAddress a = new IPAddress(new byte [16]); Assert.AreEqual(AddressFamily.InterNetworkV6, a.AddressFamily, "IPAddress.AddressFamily"); IPEndPoint ep = new IPEndPoint(a, 0); Assert.IsTrue(Object.ReferenceEquals(a, ep.Address), "Address"); Assert.AreEqual(AddressFamily.InterNetworkV6, ep.AddressFamily, "AddressFamily"); Assert.AreEqual(0, ep.Port, "Port"); Assert.Throws <ArgumentException> (delegate { SocketAddress sa = new SocketAddress(AddressFamily.InterNetwork); ep.Create(sa); }, "Create(InterNetwork)"); Assert.Throws <ArgumentException> (delegate { SocketAddress sa = new SocketAddress(AddressFamily.Unknown); ep.Create(sa); }, "Create(Unknown)"); Assert.Throws <ArgumentException> (delegate { SocketAddress sa = new SocketAddress(AddressFamily.Unspecified); ep.Create(sa); }, "Create(Unspecified)"); EndPoint ep2 = ep.Create(new SocketAddress(AddressFamily.InterNetworkV6)); Assert.IsFalse(ep.Equals(null), "Equals(null)"); Assert.IsTrue(ep.Equals(ep), "Equals(self)"); Assert.IsTrue(ep.Equals(ep2), "Equals(Create)"); Assert.AreEqual("InterNetworkV6:28:{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}", ep.Serialize().ToString(), "Serialize"); // Assert.AreEqual ("0000:0000:0000:0000:0000:0000:0.0.0.0:0", ep.ToString (), "ToString"); }
public MFTestResults SocketExceptionTest11_AccessDenied() { /// <summary> /// 1. Causes a AccessDenied error /// </summary> /// bool isCorrectCatch = false; bool isAnyCatch = false; SocketPair testSockets = new SocketPair(ProtocolType.Udp, SocketType.Dgram); try { try { int clientPort = SocketTools.nextPort; int serverPort = SocketTools.nextPort; int tempPort = serverPort; testSockets.socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, false); testSockets.Startup(clientPort, serverPort); IPEndPoint epBroadcast = new IPEndPoint(SocketTools.DottedDecimalToIp((byte)255, (byte)255, (byte)255, (byte)255), tempPort); EndPoint serverEndPoint = epBroadcast.Create(epBroadcast.Serialize()); testSockets.socketClient.SendTo(testSockets.bufSend, serverEndPoint); } catch (SocketException) { isCorrectCatch = true; isAnyCatch = true; } } catch (System.Exception e) { isAnyCatch = true; Log.Comment("Incorrect exception caught: " + e.Message); } finally { testSockets.TearDown(); } if (!isAnyCatch) { Log.Comment("No exception caught"); } return(isCorrectCatch ? MFTestResults.Pass : MFTestResults.Fail); }
public void SocketExceptionTest11_AccessDenied() { SocketPair testSockets = new SocketPair(ProtocolType.Udp, SocketType.Dgram); Assert.Throws(typeof(SocketException), () => { int clientPort = SocketTools.nextPort; int serverPort = SocketTools.nextPort; int tempPort = serverPort; testSockets.socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, false); testSockets.Startup(clientPort, serverPort); IPEndPoint epBroadcast = new IPEndPoint(SocketTools.DottedDecimalToIp((byte)255, (byte)255, (byte)255, (byte)255), tempPort); EndPoint serverEndPoint = epBroadcast.Create(epBroadcast.Serialize()); testSockets.socketClient.SendTo(testSockets.bufSend, serverEndPoint); }); testSockets.TearDown(); }
/// <summary> /// Reads the unmanaged sockaddr structure returned by a WinAPI function /// </summary> /// <param name="pSockaddrStructure">pointer to the unmanaged sockaddr structure</param> /// <returns>IP address and port number</returns> public static IPEndPoint ReadSockaddrStructure(IntPtr pSockaddrStructure) { short sAddressFamily = Marshal.ReadInt16(pSockaddrStructure); AddressFamily addressFamily = (AddressFamily)sAddressFamily; int sockAddrSructureSize; IPEndPoint ipEndPointAny; switch (addressFamily) { case AddressFamily.InterNetwork: // IP v4 address sockAddrSructureSize = 16; ipEndPointAny = new IPEndPoint(IPAddress.Any, 0); break; case AddressFamily.InterNetworkV6: // IP v6 address sockAddrSructureSize = 28; ipEndPointAny = new IPEndPoint(IPAddress.IPv6Any, 0); break; default: throw new ArgumentOutOfRangeException("pSockaddrStructure", "Unknown address family"); } // get bytes of the sockadrr structure byte[] sockAddrSructureBytes = new byte[sockAddrSructureSize]; Marshal.Copy(pSockaddrStructure, sockAddrSructureBytes, 0, sockAddrSructureSize); // create SocketAddress from bytes var socketAddress = new SocketAddress(AddressFamily.Unspecified, sockAddrSructureSize); for (int i = 0; i < sockAddrSructureSize; i++) { socketAddress[i] = sockAddrSructureBytes[i]; } // create IPEndPoint from SocketAddress IPEndPoint result = (IPEndPoint)ipEndPointAny.Create(socketAddress); return(result); }
/* * /// <summary> * /// Manually updates PlayerData from memory-mapped file. * /// </summary> * public void Update() * { * Stopwatch sw = new Stopwatch(); * decimal avg = 0; * for (int i = 0; i < 10000; i++) * { * sw.Start(); * // Make sure the memory-mapped file is loaded * if (_mappedFile == null) OpenMumbleLink(); * * // Read memory-mapped file * _accessor.Read(0, out data); * * unsafe * { * fixed (LinkedMem* _data = &data) * { * * byte[] tempBytes = new byte[512]; * IntPtr tempByteIntPtr = new IntPtr((void*)_data->context); * Marshal.Copy(tempByteIntPtr, tempBytes, 0, 512); * * * * float f = _data->fAvatarPosition[0]; * * * int size = Marshal.SizeOf(typeof(LinkedMem)); * byte[] dataBytes = new byte[size]; * IntPtr dataBytesIntPtr = new IntPtr((void*)_data); * Marshal.Copy(dataBytesIntPtr, dataBytes, 0, size); * PlayerData pd = dataBytes.ToStruct<PlayerData>(); * } * } * sw.Stop(); * avg += sw.ElapsedTicks; * sw.Reset(); * } * avg /= 10000; * Populate(); * } * * /// <summary> * /// Manually updates PlayerData from byte array. * /// </summary> * /// <param name="byteArray">Data from which to populate the Player object.</param> * public void Update(byte[] byteArray) * { * if (Marshal.SizeOf(typeof(PlayerData)) != byteArray.Length) * { * throw new ArgumentException(String.Format( * "The parameter {0} (length {1}) is invalid for converting to PlayerData struct.", * (MethodBase.GetCurrentMethod().GetParameters()[0]).Name, * byteArray.Length)); * } * _pd = byteArray.ToStruct<PlayerData>(); * Populate(); * } * * /// <summary> * /// Poll the memory-mapped file for data. * /// </summary> * private void Populate() * { * PopulateIdentity(); * PopulateServerAddress(); * } * * /// <summary> * /// Parses identity string into Identity struct using JsonConvert. * /// </summary> * private void PopulateIdentity() * { * string identityJson = _pd.identityString.Substring(0, _pd.identityString.IndexOf('}') + 1); * if (identityJson.Length > 0) * { * _pi = JsonConvert.DeserializeObject<Identity>(identityJson); * } * } * * /// <summary> * /// Parses server address byte array into IPEndPoint. * /// </summary> * private void PopulateServerAddress() * { * _serverAddress = GetServerAddress(_pd.serverAddress); * } */ /// <summary> /// Helper method to convert byte array into IPEndpoint. /// </summary> /// <param name="serverAddressBytes"></param> /// <returns></returns> public static IPEndPoint GetServerAddress(byte[] serverAddressBytes) { if (serverAddressBytes.Length < 2) { return(new IPEndPoint(IPAddress.Any, 0)); } AddressFamily addressFamily = (AddressFamily)BitConverter.ToInt16(serverAddressBytes, 0); int sockAddrSructureSize; IPEndPoint ipEndPointAny; IPEndPoint result; switch (addressFamily) { case AddressFamily.InterNetwork: // IP v4 address sockAddrSructureSize = 16; ipEndPointAny = new IPEndPoint(IPAddress.Any, 0); break; case AddressFamily.InterNetworkV6: // IP v6 address sockAddrSructureSize = 28; ipEndPointAny = new IPEndPoint(IPAddress.IPv6Any, 0); break; default: return(new IPEndPoint(IPAddress.Any, 0)); //throw new ArgumentOutOfRangeException("pSockaddrStructure", "Unknown address family"); } var socketAddress = new SocketAddress(AddressFamily.Unspecified, sockAddrSructureSize); for (int i = 0; i < sockAddrSructureSize; i++) { socketAddress[i] = serverAddressBytes[i]; } result = (IPEndPoint)ipEndPointAny.Create(socketAddress); return(result); }
public void Address() { IPEndPoint ep = new IPEndPoint(0, 0); Assert.AreEqual(AddressFamily.InterNetwork, ep.AddressFamily, "AddressFamily"); ep.Address = null; Assert.IsNull(ep.Address, "null"); Assert.Throws <NullReferenceException> (delegate { Assert.AreEqual(AddressFamily.InterNetwork, ep.AddressFamily); }, "null-AddressFamily"); Assert.Throws <NullReferenceException> (delegate { ep.ToString(); }, "null-ToString"); Assert.Throws <NullReferenceException> (delegate { ep.Create(new SocketAddress(AddressFamily.InterNetworkV6)); }, "null-Create"); // change family IPAddress a = new IPAddress(new byte [16]); ep.Address = a; Assert.AreEqual(AddressFamily.InterNetworkV6, ep.AddressFamily, "v6-AddressFamily"); }
private static IPEndPoint CreateManagedSocketAddress(IntPtr socketAddressPtr) { var addressFamily = (AddressFamily)Marshal.ReadInt16(socketAddressPtr); int socketAddressSize; IPEndPoint ipEndPointAny; switch (addressFamily) { case AddressFamily.InterNetwork: socketAddressSize = 16; ipEndPointAny = new IPEndPoint(IPAddress.Any, 0); break; case AddressFamily.InterNetworkV6: socketAddressSize = 28; ipEndPointAny = new IPEndPoint(IPAddress.IPv6Any, 0); break; default: throw new ArgumentOutOfRangeException(); } var socketAddressBytes = new byte[socketAddressSize]; Marshal.Copy(socketAddressPtr, socketAddressBytes, 0, socketAddressSize); var socketAddress = new SocketAddress(AddressFamily.Unspecified, socketAddressSize); for (var i = 0; i < socketAddressSize; ++i) { socketAddress[i] = socketAddressBytes[i]; } return((IPEndPoint)ipEndPointAny.Create(socketAddress)); }
static private IPEndPoint QueryRoutingInterface( Socket socket, IPEndPoint remoteEndPoint) { var socketAddress = remoteEndPoint.Serialize(); var remoteAddressBytes = new byte[socketAddress.Size]; for (int i = 0; i < socketAddress.Size; i++) { remoteAddressBytes[i] = socketAddress[i]; } var outBytes = new byte[remoteAddressBytes.Length]; socket.IOControl(IOControlCode.RoutingInterfaceQuery, remoteAddressBytes, outBytes); for (int i = 0; i < socketAddress.Size; i++) { socketAddress[i] = outBytes[i]; } return((IPEndPoint)remoteEndPoint.Create(socketAddress)); }
public void Ctor_LongInt() { IPEndPoint ep = new IPEndPoint(0, 80); Assert.AreEqual(new IPAddress(0), ep.Address, "Address"); Assert.AreEqual(AddressFamily.InterNetwork, ep.AddressFamily, "AddressFamily"); Assert.AreEqual(80, ep.Port, "Port"); Assert.Throws <ArgumentNullException> (delegate { ep.Create(null); }, "Create(null)"); // note: documented as ArgumentException Assert.Throws <ArgumentOutOfRangeException> (delegate { SocketAddress sa = new SocketAddress(AddressFamily.InterNetwork, 1); Assert.IsTrue(sa.Size < 8, "Size"); ep.Create(sa); }, "Create(bad-size)"); Assert.Throws <ArgumentException> (delegate { SocketAddress sa = new SocketAddress(AddressFamily.InterNetworkV6); Assert.IsTrue(sa.Size >= 8, "SizeV6"); ep.Create(sa); }, "Create(InterNetworkV6)"); Assert.Throws <ArgumentException> (delegate { SocketAddress sa = new SocketAddress(AddressFamily.Unknown); ep.Create(sa); }, "Create(Unknown)"); Assert.Throws <ArgumentException> (delegate { SocketAddress sa = new SocketAddress(AddressFamily.Unspecified); ep.Create(sa); }, "Create(Unspecified)"); EndPoint ep2 = ep.Create(new SocketAddress(AddressFamily.InterNetwork)); Assert.IsFalse(ep.Equals(null), "Equals(null)"); Assert.IsTrue(ep.Equals(ep), "Equals(self)"); Assert.IsFalse(ep.Equals(ep2), "Equals(Create)"); Assert.AreEqual("InterNetwork:16:{0,80,0,0,0,0,0,0,0,0,0,0,0,0}", ep.Serialize().ToString(), "Serialize"); Assert.AreEqual("0.0.0.0:80", ep.ToString(), "ToString"); }
public static void Create_NullSocketAddress_ThrowsArgumentNullException() { var endPoint = new IPEndPoint(1, 500); Assert.Throws <ArgumentNullException>("socketAddress", () => endPoint.Create(null)); }
public static void Create_InvalidAddressFamily_ThrowsArgumentException(IPEndPoint endPoint, SocketAddress socketAddress) { AssertExtensions.Throws <ArgumentException>("socketAddress", () => endPoint.Create(socketAddress)); }
public static void Create_Set_Invalid() { IPEndPoint ep = new IPEndPoint(testIpV41, 500); Assert.Throws<ArgumentException>(() => ep.Create(new SocketAddress(Sockets.AddressFamily.InterNetworkV6))); //Different address families Assert.Throws<ArgumentException>(() => ep.Create(new SocketAddress(Sockets.AddressFamily.InterNetwork, 7))); // }
private void RecvUdpDataLooper(object obj) { try { uint startConvId = 10000; const int pollTimeout = 100000; List <Packet> packets = new List <Packet>(); byte[] rawBuffer = new byte[KcpConstants.Packet_Length]; EndPoint remote = new IPEndPoint(IPAddress.Any, 0); while (!m_Dispose) { if (!m_Socket.Poll(pollTimeout, SelectMode.SelectRead)) { continue; } if (m_Dispose) { break; } int size = m_Socket.ReceiveFrom(rawBuffer, SocketFlags.None, ref remote); if (size > 0) { uint cid = (uint)remote.GetHashCode(); if (!m_Channels.TryGetValue(cid, out ServerChannel channel)) { if (size == 4) { uint flag = KcpHelper.Decode32u(rawBuffer, 0); if (flag == KcpConstants.Flag_Connect) { uint conv = startConvId++; EndPoint point = remote.Create(remote.Serialize()); channel = new ServerChannel(new KcpConServer(cid, conv, m_Socket, point)); if (m_Channels.TryAdd(cid, channel)) { KcpHelper.Encode32u(rawBuffer, 0, KcpConstants.Flag_Connect); KcpHelper.Encode32u(rawBuffer, 4, conv); channel.Send(rawBuffer, 0, 8); channel.Flush(); } } } else { Logger.Error($"not connect size={size}"); } } else if (size > KcpConstants.Head_Size) { uint remoteCid = KcpHelper.Decode32u(rawBuffer, 0); if (cid == remoteCid) { byte msgChannel = rawBuffer[KcpConstants.Conv_Size]; if (msgChannel == MsgChannel.Reliable) { channel.Input(rawBuffer, KcpConstants.Head_Size, size - KcpConstants.Head_Size); channel.RecvReliablePackets(m_Process, packets, m_Listener); } else if (msgChannel == MsgChannel.Unreliable) { channel.RecvUnreliablePackets(rawBuffer, KcpConstants.Head_Size, size - KcpConstants.Head_Size, m_Process, packets); } } else { Logger.Error($"conv {cid} != {remoteCid}"); } } else { Logger.Error($"size={size} < {KcpConstants.Head_Size}"); } } } } catch (Exception e) { Logger.Error(e.ToString()); } }
/// <summary> /// Called when [new client accepted]. /// </summary> /// <param name="listener">The listener.</param> /// <param name="client">The client.</param> /// <param name="state">The state.</param> protected override void OnNewClientAccepted(ISocketListener listener, Socket client, object state) { var paramArray = state as object[]; var receivedData = paramArray[0] as byte[]; var socketAddress = paramArray[1] as SocketAddress; var remoteEndPoint = (socketAddress.Family == AddressFamily.InterNetworkV6 ? m_EndPointIPv6.Create(socketAddress) : m_EndPointIPv4.Create(socketAddress)) as IPEndPoint; if (m_IsUdpRequestInfo) { ProcessPackageWithSessionID(client, remoteEndPoint, receivedData); } else { ProcessPackageWithoutSessionID(client, remoteEndPoint, receivedData); } }
public override EndPoint Create(SocketAddress socketAddress) { mIsDirty = true; return(mIPEndPoint.Create(socketAddress)); }
/// <summary> /// Called when [new client accepted]. /// </summary> /// <param name="listener">The listener.</param> /// <param name="client">The client.</param> /// <param name="state">The state.</param> protected override void OnNewClientAccepted(ISocketListener listener, Socket client, object state) { var paramArray = state as object[]; var receivedData = paramArray[0] as byte[]; var socketAddress = paramArray[1] as SocketAddress; var remoteEndPoint = (socketAddress.Family == AddressFamily.InterNetworkV6 ? m_EndPointIPv6.Create(socketAddress) : m_EndPointIPv4.Create(socketAddress)) as IPEndPoint; try { if (m_IsUdpRequestInfo) { ProcessPackageWithSessionID(client, remoteEndPoint, receivedData); } else { ProcessPackageWithoutSessionID(client, remoteEndPoint, receivedData); } } catch (Exception e) { if (AppServer.Logger.IsErrorEnabled) { AppServer.Logger.Error("Process UDP package error!", e); } } }
private void UdpReceiveEndHandler(IAsyncResult ar) { Circuit circuit; var pck = (UDPReceivePacket)ar.AsyncState; try { pck.DataLength = m_UdpSocket.EndReceiveFrom(ar, ref pck.RemoteEndPoint); } catch { return; } finally { if (m_InboundRunning) { BeginUdpReceive(); } } pck.TransferredAtTime = Environment.TickCount; pck.EnqueuedAtTime = Environment.TickCount; /* we do not want to spend time on decoding packets that are unknown where they belong */ if (!m_Circuits.TryGetValue(pck.RemoteEndPoint, out circuit) || circuit.ForceUseCircuitCode) { try { /* check whether we got an UseCircuitCode */ var mType = pck.ReadMessageType(); if (MessageType.UseCircuitCode == mType) { var circuitcode = pck.ReadUInt32(); /* it is, so we have actually to look for the circuitcode and set up the remote endpoint here */ lock (m_UseCircuitCodeProcessingLock) { if (m_Circuits.TryGetValue(circuitcode, out circuit)) { circuit.ForceUseCircuitCode = false; var sessionID = pck.ReadUUID(); var agentID = pck.ReadUUID(); var acircuit = circuit as AgentCircuit; if (acircuit != null) { /* there it is check for SessionID and AgentID */ if (!acircuit.SessionID.Equals(sessionID) || !acircuit.AgentID.Equals(agentID) || !VerifyEndpointAddress(acircuit, pck.RemoteEndPoint)) { /* no match on SessionID or AgentID */ m_Log.DebugFormat("Unmatched UseCircuitCode for AgentID {0} SessionID {1} CircuitCode {2} received", agentID, sessionID, circuitcode); } else { /* it matches, so we have to change the actual key */ var endpoint = new IPEndPoint(0, 0); var ep = endpoint.Create(pck.RemoteEndPoint.Serialize()); m_Circuits.Remove(circuit.CircuitCode); m_Circuits.Add(ep, circuit.CircuitCode, circuit); circuit.RemoteEndPoint = ep; try { circuit.Start(); var scene = Scene; RegionOptionFlags regionFlags = scene.RegionSettings.AsFlags; var rh = new RegionHandshake { RegionFlags = regionFlags, SimAccess = scene.Access, SimName = scene.Name, SimOwner = scene.Owner.ID, IsEstateManager = scene.IsEstateManager(acircuit.Agent.Owner), WaterHeight = scene.RegionSettings.WaterHeight, BillableFactor = 1, TerrainStartHeight00 = scene.RegionSettings.Elevation1SW, TerrainStartHeight01 = scene.RegionSettings.Elevation2SW, TerrainStartHeight10 = scene.RegionSettings.Elevation1NW, TerrainStartHeight11 = scene.RegionSettings.Elevation2NW, TerrainHeightRange00 = scene.RegionSettings.Elevation1SE, TerrainHeightRange01 = scene.RegionSettings.Elevation2SE, TerrainHeightRange10 = scene.RegionSettings.Elevation1NE, TerrainHeightRange11 = scene.RegionSettings.Elevation2NE, TerrainBase0 = UUID.Zero, TerrainBase1 = UUID.Zero, TerrainBase2 = UUID.Zero, TerrainBase3 = UUID.Zero, TerrainDetail0 = scene.RegionSettings.TerrainTexture1, TerrainDetail1 = scene.RegionSettings.TerrainTexture2, TerrainDetail2 = scene.RegionSettings.TerrainTexture3, TerrainDetail3 = scene.RegionSettings.TerrainTexture4, RegionID = scene.ID, CacheID = UUID.Random, CPUClassID = 9, CPURatio = 1, ColoName = string.Empty, ProductSKU = VersionInfo.SimulatorVersion, ProductName = scene.ProductName }; rh.RegionExtData.Add(new RegionHandshake.RegionExtDataEntry { RegionFlagsExtended = (ulong)regionFlags, RegionProtocols = RegionProtocolFlags.AgentAppearanceService }); /* Immediate Ack */ circuit.SendCircuitPacket(UDPPacket.PacketAckImmediate(pck.SequenceNumber)); circuit.SendMessage(rh); return; } catch (Exception e) { m_Log.DebugFormat("UseCircuitCode Exception {0} {1}\n{2}", e.GetType().Name, e.Message, e.StackTrace); circuit.Stop(); } } } } else { m_Log.DebugFormat("UseCircuitCode received for unknown circuit {0}", circuitcode); } } } else if (MessageType.NetTest == mType && (uint)m_NetTestSeqNumber == pck.SequenceNumber || pck.ReadUInt16() == (ushort)LocalPort) { OnNetTest?.Invoke(((IPEndPoint)pck.RemoteEndPoint).Address, LocalPort); return; } #if DEBUG if (mType != MessageType.StartPingCheck) { /* do not show that message for a StartPingCheck */ m_Log.DebugFormat("Unmatched endpoint address {0} for UDP server at port {1}", pck.RemoteEndPoint.ToString(), LocalPort); } #endif } catch { /* no action required */ } return; } /* here we spend time on decoding */ if (pck.IsUndersized) { /* packet is undersized so we throw it away as well */ return; } /* now we know that the packet is at least valid * We can pass it to the circuit handler. */ /* we decode the ack numbers here, the code does not need to be implemented in the UDP Circuit Handler */ List <UInt32> acknumbers = null; if (pck.HasAckFlag) { try { acknumbers = pck.Acks; } catch { /* packet is undersized so we throw it away as well */ return; } } try { circuit.PacketReceived(pck.RemoteEndPoint, pck, acknumbers); } catch (Exception e) { /* we catch all issues here */ m_Log.ErrorFormat("Exception {0} => {1} at {2}", e.GetType().Name, e.ToString(), e.StackTrace); } /* return the buffer to the pool */ }