HostScan.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Net.Sockets;
using System.Net;

namespace net_scan
{
    class HostScan
    {
        private string subnet;
        private int start_address;
        private int end_address;
        private int port;
        private int timeout;
        private int running_threads;
        private int Ccount;

        private int Subcount;
        private int end_sub;
        private int start_sub;

        public bool finished = false;

        private class isTcpPortOpen
        {
            public TcpClient MainClient { get; set; }
            public bool tcpOpen { get; set; }
        }


        Random rn = new Random(5000);
        public HostScan(string Subnet,string start_sub, string end_sub ,string start_address,string end_address,int port,int timeout)
        {
            this.subnet = Subnet;
            this.start_address = int.Parse(start_address);
            this.end_address = int.Parse(end_address);
            this.start_sub = int.Parse(start_sub);
            this.end_sub = int.Parse(end_sub);
            this.port = port;
            this.timeout = timeout;
            this.Ccount = int.Parse(start_address);
        }

        public void start(int threadCount)
        {
            running_threads = 0;
            Ccount = start_address;
            Subcount = start_sub;


            for (int i = 0; i < threadCount; i++)
            {
                Thread thread = new Thread(new ThreadStart(scan));
                thread.Start();
                running_threads++;
            }
        }

        public void scan()
        {

            IPAddress ip;
            string current;

            while ((current = Current_Counter()) != "f")
            {
                Thread.Sleep(5);

                if (!IPAddress.TryParse(subnet + current, out ip))
                {
                    Console.WriteLine(" [!] provided address range is not valid");
                    return;
                }

                try
                {
                    Connect(subnet + current, port, timeout);
                    string hostnameOutput = GetDnsHostName(subnet + current);

                    string output = $"{hostnameOutput} : " + $" -- TCP Port {port} open on {subnet + current} ";
                    Console.WriteLine(output);
                }
                catch
                {
                    continue;
                }
            }
            

            if (Interlocked.Decrement(ref running_threads)==0)
            {
                Console.WriteLine("==================================================================");
                Console.WriteLine("                        --- Done !! ---");
                finished = true;
            }
        }

        public string GetDnsHostName(string iPAddress)
        {
            try
            {
                IPHostEntry hostEntry = Dns.GetHostEntry(iPAddress);
                return $" [+] [ DNS hostname ] : {hostEntry.HostName}";
            }
            catch (Exception)
            {

                return "";
            }
        }

      
        string result;
        private static readonly object lck = new object();
        public string Current_Counter()
        {
            lock(lck)
            {
                if ((end_sub - Subcount) >= 0)
                {
                    if ((end_address - Ccount) > 0)
                    {
                        result = Subcount.ToString() + "." + Ccount.ToString();
                        Interlocked.Increment(ref Ccount);
                        return result;
                    }
                    else if ((end_address - Ccount) <= 0)
                    {
                        result = Subcount.ToString() + "." + Ccount.ToString();
                        Ccount = start_address;
                        Interlocked.Increment(ref Subcount);
                        Console.WriteLine(" at: " + result + " ... ");
                        return result;
                    }
                }

                return "f";
            }
        }


        public int sub_counter()
        {
            if ((end_sub - Subcount) >= 0)
            {
                return Subcount++;
            }
            return -1;
        }


        public TcpClient Connect(string hostName, int port, int timeout)
        {
            var newClient = new TcpClient();

            var state = new isTcpPortOpen
            {
                MainClient = newClient,
                tcpOpen = true
            };
            
                IAsyncResult ar = newClient.BeginConnect(hostName, port, AsyncCallback, state);
                state.tcpOpen = ar.AsyncWaitHandle.WaitOne(timeout*1000, false);

            
            if (state.tcpOpen == false || newClient.Connected == false)
            {
                throw new Exception();

            }
            return newClient;
        }
        public TcpClient Connect2(string hostName, int port, int timeout)
        {
            var newClient = new TcpClient();

            using (var tcp = new TcpClient())
            {
                var ar = tcp.BeginConnect(hostName, port, null, null);
                using (ar.AsyncWaitHandle)
                {
                    //Wait 2 seconds for connection.
                    if (ar.AsyncWaitHandle.WaitOne(timeout*1000, false))
                    {
                        try
                        {
                            tcp.EndConnect(ar);
                            //Connect was successful.
                        }
                        catch
                        {
                            //EndConnect threw an exception.
                            //serv refused the connection.
                        }
                    }
                    else
                    {
                        //Console.WriteLine("timed out");
                    }
                }

            }
            return newClient;
        }

        void AsyncCallback(IAsyncResult asyncResult)
        {
            var state = (isTcpPortOpen)asyncResult.AsyncState;
            TcpClient client = state.MainClient;

            try
            {
                client.EndConnect(asyncResult);
            }
            catch
            {
                return;
            }

            if (client.Connected && state.tcpOpen)
            {
                return;
            }

            client.Close();
        }

       
        
    }
}