Initial commit

HyperbolicDowloader/Networking/BroadcastClient.cs

@@ -0,0 +1,75 @@
+using Stone_Red_Utilities.ConsoleExtentions;
+
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using System.Text;
+
+namespace HyperbolicDowloader.Networking;
+
+internal class BroadcastClient
+{
+    public event EventHandler<BroadcastRecivedEventArgs>? OnBroadcastRecived;
+
+    public bool IsListening { get; private set; } = false;
+
+    private UdpClient? udpListener;
+
+    public void Send(int port, string message)
+    {
+        Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+
+        IPAddress? ip4Address = NetworkUtilities.GetIP4Adress();
+
+        if (ip4Address is null)
+        {
+            ConsoleExt.WriteLine("Could not find suitable network adapter!", ConsoleColor.Red);
+            return;
+        }
+
+        UnicastIPAddressInformation? addressInformation = NetworkUtilities.GetUnicastIPAddressInformation(ip4Address);
+
+        if (addressInformation is null)
+        {
+            ConsoleExt.WriteLine("Could not find suitable network adapter!", ConsoleColor.Red);
+            return;
+        }
+
+        IPAddress broadcast = NetworkUtilities.GetBroadcastAddress(addressInformation);
+
+        byte[] sendbuf = Encoding.ASCII.GetBytes(message);
+        IPEndPoint ep = new IPEndPoint(broadcast, port);
+
+        s.SendTo(sendbuf, ep);
+    }
+
+    public void StartListening(int port)
+    {
+        if (IsListening == true)
+        {
+            throw new InvalidOperationException("Already listening!");
+        }
+
+        IsListening = true;
+
+        udpListener = new UdpClient(port);
+        IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, port);
+
+        Task.Run(() =>
+        {
+            while (IsListening)
+            {
+                byte[] bytes = udpListener.Receive(ref groupEP);
+                string message = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
+
+                OnBroadcastRecived?.Invoke(this, new BroadcastRecivedEventArgs(groupEP, message));
+            }
+        });
+    }
+
+    public void StopListening()
+    {
+        udpListener?.Close();
+        IsListening = false;
+    }
+}

HyperbolicDowloader/Networking/BroadcastRecivedEventArgs.cs

@@ -0,0 +1,15 @@
+using System.Net;
+
+namespace HyperbolicDowloader.Networking;
+
+internal class BroadcastRecivedEventArgs : EventArgs
+{
+    public BroadcastRecivedEventArgs(IPEndPoint iPEndPoint, string message)
+    {
+        IPEndPoint = iPEndPoint;
+        Message = message;
+    }
+
+    public IPEndPoint IPEndPoint { get; }
+    public string Message { get; }
+}

HyperbolicDowloader/Networking/DataContainer.cs

@@ -0,0 +1,14 @@
+namespace HyperbolicDowloader
+{
+    internal class DataContainer
+    {
+        public string EventName { get; set; }
+        public string JsonData { get; set; }
+
+        public DataContainer(string eventName, string jsonData)
+        {
+            JsonData = jsonData;
+            EventName = eventName;
+        }
+    }
+}

HyperbolicDowloader/Networking/HostsManager.cs

@@ -0,0 +1,90 @@
+using HyperbolicDowloader.Networking;
+
+using Stone_Red_Utilities.ConsoleExtentions;
+
+using System.Net.Sockets;
+using System.Text.Json;
+
+namespace HyperbolicDowloader;
+
+internal class HostsManager
+{
+    private readonly List<NetworkSocket> hosts = new List<NetworkSocket>();
+    public int Count => hosts.Count;
+
+    public void AddRange(IEnumerable<NetworkSocket> hosts)
+    {
+        foreach (NetworkSocket host in hosts)
+        {
+            if (!this.hosts.Any(x => x.IPAddress == host.IPAddress && x.Port == host.Port))
+            {
+                this.hosts.Add(host);
+            }
+        }
+
+        SaveHosts();
+    }
+
+    public void Add(NetworkSocket host)
+    {
+        if (!hosts.Any(x => x.IPAddress == host.IPAddress && x.Port == host.Port))
+        {
+            hosts.Add(host);
+        }
+        SaveHosts();
+    }
+
+    public void Remove(NetworkSocket host)
+    {
+        hosts.RemoveAll(x => x.IPAddress == host.IPAddress && x.Port == host.Port);
+        SaveHosts();
+    }
+
+    public void RemoveInactiveHosts()
+    {
+        List<NetworkSocket> hostsToRemove = new List<NetworkSocket>();
+        foreach (NetworkSocket host in hosts)
+        {
+            ConsoleExt.Write($"{host.IPAddress}:{host.Port} > ???", ConsoleColor.DarkYellow);
+            using TcpClient tcpClient = new TcpClient();
+
+            try
+            {
+                tcpClient.ConnectAsync(host.IPAddress, host.Port).Wait(1000);
+                Console.CursorLeft = 0;
+                if (tcpClient.Connected)
+                {
+                    ConsoleExt.WriteLine($"{host.IPAddress}:{host.Port} > Active", ConsoleColor.Green);
+                }
+                else
+                {
+                    hostsToRemove.Add(host);
+                    ConsoleExt.WriteLine($"{host.IPAddress}:{host.Port} > Inactive", ConsoleColor.Red);
+                }
+            }
+            catch
+            {
+                hostsToRemove.Add(host);
+                Console.CursorLeft = 0;
+                ConsoleExt.WriteLine($"{host.IPAddress}:{host.Port} > Inactive", ConsoleColor.Red);
+            }
+        }
+
+        foreach (NetworkSocket host in hostsToRemove)
+        {
+            hosts.Remove(host);
+        }
+
+        SaveHosts();
+    }
+
+    public List<NetworkSocket> ToList()
+    {
+        return hosts.ToList();
+    }
+
+    private void SaveHosts()
+    {
+        File.WriteAllText(Program.HostsFilePath, JsonSerializer.Serialize(hosts));
+    }
+}

HyperbolicDowloader/Networking/MessageRecivedEventArgs.cs

@@ -0,0 +1,34 @@
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Text.Json;
+
+namespace HyperbolicDowloader
+{
+    internal class MessageRecivedEventArgs<T> : EventArgs
+    {
+        private readonly NetworkStream networkStream;
+
+        public MessageRecivedEventArgs(NetworkStream networkStream, IPAddress ipAddress, T data)
+        {
+            this.networkStream = networkStream;
+            Data = data;
+            IpAddress = ipAddress;
+        }
+
+        public T Data { get; set; }
+
+        public IPAddress IpAddress { get; set; }
+
+        public async Task SendResponseAsync(object response)
+        {
+            byte[] bytesToSend = Encoding.ASCII.GetBytes(JsonSerializer.Serialize(response));
+            await networkStream.WriteAsync(bytesToSend);
+        }
+
+        public void SendResponse(object response)
+        {
+            SendResponseAsync(response).GetAwaiter().GetResult();
+        }
+    }
+}

HyperbolicDowloader/Networking/NetworkClient.cs

@@ -0,0 +1,155 @@
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Text.Json;
+
+namespace HyperbolicDowloader
+{
+    internal class NetworkClient
+    {
+        public bool IsListening { get; private set; } = false;
+
+        private TcpListener? tcpListener;
+        private readonly Dictionary<string, (Type type, Delegate method)> events = new();
+
+        public NetworkClient()
+        {
+        }
+
+        public static async Task<T?> SendAsync<T>(IPAddress remoteIp, int remotePort, string eventName, object data)
+        {
+            if (remoteIp is null)
+            {
+                throw new ArgumentNullException(nameof(remoteIp));
+            }
+
+            TcpClient client = new TcpClient();
+
+            await client.ConnectAsync(remoteIp, remotePort);
+
+            NetworkStream nwStream = client.GetStream();
+
+            string stringData = JsonSerializer.Serialize(new DataContainer(eventName, JsonSerializer.Serialize(data)));
+            byte[] bytesToSend = Encoding.ASCII.GetBytes(stringData);
+
+            await nwStream.WriteAsync(bytesToSend);
+
+            byte[] bytesToRead = new byte[client.ReceiveBufferSize];
+            int bytesRead = await nwStream.ReadAsync(bytesToRead.AsMemory(0, client.ReceiveBufferSize));
+            string response = Encoding.ASCII.GetString(bytesToRead, 0, bytesRead);
+
+            client.Close();
+
+            if (string.IsNullOrWhiteSpace(response))
+            {
+                return default;
+            }
+            else
+            {
+                return JsonSerializer.Deserialize<T>(response);
+            }
+        }
+
+        public static async Task SendAsync(IPAddress remoteIp, int remotePort, string eventName, object data)
+        {
+            if (remoteIp is null)
+            {
+                throw new ArgumentNullException(nameof(remoteIp));
+            }
+
+            TcpClient client = new TcpClient();
+
+            await client.ConnectAsync(remoteIp, remotePort);
+
+            NetworkStream nwStream = client.GetStream();
+
+            string stringData = JsonSerializer.Serialize(new DataContainer(eventName, JsonSerializer.Serialize(data)));
+            byte[] bytesToSend = Encoding.ASCII.GetBytes(stringData);
+
+            await nwStream.WriteAsync(bytesToSend);
+
+            client.Close();
+        }
+
+        public static T? Send<T>(IPAddress remoteIp, int remotePort, string eventName, object data)
+        {
+            return SendAsync<T>(remoteIp, remotePort, eventName, data).GetAwaiter().GetResult();
+        }
+
+        public static void Send(IPAddress remoteIp, int remotePort, string eventName, object data)
+        {
+            SendAsync(remoteIp, remotePort, eventName, data).GetAwaiter().GetResult();
+        }
+
+        public void StartListening(int port)
+        {
+            if (IsListening == true)
+            {
+                throw new InvalidOperationException("Already listening!");
+            }
+
+            tcpListener = new TcpListener(IPAddress.Any, port);
+
+            tcpListener.Start();
+            IsListening = true;
+
+            Task.Run(() =>
+            {
+                while (IsListening)
+                {
+                    try
+                    {
+                        using TcpClient client = tcpListener.AcceptTcpClient();
+                        NetworkStream nwStream = client.GetStream();
+                        byte[] buffer = new byte[client.ReceiveBufferSize];
+
+                        int bytesRead = nwStream.Read(buffer, 0, client.ReceiveBufferSize);
+
+                        string dataReceived = Encoding.ASCII.GetString(buffer, 0, bytesRead);
+
+                        if (string.IsNullOrWhiteSpace(dataReceived))
+                        {
+                            continue;
+                        }
+
+                        DataContainer? dataContainer = JsonSerializer.Deserialize<DataContainer>(dataReceived);
+
+                        if (dataContainer is not null && events.ContainsKey(dataContainer.EventName))
+                        {
+                            (Type type, Delegate method) = events[dataContainer.EventName];
+
+                            Type eventArgsType = typeof(MessageRecivedEventArgs<>).MakeGenericType(type);
+
+                            object? eventArgs = Activator.CreateInstance(
+                                eventArgsType,
+                                nwStream,
+                                (client.Client.RemoteEndPoint as IPEndPoint)?.Address,
+                                JsonSerializer.Deserialize(dataContainer.JsonData, type));
+
+                            method?.DynamicInvoke(this, eventArgs);
+                        }
+                    }
+                    catch (SocketException ex)
+                    {
+                        if (ex.SocketErrorCode != SocketError.Interrupted)
+                        {
+                            throw ex;
+                        }
+                    }
+                }
+                tcpListener.Stop();
+            });
+        }
+
+        public void StopListening()
+        {
+            tcpListener?.Stop();
+            IsListening = false;
+        }
+
+        public void ListenTo<T>(string eventName, EventHandler<MessageRecivedEventArgs<T>> eventHandler)
+        {
+            events.Add(eventName, (typeof(T), eventHandler));
+        }
+    }
+}

HyperbolicDowloader/Networking/NetworkSocket.cs

@@ -0,0 +1,13 @@
+namespace HyperbolicDowloader.Networking;
+
+internal class NetworkSocket
+{
+    public NetworkSocket(string ipAddress, int port)
+    {
+        IPAddress = ipAddress;
+        Port = port;
+    }
+
+    public string IPAddress { get; set; }
+    public int Port { get; set; }
+}

HyperbolicDowloader/Networking/NetworkUtilities.cs

@@ -0,0 +1,49 @@
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+
+namespace HyperbolicDowloader.Networking;
+
+internal class NetworkUtilities
+{
+    public static UnicastIPAddressInformation? GetUnicastIPAddressInformation(IPAddress address)
+    {
+        foreach (NetworkInterface adapter in NetworkInterface.GetAllNetworkInterfaces())
+        {
+            foreach (UnicastIPAddressInformation unicastIPAddressInformation in adapter.GetIPProperties().UnicastAddresses)
+            {
+                if (unicastIPAddressInformation.Address.AddressFamily == AddressFamily.InterNetwork)
+                {
+                    if (address.Equals(unicastIPAddressInformation.Address))
+                    {
+                        return unicastIPAddressInformation;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    public static IPAddress? GetIP4Adress()
+    {
+        using Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, 0);
+        socket.Connect("8.8.8.8", 65530);
+        IPEndPoint? endPoint = socket.LocalEndPoint as IPEndPoint;
+
+        return endPoint?.Address;
+    }
+
+    public static IPAddress GetBroadcastAddress(UnicastIPAddressInformation unicastAddress)
+    {
+        return GetBroadcastAddress(unicastAddress.Address, unicastAddress.IPv4Mask);
+    }
+
+    public static IPAddress GetBroadcastAddress(IPAddress address, IPAddress mask)
+    {
+        uint ipAddress = BitConverter.ToUInt32(address.GetAddressBytes(), 0);
+        uint ipMaskV4 = BitConverter.ToUInt32(mask.GetAddressBytes(), 0);
+        uint broadCastIpAddress = ipAddress | ~ipMaskV4;
+
+        return new IPAddress(BitConverter.GetBytes(broadCastIpAddress));
+    }
+}