public void RecursiveResolveDomainName(DnsCache cache = null, NetProxy proxy = null, bool preferIPv6 = false, DnsTransportProtocol protocol = DnsTransportProtocol.Udp, int retries = 2, int timeout = 2000, DnsTransportProtocol recursiveResolveProtocol = DnsTransportProtocol.Udp)
{
if (_ipEndPoint != null)
{
try
{
DnsDatagram nsResponse = DnsClient.RecursiveResolve(new DnsQuestionRecord(_ipEndPoint.Address, DnsClass.IN), null, cache, proxy, preferIPv6, protocol, retries, timeout, recursiveResolveProtocol);
if ((nsResponse.Header.RCODE == DnsResponseCode.NoError) && (nsResponse.Answer.Length > 0) && (nsResponse.Answer[0].Type == DnsResourceRecordType.PTR))
{
_domainEndPoint = new DomainEndPoint((nsResponse.Answer[0].RDATA as DnsPTRRecord).PTRDomainName, _ipEndPoint.Port);
}
}
catch
{ }
}
}
public void RecursiveResolveIPAddress(DnsCache cache = null, NetProxy proxy = null, bool preferIPv6 = false, DnsTransportProtocol protocol = DnsTransportProtocol.Udp, int retries = 2, int timeout = 2000, DnsTransportProtocol recursiveResolveProtocol = DnsTransportProtocol.Udp)
{
lock (_ipEndPointResolverLock)
{
if (_ipEndPointExpires && (DateTime.UtcNow < _ipEndPointExpiresOn))
{
return;
}
string domain;
if (_dohEndPoint != null)
{
domain = _dohEndPoint.Host;
}
else if (_domainEndPoint != null)
{
domain = _domainEndPoint.Address;
}
else
{
return;
}
if (domain == "localhost")
{
_ipEndPoint = new IPEndPoint((preferIPv6 ? IPAddress.IPv6Loopback : IPAddress.Loopback), this.Port);
return;
}
if (IPAddress.TryParse(domain, out IPAddress address))
{
_ipEndPoint = new IPEndPoint(address, this.Port);
return;
}
IPEndPoint ipEndPoint = null;
DateTime ipEndPointExpiresOn = DateTime.MinValue;
if (preferIPv6)
{
DnsDatagram nsResponse = DnsClient.RecursiveResolve(new DnsQuestionRecord(domain, DnsResourceRecordType.AAAA, DnsClass.IN), null, cache, proxy, true, protocol, retries, timeout, recursiveResolveProtocol);
if ((nsResponse.Header.RCODE == DnsResponseCode.NoError) && (nsResponse.Answer.Length > 0) && (nsResponse.Answer[0].Type == DnsResourceRecordType.AAAA))
{
ipEndPoint = new IPEndPoint((nsResponse.Answer[0].RDATA as DnsAAAARecord).Address, this.Port);
ipEndPointExpiresOn = DateTime.UtcNow.AddSeconds(nsResponse.Answer[0].TtlValue);
}
}
if (ipEndPoint == null)
{
DnsDatagram nsResponse = DnsClient.RecursiveResolve(new DnsQuestionRecord(domain, DnsResourceRecordType.A, DnsClass.IN), null, cache, proxy, false, protocol, retries, timeout, recursiveResolveProtocol);
if ((nsResponse.Header.RCODE == DnsResponseCode.NoError) && (nsResponse.Answer.Length > 0) && (nsResponse.Answer[0].Type == DnsResourceRecordType.A))
{
ipEndPoint = new IPEndPoint((nsResponse.Answer[0].RDATA as DnsARecord).Address, this.Port);
ipEndPointExpiresOn = DateTime.UtcNow.AddSeconds(nsResponse.Answer[0].TtlValue);
}
}
if (ipEndPoint == null)
{
throw new DnsClientException("No IP address was found for name server: " + domain);
}
_ipEndPoint = ipEndPoint;
_ipEndPointExpires = true;
_ipEndPointExpiresOn = ipEndPointExpiresOn;
}
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
int staticFilesCachePeriod;
if (env.IsDevelopment())
{
staticFilesCachePeriod = 60;
app.UseDeveloperExceptionPage();
}
else
{
staticFilesCachePeriod = 14400;
}
app.UseDefaultFiles();
app.UseStaticFiles(new StaticFileOptions()
{
OnPrepareResponse = delegate(StaticFileResponseContext ctx)
{
ctx.Context.Response.Headers.Append("Cache-Control", $"public, max-age={staticFilesCachePeriod}");
}
});
app.Run(async(context) =>
{
await Task.Run(() =>
{
HttpRequest Request = context.Request;
HttpResponse Response = context.Response;
if (Request.Path == "/api/dnsclient/")
{
try
{
string server = Request.Query["server"];
string domain = Request.Query["domain"];
DnsResourceRecordType type = (DnsResourceRecordType)Enum.Parse(typeof(DnsResourceRecordType), Request.Query["type"], true);
if (domain.EndsWith("."))
{
domain = domain.Substring(0, domain.Length - 1);
}
bool preferIpv6 = Configuration.GetValue <bool>("PreferIpv6");
int retries = Configuration.GetValue <int>("Retries");
int timeout = Configuration.GetValue <int>("Timeout");
DnsDatagram dnsResponse;
if (server == "recursive-resolver")
{
bool useTcp = Configuration.GetValue <bool>("UseTcpForRecursion");
DnsQuestionRecord question;
if (type == DnsResourceRecordType.PTR)
{
question = new DnsQuestionRecord(IPAddress.Parse(domain), DnsClass.IN);
}
else
{
question = new DnsQuestionRecord(domain, type, DnsClass.IN);
}
dnsResponse = DnsClient.RecursiveResolve(question, null, null, null, preferIpv6, retries, timeout, useTcp);
}
else
{
DnsTransportProtocol protocol = (DnsTransportProtocol)Enum.Parse(typeof(DnsTransportProtocol), Request.Query["protocol"], true);
NameServerAddress nameServer = new NameServerAddress(server);
if (nameServer.IPEndPoint == null)
{
nameServer.ResolveIPAddress(null, null, preferIpv6);
}
else if (nameServer.DomainEndPoint == null)
{
try
{
nameServer.ResolveDomainName(null, null, preferIpv6);
}
catch
{ }
}
DnsClient dnsClient = new DnsClient(nameServer);
dnsClient.PreferIPv6 = preferIpv6;
dnsClient.Protocol = protocol;
dnsClient.Retries = retries;
dnsClient.Timeout = timeout;
dnsResponse = dnsClient.Resolve(domain, type);
if (dnsResponse.Header.Truncation && (dnsClient.Protocol == DnsTransportProtocol.Udp))
{
dnsClient.Protocol = DnsTransportProtocol.Tcp;
dnsResponse = dnsClient.Resolve(domain, type);
}
}
string jsonResponse = JsonConvert.SerializeObject(dnsResponse, new StringEnumConverter());
Response.Headers.Add("Content-Type", "application/json; charset=utf-8");
Response.WriteAsync("{\"status\":\"ok\", \"response\":" + jsonResponse + "}");
}
catch (Exception ex)
{
string jsonResponse = JsonConvert.SerializeObject(ex);
Response.Headers.Add("Content-Type", "application/json; charset=utf-8");
Response.WriteAsync("{\"status\":\"error\", \"response\":" + jsonResponse + "}");
}
}
});
});
}
