From: Matthew Endsley <mendsley@gmail.com>
Date: Wed, 3 Feb 2021 10:11:28 +0000 (-0800)
Subject: Use IPEndPoint internally in ThreadLimitedUdpConnectionListener
X-Git-Tag: 1.0.0~20^2~8^2~2
X-Git-Url: https://git.deb.at/?a=commitdiff_plain;h=920586ce9d2ec6c5dd25781d1ac1be2d80159d79;p=rhonda%2Fimpostor.hazel.git

Use IPEndPoint internally in ThreadLimitedUdpConnectionListener
---

diff --git a/Hazel/Dtls/DtlsConnectionListener.cs b/Hazel/Dtls/DtlsConnectionListener.cs
index 088dcb7..088a113 100644
--- a/Hazel/Dtls/DtlsConnectionListener.cs
+++ b/Hazel/Dtls/DtlsConnectionListener.cs
@@ -145,7 +145,7 @@ namespace Hazel.Dtls
         // HMAC key to validate ClientHello cookie
         private HMAC currentCookieHmac;
 
-        private readonly ConcurrentDictionary<EndPoint, PeerData> existingPeers = new ConcurrentDictionary<EndPoint, PeerData>();
+        private readonly ConcurrentDictionary<IPEndPoint, PeerData> existingPeers = new ConcurrentDictionary<IPEndPoint, PeerData>();
 
         private long connectionId_unsafe =  0;
 
@@ -234,7 +234,7 @@ namespace Hazel.Dtls
         /// This is primarily a wrapper around ProcessIncomingMessage
         /// to ensure `reader.Recycle()` is always called
         /// </summary>
-        protected override void ProcessIncomingMessageFromOtherThread(MessageReader reader, EndPoint peerAddress, ConnectionId connectionId)
+        protected override void ProcessIncomingMessageFromOtherThread(MessageReader reader, IPEndPoint peerAddress, ConnectionId connectionId)
         {
             ByteSpan message = new ByteSpan(reader.Buffer, reader.Offset + reader.Position, reader.BytesRemaining);
             this.ProcessIncomingMessage(message, peerAddress);
@@ -244,7 +244,7 @@ namespace Hazel.Dtls
         /// <summary>
         /// Handle an incoming datagram from the network
         /// </summary>
-        private void ProcessIncomingMessage(ByteSpan message, EndPoint peerAddress)
+        private void ProcessIncomingMessage(ByteSpan message, IPEndPoint peerAddress)
         {
             PeerData peer = null;
             if (!this.existingPeers.TryGetValue(peerAddress, out peer))
@@ -442,7 +442,7 @@ namespace Hazel.Dtls
         /// True if further processing of the underlying datagram
         /// should be continues. Otherwise, false.
         /// </returns>
-        private bool ProcessHandshake(PeerData peer, EndPoint peerAddress, ref Record record, ByteSpan message)
+        private bool ProcessHandshake(PeerData peer, IPEndPoint peerAddress, ref Record record, ByteSpan message)
         {
             // Each record may have multiple handshake payloads
             while (message.Length > 0)
@@ -706,7 +706,7 @@ namespace Hazel.Dtls
         /// <param name="record">Parent record</param>
         /// <param name="handshake">Parent Handshake header</param>
         /// <param name="payload">Handshake payload</param>
-        private bool HandleClientHello(PeerData peer, EndPoint peerAddress, ref Record record, ref Handshake handshake, ByteSpan originalMessage, ByteSpan payload)
+        private bool HandleClientHello(PeerData peer, IPEndPoint peerAddress, ref Record record, ref Handshake handshake, ByteSpan originalMessage, ByteSpan payload)
         {
             // Verify message sequence
             if (handshake.MessageSequence != 0)
@@ -1023,7 +1023,7 @@ namespace Hazel.Dtls
         /// </summary>
         /// <param name="message">Incoming datagram</param>
         /// <param name="peerAddress">Originating address</param>
-        private void HandleNonPeerRecord(ByteSpan message, EndPoint peerAddress)
+        private void HandleNonPeerRecord(ByteSpan message, IPEndPoint peerAddress)
         {
             Record record;
             if (!Record.Parse(out record, message))
@@ -1113,7 +1113,7 @@ namespace Hazel.Dtls
         }
 
         //Send a HelloVerifyRequest handshake message to a peer
-        private void SendHelloVerifyRequest(EndPoint peerAddress, ulong recordSequence, ushort epoch, IRecordProtection recordProtection)
+        private void SendHelloVerifyRequest(IPEndPoint peerAddress, ulong recordSequence, ushort epoch, IRecordProtection recordProtection)
         {
             Handshake handshake = new Handshake();
             handshake.MessageType = HandshakeType.HelloVerifyRequest;
@@ -1152,7 +1152,7 @@ namespace Hazel.Dtls
         /// <summary>
         /// Handle a requrest to send a datagram to the network
         /// </summary>
-        protected override void QueueRawData(ByteSpan span, EndPoint remoteEndPoint)
+        protected override void QueueRawData(ByteSpan span, IPEndPoint remoteEndPoint)
         {
             PeerData peer;
             if (!this.existingPeers.TryGetValue(remoteEndPoint, out peer))
diff --git a/Hazel/FewerThreads/ThreadLimitedUdpConnectionListener.cs b/Hazel/FewerThreads/ThreadLimitedUdpConnectionListener.cs
index fa7879d..339cb5b 100644
--- a/Hazel/FewerThreads/ThreadLimitedUdpConnectionListener.cs
+++ b/Hazel/FewerThreads/ThreadLimitedUdpConnectionListener.cs
@@ -16,13 +16,13 @@ namespace Hazel.Udp.FewerThreads
         private struct SendMessageInfo
         {
             public ByteSpan Span;
-            public EndPoint Recipient;
+            public IPEndPoint Recipient;
         }
 
         private struct ReceiveMessageInfo
         {
             public MessageReader Message;
-            public EndPoint Sender;
+            public IPEndPoint Sender;
             public ConnectionId ConnectionId;
         }
 
@@ -236,7 +236,7 @@ namespace Hazel.Udp.FewerThreads
                     }
 
                     ConnectionId connectionId = ConnectionId.CreateFromEndPoint((IPEndPoint)remoteEP);
-                    this.ProcessIncomingMessageFromOtherThread(message, remoteEP, connectionId);
+                    this.ProcessIncomingMessageFromOtherThread(message, (IPEndPoint)remoteEP, connectionId);
                 }
             }
         }
@@ -254,7 +254,7 @@ namespace Hazel.Udp.FewerThreads
                 }
             }
         }
-        protected virtual void ProcessIncomingMessageFromOtherThread(MessageReader message, EndPoint remoteEndPoint, ConnectionId connectionId)
+        protected virtual void ProcessIncomingMessageFromOtherThread(MessageReader message, IPEndPoint remoteEndPoint, ConnectionId connectionId)
         {
             this.receiveQueue.Add(new ReceiveMessageInfo() { Message = message, Sender = remoteEndPoint, ConnectionId = connectionId });
         }
@@ -278,7 +278,7 @@ namespace Hazel.Udp.FewerThreads
             }
         }
 
-        void ReadCallback(MessageReader message, EndPoint remoteEndPoint, ConnectionId connectionId)
+        void ReadCallback(MessageReader message, IPEndPoint remoteEndPoint, ConnectionId connectionId)
         {
             int bytesReceived = message.Length;
             bool aware = true;
@@ -345,12 +345,12 @@ namespace Hazel.Udp.FewerThreads
             }
         }
 
-        internal void SendDataRaw(byte[] response, EndPoint remoteEndPoint)
+        internal void SendDataRaw(byte[] response, IPEndPoint remoteEndPoint)
         {
             QueueRawData(response, remoteEndPoint);
         }
 
-        protected virtual void QueueRawData(ByteSpan span, EndPoint remoteEndPoint)
+        protected virtual void QueueRawData(ByteSpan span, IPEndPoint remoteEndPoint)
         {
             this.sendQueue.TryAdd(new SendMessageInfo() { Span = span, Recipient = remoteEndPoint });
         }
diff --git a/Hazel/FewerThreads/ThreadLimitedUdpServerConnection.cs b/Hazel/FewerThreads/ThreadLimitedUdpServerConnection.cs
index 31c9ca2..149ab9e 100644
--- a/Hazel/FewerThreads/ThreadLimitedUdpServerConnection.cs
+++ b/Hazel/FewerThreads/ThreadLimitedUdpServerConnection.cs
@@ -46,7 +46,7 @@ namespace Hazel.Udp.FewerThreads
         {
             if (bytes.Length != length) throw new ArgumentException("I made an assumption here. I hope you see this error.");
 
-            Listener.SendDataRaw(bytes, RemoteEndPoint);
+            Listener.SendDataRaw(bytes, EndPoint);
         }
 
         /// <inheritdoc />
@@ -86,7 +86,7 @@ namespace Hazel.Udp.FewerThreads
 
             try
             {
-                Listener.SendDataRaw(bytes, RemoteEndPoint);
+                Listener.SendDataRaw(bytes, EndPoint);
             }
             catch { }