/// <summary>
        /// https://www.example-code.com/dotnet-core/dnsLookup.asp
        /// </summary>
        /// <param name="target"></param>
        /// <returns></returns>
        public async Task <NetworkDnsQueryLookup> DnsChilkatLookup(string target)
        {
            Chilkat.Socket socket = new Chilkat.Socket();
            socket.UnlockComponent("unlock_code");

            int milliseconds = 10000;

            var address = await Task.Run(() => { return(socket.DnsLookup(target, milliseconds)); });

            var networkDnsQueryLookup = new NetworkDnsQueryLookup
            {
                IpAddress = address,
            };

            Debug.Assert(!string.IsNullOrEmpty(networkDnsQueryLookup.IpAddress), "IP Address empty? Why?");

            if (!socket.LastMethodSuccess)
            {
                Debug.WriteLine(socket.LastErrorText);
                return(default);
Beispiel #2
0
        public static void tunnel(int serverPort)
        {
            Chilkat.Socket tunnel = new Chilkat.Socket();

            bool success;

            //  Anything unlocks the component and begins a fully-functional 30-day trial.
            success = tunnel.UnlockComponent("Anything for 30-day trial");
            if (success != true)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            string sshHostname = "172.24.19.18";
            int    sshPort     = 22;

            //  Connect to an SSH server and establish the SSH tunnel:
            success = tunnel.SshOpenTunnel(sshHostname, sshPort);
            if (success != true)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            //  Authenticate with the SSH server via a login/password
            //  or with a public key.
            //  This example demonstrates SSH password authentication.
            success = tunnel.SshAuthenticatePw("rishabh", "root123");
            if (success != true)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            //  OK, the SSH tunnel is setup.  Now open a channel within the tunnel.
            //  Once the channel is obtained, the Socket API may
            //  be used exactly the same as usual, except all communications
            //  are sent through the channel in the SSH tunnel.
            //  Any number of channels may be created from the same SSH tunnel.
            //  Multiple channels may coexist at the same time.

            //  Connect to an NIST time server and read the current date/time
            Chilkat.Socket channel   = null;
            int            maxWaitMs = 4000;
            bool           useTls    = false;

            channel = tunnel.SshOpenChannel("time-c-g.nist.gov", 37, useTls, maxWaitMs);
            if (channel == null)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            //  The time server will send a big-endian 32-bit integer representing
            //  the number of seconds since since 00:00 (midnight) 1 January 1900 GMT.
            //  The ReceiveInt32 method will receive a 4-byte integer, but returns
            //  true or false to indicate success.  If successful, the integer
            //  is obtained via the ReceivedInt property.
            bool bigEndian = true;

            success = channel.ReceiveInt32(bigEndian);
            if (success != true)
            {
                Console.WriteLine(channel.LastErrorText);

                return;
            }

            Chilkat.CkDateTime dt = new Chilkat.CkDateTime();
            dt.SetFromNtpTime(channel.ReceivedInt);

            //  Show the current local date/time
            bool bLocalTime = true;

            Console.WriteLine("Current local date/time: " + dt.GetAsRfc822(bLocalTime));

            bool isSent = channel.SendString("echo hello world");

            if (isSent != true)
            {
                Console.WriteLine(channel.LastErrorText);
                return;
            }

            Console.WriteLine("---- echo hello world ----");

            //  Close the SSH channel.
            success = channel.Close(maxWaitMs);
            if (success != true)
            {
                Console.WriteLine(channel.LastErrorText);

                return;
            }

            //  It is possible to create a new channel from the existing SSH tunnel for the next connection:
            //  Any number of channels may be created from the same SSH tunnel.
            //  Multiple channels may coexist at the same time.
            channel = tunnel.SshOpenChannel("time-a.nist.gov", 37, useTls, maxWaitMs);
            if (channel == null)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            //  Review the LastErrorText to see that the connection was made via the SSH tunnel:
            Console.WriteLine(tunnel.LastErrorText);

            //  Close the connection to time-a.nist.gov.  This is actually closing our channel
            //  within the SSH tunnel, but keeps the tunnel open for the next port-forwarded connection.
            success = channel.Close(maxWaitMs);
            if (success != true)
            {
                Console.WriteLine(channel.LastErrorText);

                return;
            }

            //  Finally, close the SSH tunnel.
            success = tunnel.SshCloseTunnel();
            if (success != true)
            {
                Console.WriteLine(tunnel.LastErrorText);
                return;
            }

            Console.WriteLine("TCP SSH tunneling example completed.");
        }