Initial commit

2026-09-06 15:56:22 +02:00 · 2022-01-25 22:20:53 +01:00
commit ec6778b2be
16 changed files with 1150 additions and 0 deletions
@@ -0,0 +1,22 @@
+using System.IO.Compression;
+
+namespace HyperbolicDowloader.FileProcessing;
+
+internal class FileCompressor
+{
+    private static void CompressFile(string inputFilePath, string compressedFilePath)
+    {
+        using FileStream originalFileStream = File.Open(inputFilePath, FileMode.Open);
+        using FileStream compressedFileStream = File.Create(compressedFilePath);
+        using GZipStream? compressor = new GZipStream(compressedFileStream, CompressionMode.Compress);
+        originalFileStream.CopyTo(compressor);
+    }
+
+    private static void DecompressFile(string compressedFilePath, string outputFilePath)
+    {
+        using FileStream compressedFileStream = File.Open(compressedFilePath, FileMode.Open);
+        using FileStream outputFileStream = File.Create(outputFilePath);
+        using GZipStream? decompressor = new GZipStream(compressedFileStream, CompressionMode.Decompress);
+        decompressor.CopyTo(outputFileStream);
+    }
+}
@@ -0,0 +1,19 @@
+using System.Security.Cryptography;
+
+namespace HyperbolicDowloader.FileProcessing;
+
+internal class FileValidator
+{
+    public static async Task<string> CalculateHashAsync(string filePath)
+    {
+        using SHA512 sha = SHA512.Create();
+        using FileStream? stream = File.OpenRead(filePath);
+        byte[]? hash = await sha.ComputeHashAsync(stream);
+        return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
+    }
+
+    public static async Task<bool> ValidateHashAsync(string filePath, string hash)
+    {
+        return await CalculateHashAsync(filePath) == hash;
+    }
+}
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Open.NAT" Version="2.1.0" />
+    <PackageReference Include="Stone_Red-C-Sharp-Utilities" Version="1.0.3.1" />
+  </ItemGroup>
+
+</Project>
@@ -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;
+    }
+}
@@ -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; }
+}
@@ -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;
+        }
+    }
+}
@@ -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));
+    }
+}
@@ -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();
+        }
+    }
+}
@@ -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));
+        }
+    }
+}
@@ -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; }
+}
@@ -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));
+    }
+}
@@ -0,0 +1,230 @@
+
+using HyperbolicDowloader.Networking;
+
+using Open.Nat;
+
+using Stone_Red_Utilities.ConsoleExtentions;
+
+using System.Diagnostics;
+using System.Net;
+using System.Net.Sockets;
+using System.Text.Json;
+
+namespace HyperbolicDowloader;
+
+internal class Program
+{
+    private const int BroadcastPort = 2155;
+
+    public const string HostsFilePath = "Hosts.json";
+
+    private static int publicPort;
+    private static readonly int privatePort = 3055;
+    private static NatDevice? device;
+    private static Mapping? portMapping;
+    private static readonly HostsManager hosts = new();
+    private static readonly NetworkClient networkClient = new();
+    private static readonly Random random = new Random();
+
+    private static async Task Main()
+    {
+        Console.CancelKeyPress += Console_CancelKeyPress;
+
+        if (File.Exists(HostsFilePath))
+        {
+            string hostsJson = await File.ReadAllTextAsync(HostsFilePath);
+            hosts.AddRange(JsonSerializer.Deserialize<List<NetworkSocket>>(hostsJson) ?? new());
+        }
+
+        Console.WriteLine("Searching for a UPnP/NAT-PMP device...");
+        _ = await OpenPorts();
+
+        ConsoleExt.WriteLine($"The private IP Address is: {NetworkUtilities.GetIP4Adress()} ", ConsoleColor.Green);
+        ConsoleExt.WriteLine($"The private port is: {privatePort}", ConsoleColor.Green);
+
+        Console.WriteLine("Starting TCP listener...");
+
+        try
+        {
+            networkClient.ListenTo<NetworkSocket>("GetHostsList", GetHostList);
+            networkClient.ListenTo<List<NetworkSocket>>("DiscoverAnswer", DiscoverAnswer);
+            networkClient.StartListening(privatePort);
+        }
+        catch (SocketException ex)
+        {
+            Console.WriteLine($"An error occurred while starting the TCP listener! Error message: {ex.Message}");
+            return;
+        }
+
+        BroadcastClient broadcastClient = new BroadcastClient();
+
+        Console.WriteLine("Running local discovery routine...");
+        broadcastClient.Send(BroadcastPort, privatePort.ToString());
+        await Task.Delay(5000);
+
+        if (hosts.Count > 0)
+        {
+            Console.WriteLine("Checking if hosts are active...");
+            hosts.RemoveInactiveHosts();
+        }
+
+        if (hosts.Count == 0)
+        {
+            hosts.AddRange(await Setup.ConfigureHost());
+            Console.WriteLine("Checking if hosts are active...");
+            hosts.RemoveInactiveHosts();
+        }
+
+        Console.WriteLine($"{hosts.Count} active host(s).");
+        Console.WriteLine("Starting broadcast listener...");
+        broadcastClient.StartListening(BroadcastPort);
+        broadcastClient.OnBroadcastRecived += BroadcastClient_OnBroadcastRecived;
+        ConsoleExt.WriteLine("Done", ConsoleColor.Green);
+        await Task.Delay(-1);
+    }
+
+    private static async void BroadcastClient_OnBroadcastRecived(object? sender, BroadcastRecivedEventArgs recivedEventArgs)
+    {
+        Debug.WriteLine($"Received broadcast \"{recivedEventArgs.Message}\" from {recivedEventArgs.IPEndPoint.Address}");
+        List<NetworkSocket> hostsToSend = hosts.ToList();
+
+        NetworkSocket? localSocket = GetLocalSocket();
+
+        if (localSocket is null)
+        {
+            return;
+        }
+
+        hostsToSend.RemoveAll(x => x.IPAddress == recivedEventArgs.IPEndPoint.Address.ToString());
+        hostsToSend.Add(localSocket);
+
+        bool success = int.TryParse(recivedEventArgs.Message, out int remotePort);
+
+        if (success)
+        {
+            hosts.Add(new NetworkSocket(recivedEventArgs.IPEndPoint.Address.ToString(), remotePort));
+            try
+            {
+                await NetworkClient.SendAsync(recivedEventArgs.IPEndPoint.Address, remotePort, "DiscoverAnswer", hostsToSend);
+            }
+            catch (SocketException ex)
+            {
+                Debug.WriteLine(ex);
+            }
+        }
+    }
+
+    private static void DiscoverAnswer(object? sender, MessageRecivedEventArgs<List<NetworkSocket>> recivedEventArgs)
+    {
+        Console.WriteLine($"Received answer from {recivedEventArgs.IpAddress}. Returned {recivedEventArgs.Data.Count} host(s).");
+        hosts.AddRange(recivedEventArgs.Data);
+    }
+
+    private static async void GetHostList(object? sender, MessageRecivedEventArgs<NetworkSocket> recivedEventArgs)
+    {
+        List<NetworkSocket> hostsToSend = hosts.ToList();
+
+        NetworkSocket? localSocket = GetLocalSocket();
+
+        if (localSocket is null)
+        {
+            return;
+        }
+
+        hostsToSend.RemoveAll(x => x.IPAddress == recivedEventArgs.IpAddress.ToString());
+        hostsToSend.Add(localSocket);
+
+        if (recivedEventArgs.Data.Port != 0)
+        {
+            hosts.Add(recivedEventArgs.Data);
+        }
+
+        await recivedEventArgs.SendResponseAsync(hostsToSend);
+    }
+
+    public static async Task<bool> OpenPorts()
+    {
+        try
+        {
+            publicPort = random.Next(1000, 6000);
+
+            NatDiscoverer? discoverer = new NatDiscoverer();
+            device = await discoverer.DiscoverDeviceAsync();
+
+            IPAddress? ip = await device.GetExternalIPAsync();
+            ConsoleExt.WriteLine($"The public IP Address is: {ip} ", ConsoleColor.Green);
+
+            portMapping = new Mapping(Protocol.Tcp, privatePort, publicPort, "HyperbolicDowloader");
+
+            await device.CreatePortMapAsync(portMapping);
+
+            ConsoleExt.WriteLine($"The public port is: {publicPort}", ConsoleColor.Green);
+            return true;
+        }
+        catch (NatDeviceNotFoundException)
+        {
+            ConsoleExt.WriteLine($"Could not find a UPnP or NAT-PMP device!", ConsoleColor.Red);
+            return false;
+        }
+        catch (MappingException ex)
+        {
+            ConsoleExt.WriteLine($"An error occurred while mapping the private port ({privatePort}) to the public port ({publicPort})! Error message: {ex.Message}", ConsoleColor.Red);
+            return false;
+        }
+    }
+
+    private static void ClosePorts()
+    {
+        Console.WriteLine("Closing ports...");
+        if (device is not null)
+        {
+            try
+            {
+                IEnumerable<Mapping>? mappings = device.GetAllMappingsAsync().GetAwaiter().GetResult();
+                foreach (Mapping? mapping in mappings)
+                {
+                    if (mapping.Description.Contains("HyperbolicDowloader") && mapping.PrivateIP.ToString() == portMapping?.PrivateIP.ToString())
+                    {
+                        device.DeletePortMapAsync(mapping).GetAwaiter().GetResult();
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex);
+            }
+        }
+
+        ConsoleExt.WriteLine("Ports closed!", ConsoleColor.DarkYellow);
+        Environment.Exit(0);
+    }
+
+    private static void Console_CancelKeyPress(object? sender, ConsoleCancelEventArgs e)
+    {
+        ClosePorts();
+    }
+
+    public static NetworkSocket? GetLocalSocket()
+    {
+        int port = publicPort;
+        string? ipAddress = null;
+
+        if (device is not null)
+        {
+            ipAddress = (device.GetExternalIPAsync()).GetAwaiter().GetResult()?.ToString();
+        }
+
+        if (ipAddress is null || ipAddress == "0.0.0.0")
+        {
+            ipAddress = NetworkUtilities.GetIP4Adress()?.ToString();
+            port = privatePort;
+        }
+
+        if (ipAddress is null)
+        {
+            return null;
+        }
+
+        return new NetworkSocket(ipAddress, port);
+    }
+}
@@ -0,0 +1,58 @@
+using HyperbolicDowloader.Networking;
+
+using Stone_Red_Utilities.ConsoleExtentions;
+
+using System.Net;
+using System.Net.Sockets;
+
+namespace HyperbolicDowloader;
+
+internal static class Setup
+{
+    public static async Task<List<NetworkSocket>> ConfigureHost()
+    {
+        ConsoleExt.WriteLine("No active hosts found!", ConsoleColor.Red);
+        do
+        {
+            Console.WriteLine();
+            Console.Write("Please enter an IP address manually: ");
+            string? ipAddressInput = Console.ReadLine();
+
+            Console.Write("Please enter an port number manually: ");
+            string? portInput = Console.ReadLine();
+
+            _ = int.TryParse(portInput, out int port);
+            if (port < 1000 || port >= 6000)
+            {
+                ConsoleExt.WriteLine("Invalid port number!", ConsoleColor.Red);
+            }
+            else if (IPAddress.TryParse(ipAddressInput, out IPAddress? ipAddress))
+            {
+                try
+                {
+                    Console.WriteLine("Waiting for response...");
+                    NetworkSocket? localSocket = Program.GetLocalSocket() ?? new NetworkSocket("0.0.0.0", 0);
+                    List<NetworkSocket>? recivedHosts = await NetworkClient.SendAsync<List<NetworkSocket>>(ipAddress, port, "GetHostsList", localSocket);
+
+                    if (recivedHosts is not null)
+                    {
+                        ConsoleExt.WriteLine($"Success! Added {recivedHosts.Count} new host(s).", ConsoleColor.Green);
+                        return recivedHosts;
+                    }
+                    else
+                    {
+                        ConsoleExt.WriteLine($"Invalid response!", ConsoleColor.Red);
+                    }
+                }
+                catch (SocketException ex)
+                {
+                    ConsoleExt.WriteLine($"Invalid host! Error message: {ex.Message}", ConsoleColor.Red);
+                }
+            }
+            else
+            {
+                ConsoleExt.WriteLine("Invalid IP address!", ConsoleColor.Red);
+            }
+        } while (true);
+    }
+}