Route.cs

using System;
using System.Net.NetworkInformation;
using System.Threading.Tasks;
using Waher.Networking.DNS;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Objects.Matrices;
using Waher.Script.Objects.VectorSpaces;
using Waher.Script.Units;
 
namespace Waher.Script.Networking.Functions
{
    public class Route : FunctionOneScalarVariable
    {
        public Route(ScriptNode Argument, int Start, int Length, Expression Expression)
            : base(Argument, Start, Length, Expression)
        {
        }
 
        public override string FunctionName => nameof(Route);
 
        public override bool IsAsynchronous => true;
 
        public override IElement EvaluateScalar(string Argument, Variables Variables)
        {
            return this.EvaluateScalarAsync(Argument, Variables).Result;
        }
 
        public override async Task<IElement> EvaluateScalarAsync(string Argument, Variables Variables)
        {
            using System.Net.NetworkInformation.Ping Icmp = new System.Net.NetworkInformation.Ping();
            PingReply Response;
            PingOptions Options = new PingOptions()
            {
                Ttl = 1
            };
            ChunkedList<IElement> Elements = new ChunkedList<IElement>();
            IElement E;
 
            do
            {
                Response = await Icmp.SendPingAsync(Argument, 2000, Ping.data, Options);
 
                Elements.Add(new DoubleNumber(Options.Ttl));
                Elements.Add(new ObjectValue(Response.Address));
 
                if (Response.Status == IPStatus.Success)
                    E = new PhysicalQuantity(Response.RoundtripTime, Unit.Parse("ms"));
                else if (Response.Status == IPStatus.TimedOut ||
                    Response.Status == IPStatus.TimeExceeded ||
                    Response.Status == IPStatus.TtlExpired)
                {
                    E = ObjectValue.Null;
                }
                else
                    E = new StringValue(Ping.GetErrorMessage(Response));
 
                Elements.Add(E);
 
                try
                {
                    string[] Names = await DnsResolver.TryReverseDns(Response.Address);
 
                    if (Names is null)
                        E = ObjectValue.Null;
                    else if (Names.Length == 1)
                        E = new StringValue(Names[0]);
                    else
                        E = new ObjectVector(Names);
                }
                catch (Exception)
                {
                    E = ObjectValue.Null;
                }
 
                Elements.Add(E);
                Options.Ttl++;
            }
            while (Response.Status != IPStatus.Success && Options.Ttl < 256);
 
            return new ObjectMatrix(Elements.Count / 4, 4, Elements)
            {
                ColumnNames = new string[] { "TTL", "IP", "Roundtrip", "Name" }
            };
        }
 
        public override IElement EvaluateScalar(IElement Argument, Variables Variables)
        {
            return this.EvaluateScalarAsync(Argument, Variables).Result;
        }
 
        public override Task<IElement> EvaluateScalarAsync(IElement Argument, Variables Variables)
        {
            return this.EvaluateScalarAsync(ToString(Argument) ?? string.Empty, Variables);
        }
    }
}