Route.cs

using System;
using System.Collections.Generic;
using System.Net.NetworkInformation;
using System.Threading.Tasks;
using Waher.Networking.DNS;
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
                };
                LinkedList<IElement> Elements = new LinkedList<IElement>();
                IElement E;
 
                do
                {
                    Response = await Icmp.SendPingAsync(Argument, 2000, Ping.data, Options);
 
                    Elements.AddLast(new DoubleNumber(Options.Ttl));
                    Elements.AddLast(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.AddLast(E);
 
                    try
                    {
                        string[] Names = await DnsResolver.ReverseDns(Response.Address);
 
                        if (Names.Length == 1)
                            E = new StringValue(Names[0]);
                        else
                            E = new ObjectVector(Names);
                    }
                    catch (Exception)
                    {
                        E = ObjectValue.Null;
                    }
 
                    Elements.AddLast(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(Argument.AssociatedObjectValue?.ToString() ?? string.Empty, Variables);
        }
    }
}