Udp support

neo.UnitTests/UT_P2PMessage.cs

@@ -3,7 +3,9 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.IO;
 using Neo.Network.P2P;
+using Neo.Network.P2P.Capabilities;
 using Neo.Network.P2P.Payloads;
+using System.Collections.Generic;
 
 namespace Neo.UnitTests
 {
@@ -81,12 +83,17 @@ public void Compression()
             {
                 UserAgent = "".PadLeft(1024, '0'),
                 Nonce = 1,
-                Port = 2,
+                Magic = 2,
                 Services = VersionServices.FullNode,
                 StartHeight = 4,
                 Timestamp = 5,
-                Version = 6
+                Version = 6,
+                Capabilities = new Dictionary<NodeCapabilities, INodeCapability>()
             };
+
+            payload.Capabilities.Add(NodeCapabilities.TcpPort, new UInt16Capability() { Value = 25 });
+            payload.Capabilities.Add(NodeCapabilities.RpcServerAddress, new StringCapability() { Value = "".PadLeft(32, 'Z') });
+
             var msg = Message.Create(MessageCommand.Version, payload);
             var buffer = msg.ToArray();
 
@@ -100,11 +107,16 @@ public void Compression()
 
             payloadCopy.UserAgent.Should().Be(payload.UserAgent);
             payloadCopy.Nonce.Should().Be(payload.Nonce);
-            payloadCopy.Port.Should().Be(payload.Port);
+            payloadCopy.Magic.Should().Be(payload.Magic);
             payloadCopy.Services.Should().Be(payload.Services);
             payloadCopy.StartHeight.Should().Be(payload.StartHeight);
             payloadCopy.Timestamp.Should().Be(payload.Timestamp);
             payloadCopy.Version.Should().Be(payload.Version);
+
+            payloadCopy.Capabilities.Count.Should().Be(2);
+            ((UInt16Capability)payloadCopy.Capabilities[NodeCapabilities.TcpPort]).Value.Should().Be(25);
+            ((StringCapability)payloadCopy.Capabilities[NodeCapabilities.RpcServerAddress]).Value.Should().Be("".PadLeft(32, 'Z'));
+
         }
     }
 }

neo/EndPointConfig.cs

@@ -0,0 +1,27 @@
+using System.Net;
+
+namespace Neo
+{
+    public class EndPointConfig
+    {
+        /// <summary>
+        /// Address
+        /// </summary>
+        public string Address { get; set; } = "0.0.0.0";
+
+        /// <summary>
+        /// Port
+        /// </summary>
+        public ushort Port { get; set; } = 0;
+
+        /// <summary>
+        /// Ip EndPoint
+        /// </summary>
+        public IPEndPoint EndPoint => new IPEndPoint(IPAddress.Parse(Address), Port);
+
+        /// <summary>
+        /// Return true if the address and port are valid
+        /// </summary>
+        public bool IsValid => IPAddress.TryParse(Address, out var addr) && Port > 0;
+    }
+}

neo/NeoSystem.cs

@@ -28,7 +28,7 @@ public class NeoSystem : IDisposable
         public RpcServer RpcServer { get; private set; }
 
         private readonly Store store;
-        private Peer.Start start_message = null;
+        private NodeStartConfig start_message = null;
         private bool suspend = false;
 
         public NeoSystem(Store store)
@@ -74,17 +74,10 @@ public void StartConsensus(Wallet wallet, Store consensus_store = null, bool ign
             Consensus.Tell(new ConsensusService.Start { IgnoreRecoveryLogs = ignoreRecoveryLogs }, Blockchain);
         }
 
-        public void StartNode(int port = 0, int wsPort = 0, int minDesiredConnections = Peer.DefaultMinDesiredConnections,
-            int maxConnections = Peer.DefaultMaxConnections, int maxConnectionsPerAddress = 3)
+        public void StartNode(NodeStartConfig cfg)
         {
-            start_message = new Peer.Start
-            {
-                Port = port,
-                WsPort = wsPort,
-                MinDesiredConnections = minDesiredConnections,
-                MaxConnections = maxConnections,
-                MaxConnectionsPerAddress = maxConnectionsPerAddress
-            };
+            start_message = cfg;
+
             if (!suspend)
             {
                 LocalNode.Tell(start_message);

neo/Network/P2P/Capabilities/INodeCapability.cs

@@ -0,0 +1,6 @@
+using Neo.IO;
+
+namespace Neo.Network.P2P.Capabilities
+{
+    public interface INodeCapability : ISerializable { }
+}

neo/Network/P2P/Capabilities/NodeCapabilities.cs

@@ -0,0 +1,19 @@
+using Neo.IO.Caching;
+
+namespace Neo.Network.P2P.Capabilities
+{
+    public enum NodeCapabilities : byte
+    {
+        [ReflectionCache(typeof(UInt16Capability))]
+        TcpPort = 0x00,
+
+        [ReflectionCache(typeof(UInt16Capability))]
+        UdpPort = 0x01,
+
+        [ReflectionCache(typeof(UInt16Capability))]
+        WebsocketPort = 0x02,
+
+        [ReflectionCache(typeof(StringCapability))]
+        RpcServerAddress = 0x03
+    }
+}

neo/Network/P2P/Capabilities/StringCapability.cs

@@ -0,0 +1,38 @@
+using Neo.IO;
+using System.IO;
+
+namespace Neo.Network.P2P.Capabilities
+{
+    public class StringCapability : INodeCapability
+    {
+        const int MaxStringCapability = byte.MaxValue;
+
+        public string Value { get; set; }
+
+        public int Size => Value.GetVarSize();
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public StringCapability() { }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="value">Value</param>
+        public StringCapability(string value)
+        {
+            Value = value
+        }
+
+        public void Deserialize(BinaryReader reader)
+        {
+            Value = reader.ReadVarString(MaxStringCapability);
+        }
+
+        public void Serialize(BinaryWriter writer)
+        {
+            writer.WriteVarString(Value);
+        }
+    }
+}

neo/Network/P2P/Capabilities/UInt16Capability.cs

@@ -0,0 +1,35 @@
+using System.IO;
+
+namespace Neo.Network.P2P.Capabilities
+{
+    public class UInt16Capability : INodeCapability
+    {
+        public ushort Value { get; set; }
+
+        public int Size => sizeof(ushort);
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public UInt16Capability() { }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="value">Value</param>
+        public UInt16Capability(ushort value)
+        {
+            Value = value;
+        }
+
+        public void Deserialize(BinaryReader reader)
+        {
+            Value = reader.ReadUInt16();
+        }
+
+        public void Serialize(BinaryWriter writer)
+        {
+            writer.Write(Value);
+        }
+    }
+}

neo/Network/P2P/Connection.cs

@@ -14,7 +14,7 @@ public abstract class Connection : UntypedActor
 
         public IPEndPoint Remote { get; }
         public IPEndPoint Local { get; }
-        public abstract int ListenerPort { get; }
+        public abstract int ListenerTcpPort { get; }
 
         private ICancelable timer;
         private readonly IActorRef tcp;

neo/Network/P2P/LocalNode.cs

@@ -1,4 +1,5 @@
 using Akka.Actor;
+using Akka.IO;
 using Neo.IO;
 using Neo.Ledger;
 using Neo.Network.P2P.Payloads;
@@ -30,13 +31,13 @@ internal class SendDirectly { public IInventory Inventory; }
         public static readonly uint Nonce;
         public static string UserAgent { get; set; }
 
-        private static LocalNode singleton { get; set; }
+        private static LocalNode _singleton;
         public static LocalNode Singleton
         {
             get
             {
-                while (singleton == null) Thread.Sleep(10);
-                return singleton;
+                while (_singleton == null) Thread.Sleep(10);
+                return _singleton;
             }
         }
 
@@ -51,10 +52,10 @@ public LocalNode(NeoSystem system)
         {
             lock (lockObj)
             {
-                if (singleton != null)
+                if (_singleton != null)
                     throw new InvalidOperationException();
                 this.system = system;
-                singleton = this;
+                _singleton = this;
             }
         }
 
@@ -75,7 +76,7 @@ private static IPEndPoint GetIPEndpointFromHostPort(string hostNameOrAddress, in
             IPHostEntry entry;
             try
             {
-                entry = Dns.GetHostEntry(hostNameOrAddress);
+                entry = System.Net.Dns.GetHostEntry(hostNameOrAddress);
             }
             catch (SocketException)
             {
@@ -156,6 +157,49 @@ protected override void OnReceive(object message)
             }
         }
 
+        protected override void OnUdpMessage(IPEndPoint remote, ByteString data)
+        {
+            if (Message.TryDeserialize(data, out var msg) != data.Count) return;
+
+            switch (msg.Command)
+            {
+                case MessageCommand.Transaction:
+                    {
+                        if (msg.Payload.Size <= Transaction.MaxTransactionSize)
+                            system.LocalNode.Tell(new Relay { Inventory = (Transaction)msg.Payload });
+
+                        break;
+                    }
+                case MessageCommand.Ping:
+                    {
+                        var payload = (PingPayload)msg.Payload;
+                        msg = Message.Create(MessageCommand.Pong, PingPayload.Create(Blockchain.Singleton.Height, payload.Nonce));
+                        SendUdp(remote, ByteString.FromBytes(msg.ToArray()));
+                        break;
+                    }
+                case MessageCommand.GetAddr:
+                    {
+                        NetworkAddressWithTime[] networkAddresses = GetPeers();
+                        if (networkAddresses.Length == 0) return;
+                        msg = Message.Create(MessageCommand.Addr, AddrPayload.Create(networkAddresses));
+                        SendUdp(remote, ByteString.FromBytes(msg.ToArray()));
+                        break;
+                    }
+            }
+        }
+
+        public NetworkAddressWithTime[] GetPeers()
+        {
+            Random rand = new Random();
+            IEnumerable<RemoteNode> peers = RemoteNodes.Values
+                .Where(p => p.ListenerTcpPort > 0)
+                .GroupBy(p => p.Remote.Address, (k, g) => g.First())
+                .OrderBy(p => rand.Next())
+                .Take(AddrPayload.MaxCountToSend);
+
+            return peers.Select(p => NetworkAddressWithTime.Create(p.Listener, p.Version.Services, p.Version.Timestamp)).ToArray();
+        }
+
         private void OnRelay(IInventory inventory)
         {
             if (inventory is Transaction transaction)