public async Task TestLookupDomainDontFollowReferrer()
{
var request = new WhoisRequest {
Query = "google.com", FollowReferrer = false
};
var intermediateResult = sampleReader.Read("whois.verisign-grs.com", "com", "found_status_registered.txt");
var rootServer = new WhoisResponse
{
DomainName = new HostName("com"),
Registrar = new Registrar {
WhoisServer = new HostName("whois.verisign-grs.com")
}
};
whoisServerLookup
.Setup(call => call.LookupAsync(request))
.Returns(Task.FromResult(rootServer));
tcpReader
.Setup(call => call.Read("whois.verisign-grs.com", 43, "google.com", Encoding.UTF8, 10))
.Returns(Task.FromResult(intermediateResult));
var result = await lookup.LookupAsync(request);
Assert.AreEqual("google.com", result.DomainName.ToString());
Assert.AreEqual(WhoisStatus.Found, result.Status);
Assert.AreEqual(intermediateResult, result.Content);
Assert.AreEqual(rootServer, result.Referrer);
}
public async Task TestLookupDomain()
{
var request = new WhoisRequest("google.com");
var rootServer = new WhoisResponse
{
DomainName = new HostName("com"),
Registrar = new Registrar {
WhoisServer = new HostName("whois.markmonitor.com")
}
};
whoisServerLookup
.Setup(call => call.LookupAsync(request))
.Returns(Task.FromResult(rootServer));
tcpReader
.Setup(call => call.Read("whois.markmonitor.com", 43, "google.com", Encoding.UTF8, 10))
.Returns(Task.FromResult(sampleReader.Read("whois.markmonitor.com", "com", "found.txt")));
var result = await lookup.LookupAsync(request);
Assert.AreEqual("google.com", result.DomainName.ToString());
Assert.AreEqual(WhoisStatus.Found, result.Status);
}
public async Task TestLookupDomainUseBestResponse()
{
// Setup our initial request
var request = new WhoisRequest {
Query = "fark.co", FollowReferrer = true
};
// Setup the inital root server response
var rootServer = new WhoisResponse
{
DomainName = new HostName("co"),
Registrar = new Registrar {
WhoisServer = new HostName("whois.nic.co")
}
};
whoisServerLookup
.Setup(call => call.LookupAsync(request))
.Returns(Task.FromResult(rootServer));
// Setup the intermediate server response
var intermediateResult = sampleReader.Read("whois.nic.co", "co", "fark.co.txt");
tcpReader
.Setup(call => call.Read("whois.nic.co", 43, "fark.co", Encoding.UTF8, 10))
.Returns(Task.FromResult(intermediateResult));
// Setup the authoritative server response
// Note: this contains less data than the intermediate response, so should be ignored
var authoritativeResult = sampleReader.Read("whois.dynadot.com", "co", "fark.co.txt");
tcpReader
.Setup(call => call.Read("whois.dynadot.com", 43, "fark.co", Encoding.UTF8, 10))
.Returns(Task.FromResult(authoritativeResult));
var result = await lookup.LookupAsync(request);
Assert.AreEqual("fark.co", result.DomainName.ToString());
Assert.AreEqual(WhoisStatus.Found, result.Status);
Assert.AreEqual(intermediateResult, result.Content);
Assert.AreEqual(rootServer, result.Referrer);
}
public async Task TestLookupTld()
{
var request = new WhoisRequest(".com");
var rootServer = new WhoisResponse
{
DomainName = new HostName("com"),
Registrar = new Registrar {
WhoisServer = new HostName("whois.markmonitor.com")
}
};
whoisServerLookup
.Setup(call => call.LookupAsync(request))
.Returns(Task.FromResult(rootServer));
var result = await lookup.LookupAsync(request);
Assert.AreEqual(rootServer, result);
}
public async Task <WhoisResponse> LookupAsync(string domain, Encoding encoding)
{
if (string.IsNullOrEmpty(domain))
{
throw new ArgumentNullException("domain");
}
if (IsValidDomainName(domain) == false)
{
throw new WhoisException($"Domain Name is invalid: {domain}");
}
Log.Debug("Looking up WHOIS response for: {0}", domain);
var tld = GetTld(domain);
var whoisServer = await ServerLookup.LookupAsync(tld);
var response = new WhoisResponse();
var whoisServerUrl = whoisServer.Url;
while (string.IsNullOrEmpty(whoisServerUrl) == false)
{
var content = await Download(whoisServerUrl, domain, encoding);
response = whoisParser.Parse(whoisServerUrl, tld, content);
response.Content = content;
if (response.Registrar?.WhoisServerUrl == whoisServerUrl)
{
break;
}
whoisServerUrl = response.Registrar?.WhoisServerUrl;
}
return(response);
}
public void TestDownloadSampleDomainsSingleThreaded()
{
var domains = new SampleReader().ReadSampleDomains();
foreach (var domain in domains)
{
Console.WriteLine($"Looking Up: {domain.DomainName}");
WhoisResponse response = null;
try
{
response = lookup.Lookup(domain.DomainName);
Console.WriteLine($"Looked Up: {domain.DomainName}, Status: {response.Status}, Size: {response.Content.Length}");
}
catch (Exception e)
{
Console.WriteLine($"FAIL: {response?.DomainName}: {e.Message}");
}
Thread.Sleep(1000);
}
}
public static void Write(WhoisResponse response)
{
sb.Clear();
Write(nameof(response.ParsingErrors), response.ParsingErrors);
Write(nameof(response.TemplateName), response.TemplateName);
sb.AppendLine();
Write(nameof(response.DomainName), response.DomainName);
Write(nameof(response.RegistryDomainId), response.RegistryDomainId);
if (response.Registrar != null)
{
sb.AppendLine();
sb.AppendLine(" // Registrar Details");
Write(nameof(response.Registrar) + "." + nameof(response.Registrar.Name), response.Registrar?.Name);
Write(nameof(response.Registrar) + "." + nameof(response.Registrar.IanaId), response.Registrar?.IanaId);
Write(nameof(response.Registrar) + "." + nameof(response.Registrar.Url), response.Registrar?.Url);
Write(nameof(response.Registrar) + "." + nameof(response.Registrar.WhoisServerUrl), response.Registrar?.WhoisServerUrl);
Write(nameof(response.Registrar) + "." + nameof(response.Registrar.AbuseEmail), response.Registrar?.AbuseEmail);
Write(nameof(response.Registrar) + "." + nameof(response.Registrar.AbuseTelephoneNumber), response.Registrar?.AbuseTelephoneNumber);
}
sb.AppendLine();
Write(nameof(response.Updated), response.Updated);
Write(nameof(response.Registered), response.Registered);
Write(nameof(response.Expiration), response.Expiration);
Write(nameof(response.Registrant), response.Registrant);
Write(nameof(response.AdminContact), response.AdminContact);
Write(nameof(response.BillingContact), response.BillingContact);
Write(nameof(response.TechnicalContact), response.TechnicalContact);
sb.AppendLine();
if (response.NameServers.Any())
{
sb.AppendLine(" // Nameservers");
Write($"{nameof(response.NameServers)}.Count", response.NameServers.Count);
for (var i = 0; i < response.NameServers.Count; i++)
{
var nameServer = response.NameServers[i];
Write($"{nameof(response.NameServers)}[{i}]", nameServer);
}
sb.AppendLine();
}
if (response.DomainStatus.Any())
{
sb.AppendLine(" // Domain Status");
Write($"{nameof(response.DomainStatus)}.Count", response.DomainStatus.Count);
for (var i = 0; i < response.DomainStatus.Count; i++)
{
var status = response.DomainStatus[i];
Write($"{nameof(response.DomainStatus)}[{i}]", status);
}
sb.AppendLine();
}
Write(nameof(response.DnsSecStatus), response.DnsSecStatus);
Write(nameof(response.FieldsParsed), response.FieldsParsed);
Console.WriteLine(sb.ToString());
WindowsClipboard.SetText(sb.ToString());
}
/// <summary>
/// Performs a WHOIS lookup for the given request.
/// </summary>
public async Task <WhoisResponse> LookupAsync(WhoisRequest request)
{
if (string.IsNullOrEmpty(request.Query))
{
throw new ArgumentNullException("domain");
}
// Trim leading '.'
if (request.Query.StartsWith("."))
{
request.Query = request.Query.Substring(1);
}
// Validate domain name
if (HostName.TryParse(request.Query, out var hostName) == false)
{
throw new WhoisException($"WHOIS Query Format Error: {request.Query}");
}
Log.Debug("Looking up WHOIS response for: {0}", hostName.Value);
// Set our starting point
WhoisResponse response;
if (string.IsNullOrEmpty(request.WhoisServerUrl))
{
// Lookup root WHOIS server for the TLD
response = await ServerLookup.LookupAsync(request);
}
else
{
// Use the given WHOIS server
response = WhoisResponse.WithServerUrl(request.WhoisServerUrl);
}
// Main loop: download & parse WHOIS data and follow the referrer chain
var whoisServerUrl = response?.WhoisServerUrl;
while (string.IsNullOrEmpty(whoisServerUrl) == false && !hostName.IsTld)
{
// Download
var content = await Download(whoisServerUrl, request);
// Parse result
var parsed = whoisParser.Parse(whoisServerUrl, content);
// Build referrer chain
response = response.Chain(parsed);
// Check for referral loop
if (request.FollowReferrer == false)
{
break;
}
if (response.SeenServer(response.WhoisServerUrl))
{
break;
}
// Lookup result in referral server
whoisServerUrl = response.WhoisServerUrl;
}
return(response);
}
/// <summary>
/// Performs a WHOIS lookup for the given request.
/// </summary>
public async Task <WhoisResponse> LookupAsync(WhoisRequest request)
{
if (string.IsNullOrEmpty(request.Query))
{
throw new ArgumentNullException($"{nameof(request)}.{nameof(request.Query)}");
}
// Trim leading '.'
if (request.Query.StartsWith("."))
{
request.Query = request.Query.Substring(1);
}
// Validate domain name
if (HostName.TryParse(request.Query, out var hostName) == false)
{
throw new WhoisException($"WHOIS Query Format Error: {request.Query}");
}
Log.Debug("Looking up WHOIS response for: {0}", hostName.Value);
// Set our starting point
WhoisResponse response;
if (string.IsNullOrEmpty(request.WhoisServer))
{
// Lookup root WHOIS server for the TLD
response = await ServerLookup.LookupAsync(request);
}
else
{
// Use the given WHOIS server
response = WhoisResponse.WithServerUrl(request.WhoisServer);
}
// If query is for a top level domain, we're finished
if (hostName.IsTld)
{
return(response);
}
// Main loop: download & parse WHOIS data and follow the referrer chain
var whoisServer = response?.WhoisServer;
while (whoisServer != null)
{
// Download
var content = await Download(whoisServer.Value, request);
// Parse result
var parsed = Parser.Parse(whoisServer.Value, content);
// Sanity check: ensure the last response has some data
if (parsed.FieldsParsed == 0 && response.FieldsParsed > 0)
{
break;
}
// Build referrer chain
response = response.Chain(parsed);
// Check for referral loop
if (request.FollowReferrer == false)
{
break;
}
if (response.SeenServer(response.WhoisServer))
{
break;
}
// Lookup result in referral server
whoisServer = response.WhoisServer;
}
return(response);
}
/// <summary>
/// Sets the WHOIS referrer on this instance
/// </summary>
internal WhoisResponse Chain(WhoisResponse response)
{
response.Referrer = this;
return(response);
}
