public Task <LookupState> Visit(LookupState state)
{
if (state.Options.ParseWhoisResponse == false)
{
return(Task.FromResult(state));
}
try
{
if (matcher.TryMatch <ParsedWhoisResponse>(state.Response.Content, out var match))
{
Log.Debug("Parsed WHOIS data using pattern {0} - {1} replacement(s) made.", match.Template.Name, match.Matches);
state.Response.ParsedResponse = match.Result;
}
else
{
Log.Debug("Unable to parse WHOIS data.");
}
}
catch (Exception e)
{
Log.Error(e, "Error parsing WHOIS DATA for: {0}", state.Domain);
if (state.Options.ThrowOnParsingException)
{
throw;
}
}
return(Task.FromResult(state));
}
private void MakeFSM(Soldier soldier)
{
LookupState lookupState = new LookupState(soldier.gameObject);
lookupState.AddTransition(Transition.FoundEnemy, StateID.ForwardEnemy);
lookupState.AddTransition(Transition.HpEmpty, StateID.Dead);
ForwardState forwardState = new ForwardState(soldier.gameObject);
forwardState.AddTransition(Transition.LostEnemy, StateID.LookupEnemy);
forwardState.AddTransition(Transition.CanAttackEnemy, StateID.AttackEnemy);
forwardState.AddTransition(Transition.HpEmpty, StateID.Dead);
AttackState attackState = new AttackState(soldier.gameObject);
attackState.AddTransition(Transition.LostEnemy, StateID.LookupEnemy);
attackState.AddTransition(Transition.HpEmpty, StateID.Dead);
DeadState deadState = new DeadState(soldier.gameObject);
deadState.AddTransition(Transition.HpRemain, StateID.LookupEnemy);
fsm = new FSMSystem();
fsm.AddState(lookupState);
fsm.AddState(forwardState);
fsm.AddState(attackState);
fsm.AddState(deadState);
}
public void TestParseBrRecord()
{
var sample = File.ReadAllText("..\\..\\..\\Samples\\Domains\\001hosting.com.br.txt");
var state = new LookupState
{
Response = new WhoisResponse(sample),
Options = new WhoisOptions {
ParseWhoisResponse = true
}
};
visitor.Visit(state);
var record = state.Response.ParsedResponse;
Assert.AreEqual("001hosting.com.br", record.DomainName);
Assert.AreEqual("350.562.738-05", record.RegistryDomainId);
Assert.AreEqual("Ultra Provedor", record.Registrar.Name);
Assert.AreEqual(new DateTime(2019, 4, 6, 0, 0, 0), record.Updated.Value.ToUniversalTime());
Assert.AreEqual(new DateTime(2001, 9, 19, 0, 0, 0), record.Registered.Value.ToUniversalTime());
Assert.AreEqual(new DateTime(2020, 9, 19, 0, 0, 0), record.Expiration.Value.ToUniversalTime());
Assert.AreEqual("ULPRO5", record.Registrant.Name);
Assert.AreEqual("ULPRO5", record.AdminContact.Name);
Assert.AreEqual("ULPRO5", record.TechnicalContact.Name);
Assert.AreEqual(3, record.NameServers.Count);
Assert.AreEqual("ns1.ultraprovedor.com.br", record.NameServers[0]);
Assert.AreEqual("ns2.ultraprovedor.com.br", record.NameServers[1]);
Assert.AreEqual("ns3.ultraprovedor.com.br", record.NameServers[2]);
}
public async Task <LookupState> Visit(LookupState state)
{
var server = Cache.Get(state.Tld);
if (server == null)
{
server = await WhoisServerLookup.LookupAsync(state.Tld);
if (server != null)
{
Cache.Set(server);
}
}
else
{
Log.Debug("Retreived Root WHOIS server for TLD {0} from cache.", state.Tld);
}
if (server == null || string.IsNullOrEmpty(server.Url))
{
Log.Error("Unable to locate Root WHOIS server for TLD: {0}", state.Tld);
throw new WhoisException($"Unable to locate Root WHOIS server for TLD: {state.Tld}");
}
state.WhoisServer = server;
return(state);
}
// Record the IPs in the state object for later use.
public void GetHostEntryCallback(IAsyncResult ar)
{
ResolveState ioContext = (ResolveState)ar.AsyncState;
LookupState returnState = new LookupState();
returnState.hostName = ioContext.host;
try
{
ioContext.IPs = Dns.EndResolve(ar);
returnState.successful = true;
returnState.resolvedIPs = ioContext.IPs;
}
catch (SocketException se)
{
returnState.successful = false;
returnState.message = se.Message;
}
catch (Exception e)
{
returnState.successful = false;
returnState.message = e.Message;
}
GetHostEntryFinished.Set();
ioContext.Callback.Invoke(returnState);
}
public void TestValidateWhenDomainTooLong()
{
var state = new LookupState {
Domain = "example-too-long-domain-name-1234456678990123445678901233456778901234456678890.com"
};
Assert.Throws <WhoisException>(() => visitor.Visit(state));
}
public void TestLookupWhoisServerWhenNotFound()
{
var state = new LookupState {
Tld = "com"
};
Assert.Throws <AggregateException>(() => Task.Run(async() => await visitor.Visit(state)).Wait());
}
public void TestValidateWhenNullString()
{
var state = new LookupState {
Domain = ""
};
Assert.Throws <WhoisException>(() => visitor.Visit(state));
}
public async Task TestValidateDomainAndNewTld()
{
var state = new LookupState {
Domain = "example.ninja"
};
var result = await visitor.Visit(state);
Assert.AreEqual("example.ninja", result.Domain);
Assert.AreEqual("ninja", result.Tld);
}
public async Task TestLookupWhoisServerWhenCached()
{
visitor.Cache.Set(new WhoisServer("com", "test.whois.com"));
var state = new LookupState {
Tld = "com"
};
Assert.IsNull(state.WhoisServer);
state = await visitor.Visit(state);
Assert.AreEqual("test.whois.com", state.WhoisServer.Url);
}
// GET: Admin/States/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LookupState lookupState = db.LookupStates.Find(id);
if (lookupState == null)
{
return(HttpNotFound());
}
return(View(lookupState));
}
public ActionResult Edit([Bind(Include = "Id,CountryId,StateCode,StateName,IsActive,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy")] LookupState lookupState)
{
if (ModelState.IsValid)
{
lookupState.UpdatedBy = CurrentUser.Id;
lookupState.UpdatedOn = DateTime.UtcNow;
db.Entry(lookupState).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CountryId = new SelectList(db.LookupCountries, "Id", "CountryCode", lookupState.CountryId);
ViewBag.CreatedBy = new SelectList(db.Users, "Id", "UserName", lookupState.CreatedBy);
ViewBag.UpdatedBy = new SelectList(db.Users, "Id", "UserName", lookupState.UpdatedBy);
return(View(lookupState));
}
public async Task TestRedirectedWhoisData()
{
TcpReaderFactory.Bind(() => new FakeTcpReader("Redirected WHOIS Data"));
var record = new WhoisResponse(File.ReadAllText(@"..\..\..\Samples\Redirects\MarkMonitor.txt"));
var state = new LookupState
{
Response = record,
Options = WhoisOptions.Defaults,
Domain = "example.com"
};
var result = await visitor.Visit(state);
Assert.AreEqual("Redirected WHOIS Data", result.Response.Content);
}
public ActionResult DeleteConfirmed(int id)
{
LookupState lookupState = db.LookupStates.Find(id);
try
{
db.LookupStates.Remove(lookupState);
db.SaveChanges();
}
catch (DbUpdateException ex)
{
ModelState.AddModelError("Error", "There are some releted item in database, please delete those first");
return(View("Delete", lookupState));
}
return(RedirectToAction("Index"));
}
public void TestDownloadWhoisResults()
{
TcpReaderFactory.Bind(() => new FakeTcpReader("WHOIS Data"));
var server = new WhoisServer("uk", "whois.com");
var lookup = new LookupState
{
WhoisServer = server,
Domain = "flipbit.co.uk",
Options = WhoisOptions.Defaults
};
visitor.Visit(lookup);
Assert.AreEqual("WHOIS Data", lookup.Response.Content);
}
public async Task <LookupState> Visit(LookupState state)
{
using (var tcpReader = TcpReaderFactory.Create())
{
var response = await tcpReader.Read(state.WhoisServer.Url, 43, state.Domain, state.Options.DefaultEncoding);
state.Response = new WhoisResponse
{
Domain = state.Domain,
Content = response
};
}
Log.Debug("Lookup {0}: Downloaded {1:###,###,##0} byte(s) from {2}.", state.Domain, state.Response.Content.Length, state.WhoisServer.Url);
return(state);
}
// GET: Admin/States/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LookupState lookupState = db.LookupStates.Find(id);
if (lookupState == null)
{
return(HttpNotFound());
}
ViewBag.CountryId = new SelectList(db.LookupCountries, "Id", "CountryCode", lookupState.CountryId);
ViewBag.CreatedBy = new SelectList(db.Users, "Id", "UserName", lookupState.CreatedBy);
ViewBag.UpdatedBy = new SelectList(db.Users, "Id", "UserName", lookupState.UpdatedBy);
return(View(lookupState));
}
public Task <LookupState> Visit(LookupState state)
{
if (string.IsNullOrEmpty(state.Domain))
{
throw new WhoisException($"Domain Name not specified.");
}
state.Domain = state.Domain.Trim();
if (IsValidDomainName(state.Domain) == false)
{
throw new WhoisException($"Domain Name is invalid: {state.Domain}");
}
state.Tld = GetTld(state.Domain);
return(Task.FromResult(state));
}
public async Task <LookupState> Visit(LookupState state)
{
if (IsARedirectRecord(state.Response, out var redirect))
{
using (var tcpReader = TcpReaderFactory.Create())
{
var response = await tcpReader.Read(redirect.Url, 43, state.Domain, state.Options.DefaultEncoding);
Log.Debug("Lookup {0}: Downloaded {1:###,###,##0} byte(s) from {2}.", state.Domain, response.Length, redirect.Url);
state.Response = new WhoisResponse
{
Domain = state.Domain,
Content = response
};
}
}
return(state);
}
public async Task TestLookupWhoisServer()
{
lookup
.Setup(call => call.LookupAsync("com"))
.ReturnsAsync(new WhoisServer("com", "test.whois.com"));
var state = new LookupState {
Tld = "com"
};
Assert.IsNull(state.WhoisServer);
state = await visitor.Visit(state);
Assert.AreEqual("test.whois.com", state.WhoisServer.Url);
var cached = visitor.Cache.Get("com");
Assert.AreEqual("test.whois.com", cached.Url);
}
public void TestParseRecord()
{
var sample = File.ReadAllText("..\\..\\..\\Samples\\Domains\\adobe.com.txt");
var state = new LookupState
{
Response = new WhoisResponse(sample),
Options = new WhoisOptions {
ParseWhoisResponse = true
}
};
visitor.Visit(state);
var record = state.Response.ParsedResponse;
Assert.AreEqual("adobe.com", record.DomainName);
Assert.AreEqual("4364022_DOMAIN_COM-VRSN", record.RegistryDomainId);
Assert.AreEqual("whois.comlaude.com", record.Registrar.WhoisServerUrl);
Assert.AreEqual("http://www.comlaude.com", record.Registrar.Url);
Assert.AreEqual(new DateTime(2018, 10, 18, 17, 9, 58), record.Updated.Value.ToUniversalTime());
Assert.AreEqual(new DateTime(1986, 11, 17, 05, 0, 00), record.Registered.Value.ToUniversalTime());
Assert.AreEqual(new DateTime(2019, 05, 17, 00, 0, 00), record.Expiration.Value.ToUniversalTime());
Assert.AreEqual("NOM-IQ Ltd dba Com Laude", record.Registrar.Name);
Assert.AreEqual("470", record.Registrar.IanaId);
Assert.AreEqual("clientUpdateProhibited", record.DomainStatus[0]);
Assert.AreEqual("serverDeleteProhibited", record.DomainStatus[1]);
Assert.AreEqual("serverTransferProhibited", record.DomainStatus[2]);
Assert.AreEqual("serverUpdateProhibited", record.DomainStatus[3]);
Assert.AreEqual("Domain Administrator", record.Registrant.Name);
Assert.AreEqual("Adobe Inc.", record.Registrant.Organization);
Assert.AreEqual("345 Park Avenue", record.Registrant.Address[0]);
Assert.AreEqual("San Jose", record.Registrant.Address[1]);
Assert.AreEqual("California", record.Registrant.Address[2]);
Assert.AreEqual("95110", record.Registrant.Address[3]);
Assert.AreEqual("US", record.Registrant.Address[4]);
Assert.AreEqual("+1.4085366000", record.Registrant.TelephoneNumber);
Assert.AreEqual("", record.Registrant.TelephoneNumberExt);
Assert.AreEqual("", record.Registrant.FaxNumber);
Assert.AreEqual("", record.Registrant.FaxNumberExt);
Assert.AreEqual("*****@*****.**", record.Registrant.Email);
Assert.AreEqual("Domain Administrator", record.AdminContact.Name);
Assert.AreEqual("Adobe Inc.", record.AdminContact.Organization);
Assert.AreEqual("345 Park Avenue", record.AdminContact.Address[0]);
Assert.AreEqual("San Jose", record.AdminContact.Address[1]);
Assert.AreEqual("California", record.AdminContact.Address[2]);
Assert.AreEqual("95110", record.AdminContact.Address[3]);
Assert.AreEqual("US", record.AdminContact.Address[4]);
Assert.AreEqual("+1.4085366000", record.AdminContact.TelephoneNumber);
Assert.AreEqual("", record.AdminContact.TelephoneNumberExt);
Assert.AreEqual("", record.AdminContact.FaxNumber);
Assert.AreEqual("", record.AdminContact.FaxNumberExt);
Assert.AreEqual("*****@*****.**", record.AdminContact.Email);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.Name);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.Organization);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.Address[0]);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.Address[1]);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.Address[2]);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.Address[3]);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.Address[4]);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.TelephoneNumber);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.TelephoneNumberExt);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.FaxNumber);
Assert.AreEqual("REDACTED FOR PRIVACY", record.TechnicalContact.FaxNumberExt);
Assert.AreEqual("*****@*****.**", record.TechnicalContact.Email);
Assert.AreEqual(7, record.NameServers.Count);
Assert.AreEqual("a1-217.akam.net", record.NameServers[0]);
Assert.AreEqual("a10-64.akam.net", record.NameServers[1]);
Assert.AreEqual("a13-65.akam.net", record.NameServers[2]);
Assert.AreEqual("a26-66.akam.net", record.NameServers[3]);
Assert.AreEqual("a28-67.akam.net", record.NameServers[4]);
Assert.AreEqual("a7-64.akam.net", record.NameServers[5]);
Assert.AreEqual("adobe-dns-01.adobe.com", record.NameServers[6]);
Assert.AreEqual("Unsigned Delegation", record.DnsSecStatus);
Assert.AreEqual("*****@*****.**", record.Registrar.AbuseEmail);
Assert.AreEqual("+44.2074218250", record.Registrar.AbuseTelephoneNumber);
}
public Task <LookupState> Visit(LookupState record)
{
record.Response = new WhoisResponse(fakeContent);
return(Task.FromResult(record));
}