예제 #1
0
        protected override async Task <int> Execute()
        {
            Console.WriteLine();
            Console.WriteLine($"; <<>> MiniDiG {Version} {OS} <<>> {string.Join(" ", OriginalArgs)}");

            string     useDomain = string.IsNullOrWhiteSpace(DomainArg.Value) ? "." : DomainArg.Value;
            QueryType  useQType  = 0;
            QueryClass useQClass = 0;

            if (!string.IsNullOrWhiteSpace(QClassArg.Value))
            {
                // q class != null => 3 params (domain already set above).
                Enum.TryParse(QClassArg.Value, true, out useQClass);
                Enum.TryParse(QTypeArg.Value, true, out useQType);
            }
            else
            {
                // q class is null => 2 params only
                // test if no domain is specified and first param is either qtype or qclass
                if (Enum.TryParse(DomainArg.Value, true, out useQType))
                {
                    useDomain = ".";
                    Enum.TryParse(QTypeArg.Value, true, out useQClass);
                }
                else if (Enum.TryParse(DomainArg.Value, true, out useQClass))
                {
                    useDomain = ".";
                }
                else if (!Enum.TryParse(QTypeArg.Value, true, out useQType))
                {
                    // could be q class as second and no QType
                    Enum.TryParse(QTypeArg.Value, true, out useQClass);
                }
            }

            if (ReversArg.HasValue())
            {
                useQType  = QueryType.PTR;
                useQClass = QueryClass.IN;
                IPAddress ip;
                if (!IPAddress.TryParse(useDomain, out ip))
                {
                    Console.WriteLine($";; Error: Reverse lookup for invalid ip {useDomain}.");
                    return(1);
                }

                useDomain = LookupClient.GetArpaName(ip);
            }

            if (useQType == 0)
            {
                if (string.IsNullOrWhiteSpace(useDomain) || useDomain == ".")
                {
                    useQType = QueryType.NS;
                }
                else
                {
                    useQType = QueryType.A;
                }
            }

            try
            {
                // finally running the command
                var lookup = GetDnsLookup();
                lookup.EnableAuditTrail = true;

                var result = useQClass == 0 ?
                             await lookup.QueryAsync(useDomain, useQType) :
                             await lookup.QueryAsync(useDomain, useQType, useQClass);

                Console.WriteLine(result.AuditTrail);
            }
            catch (Exception ex)
            {
                var agg = ex as AggregateException;
                var dns = ex as DnsResponseException;
                agg?.Handle(e =>
                {
                    dns = e as DnsResponseException;
                    if (dns != null)
                    {
                        return(true);
                    }

                    return(false);
                });

                if (dns != null)
                {
                    Console.WriteLine(dns.AuditTrail);
                    Console.WriteLine($";; Error: {ex.Message}");
                    return(24);
                }
                else
                {
                    Console.WriteLine($";; Error: {ex.Message}");
                    return(40);
                }
            }

            return(0);
        }