public override DnsRecordBase Answer(DnsQuestion question)
{
if (pattern.IsMatch(question.Name))
return new CNameRecord(question.Name, 1, this.canonicalName);
return null;
}
private List<DnsRecordBase> ForwardQuery(DnsQuestion question)
{
List<DnsRecordBase> result = new List<DnsRecordBase>();
state_.Logger.Debug("Ask the DNS server. Name: {0}, Type: {1}, Class: {2}", question.Name, question.RecordType, question.RecordClass);
DnsMessage answer = state_.Dns.Resolve(question.Name, question.RecordType, question.RecordClass);
if(answer == null)
{
state_.Logger.Debug("No answer");
return null;
}
foreach(DnsRecordBase record in answer.AnswerRecords)
{
state_.Logger.Information("{0}", record);
result.Add(record);
}
foreach(DnsRecordBase record in answer.AdditionalRecords)
{
state_.Logger.Information("{0}", record);
result.Add(record);
}
return result;
}
public override DnsRecordBase Answer(DnsQuestion question)
{
if (pattern.IsMatch(question.Name))
return new ARecord(question.Name, 1, this.ipAddress);
return null;
}
private void ProcessQuestion(DnsMessage message, DnsQuestion dnsQuestion)
{
var dnsRequest = new DnsRequest() { Name = dnsQuestion.Name, Type = dnsQuestion.RecordType.ToString() };
var result = dnsResolver.Resolve(dnsRequest);
if (result.DnsEntry == null)
{
message.ReturnCode = ReturnCode.NxDomain;
return;
}
message.AnswerRecords.Add(new ARecord(dnsRequest.Name, 3600, IPAddress.Parse(result.DnsEntry.IpV4)));
}
public void ResolveMapOnlyTest()
{
var resolver = new DotBitResolver(mockResolveDns, new dotBitNs.Server.DotBitResolver.LookupDomainValueRootHandler(mockLookupDotBit));
var q = new DnsQuestion("nx.bit", RecordType.Any, RecordClass.Any);
string expectedA = "178.248.244.15";
var answer = resolver.GetAnswer(q);
Assert.IsInstanceOfType(answer.AnswerRecords.First(), typeof(ARecord));
ARecord a = answer.AnswerRecords.First() as ARecord;
Assert.AreEqual(expectedA, a.Address.ToString());
}
/// <summary>
/// Create a new cache entry.
/// </summary>
public CacheEntry(DnsQuestion question, DnsRecordBase[] records, int ttl)
{
Since = DateTime.UtcNow;
Question = question;
foreach (var record in records)
{
// Override the TTL
record.TimeToLive = ttl > 0 ? ttl : int.MaxValue;
}
Records = records;
}
public void ResolveRootTest()
{
var resolver = new DotBitResolver(mockResolveDns, new dotBitNs.Server.DotBitResolver.LookupDomainValueRootHandler(mockLookupDotBit));
var qRoot = new DnsQuestion("json1.bit", RecordType.Any, RecordClass.Any);
var answer = resolver.GetAnswer(qRoot);
var expectedRootName = "json1.bit";
var expectedRootAddress = IPAddress.Parse(ip);
Assert.IsInstanceOfType(answer.AnswerRecords.First(), typeof(ARecord));
Assert.AreEqual(expectedRootName, answer.AnswerRecords.First().Name);
Assert.AreEqual(expectedRootAddress, ((ARecord)answer.AnswerRecords.First()).Address);
}
/// <summary>
/// Compares source with target to see if it matches.
/// </summary>
public static bool IsEqualTo(this DnsQuestion source, DnsQuestion target)
{
if (source == target)
{
return true;
}
if (source == null || target == null)
{
return false;
}
return source.Name == target.Name && source.RecordClass == target.RecordClass &&
source.RecordType == target.RecordType;
}
private DnsMessage InternalGetAnswer(DnsQuestion question)
{
DnsMessage answer = ResolveDotBitAddress(question);
if (answer == null)
{
// send query to upstream server
answer = DnsResolve(question.Name, question.RecordType, question.RecordClass);
}
return answer;
}
internal List<DnsRecordBase> ProcessQuery(DnsQuestion question)
{
IPAddress ip = null;
if(state_.Config.Dns.CatchAll)
ip = CatchAllProcessQuery(question);
else
{
Interception interception = state_.Config.GetInterception(question.Name);
if(interception == null)
{
state_.Logger.Debug("No interception for '{0}' found", question.Name);
return null;
}
ip = GetIp(interception);
}
if(null == ip)
{
state_.Logger.Information("No IP found for '{0}'", question.Name);
return null;
}
List<DnsRecordBase> result = new List<DnsRecordBase>();
state_.Logger.Information("DNS {1} {0} TTL {2}", ip, question.Name, state_.Config.Dns.AnswerTtl);
result.Add(new ARecord(question.Name, state_.Config.Dns.AnswerTtl, ip));
return result;
}
private List<DnsRecordBase> ProcessQuestion(DnsQuestion question)
{
if(!intercept_)
return null;
switch(question.RecordType)
{
case RecordType.A:
return processAQuery_.ProcessQuery(question);
case RecordType.Aaaa:
//records = processAaaaQuery_.ProcessQuery(question);
break;
default:
break;
}
return null;
}
public abstract DnsRecordBase Answer(DnsQuestion question);
private DnsMessage GetDotBitAnswerForName(DnsQuestion question, string name)
{
try
{
recursionLevel++;
if (recursionLevel > maxRecursion)
{
ConsoleUtils.WriteWarning("Max recursion reached");
return null;
}
DomainValue value = GetDomainValue(name);
if (value == null)
return null;
value.ImportDefaultMap();
DnsMessage answer = null;
//TODO: delegate not implemented
if (!string.IsNullOrWhiteSpace(value.@Delegate))
ConsoleUtils.WriteWarning("delegate setting not implemented: {0}", value.Import);
//TODO: import not implemented
if (!string.IsNullOrWhiteSpace(value.Import))
ConsoleUtils.WriteWarning("import setting not implemented: {0}", value.Import);
if (value.Alias != null)
{
string newLookup;
if (value.Alias.EndsWith(".")) // absolute
{
newLookup = value.Alias;
}
else // sub domain
{
newLookup = value.Alias + '.';
}
DnsQuestion newQuestion = new DnsQuestion(value.Alias, question.RecordType, question.RecordClass);
return InternalGetAnswer(newQuestion);
}
answer = new DnsMessage()
{
Questions = new List<DnsQuestion>() { question }
};
bool any = question.RecordType == RecordType.Any;
var nsnames = value.Ns;
if (nsnames != null && nsnames.Count() > 0) // NS overrides all
{
List<IPAddress> nameservers = GetDotBitNameservers(nsnames);
if (nameservers.Count() > 0)
{
var client = new DnsClient(nameservers, 2000);
if (!string.IsNullOrWhiteSpace(value.Translate))
name = value.Translate;
answer = client.Resolve(name, question.RecordType, question.RecordClass);
}
}
else
{
if (any || question.RecordType == RecordType.A)
{
var addresses = value.Ips;
if (addresses.Count() > 0)
foreach (var address in addresses)
answer.AnswerRecords.Add(new ARecord(name, 60, address));
}
if (any || question.RecordType == RecordType.Aaaa)
{
var addresses = value.Ip6s;
if (addresses.Count() > 0)
foreach (var address in addresses)
answer.AnswerRecords.Add(new AaaaRecord(name, 60, address));
}
}
return answer;
}
finally
{
recursionLevel--;
}
}
private IPAddress CatchAllProcessQuery(DnsQuestion question)
{
// If there is an interception configured, take it
Interception interception = state_.Config.GetInterception(question.Name);
if(interception != null)
return GetIp(interception);
return state_.AllocateIP(question.Name);
}
public InfiniteForwardingException(DnsQuestion question)
{
Question = question;
}
private List<IPAddress> GetDotBitNameservers(IEnumerable<string> nsnames)
{
List<IPAddress> nameservers = new List<IPAddress>();
foreach (var ns in nsnames)
{
IPAddress ip;
if (IPAddress.TryParse(ns, out ip))
nameservers.Add(ip);
else
{
var nsQuestion = new DnsQuestion(ns, RecordType.A, RecordClass.Any);
var nsAnswer = InternalGetAnswer(nsQuestion);
if (nsAnswer != null && nsAnswer.AnswerRecords.Any(m => m.RecordType == RecordType.A && m is ARecord))
{
IPAddress nsip = nsAnswer.AnswerRecords.Where(m => m.RecordType == RecordType.A).Cast<ARecord>().First().Address;
nameservers.Add(nsip);
}
}
}
return nameservers;
}
private DnsRecordBase[] ApplyRemaps(DnsQuestion question)
{
var records = new List<DnsRecordBase>();
foreach (var entry in Configuration.Where(c => c.Key.Equals("remap", StringComparison.InvariantCultureIgnoreCase)))
{
// FORMAT: <filter> <class> <type> <value>
string[] parts = entry.Value.Split(new[] {' '}, 4);
if (parts.Length != 4)
{
// Invalid rule
continue;
}
string remapFilter = parts[0];
string remapClass = parts[1];
string remapType = parts[2];
string remapValue = parts[3];
// See if we got a match
if (Glob.Match(question.Name, remapFilter)
&& (question.RecordClass == RecordClass.Any || (question.RecordClass.ToString().Equals(remapClass, StringComparison.InvariantCultureIgnoreCase)))
&& (question.RecordType == RecordType.Any || (question.RecordType.ToString().Equals(remapType, StringComparison.InvariantCultureIgnoreCase))))
{
IPAddress ipaddress = null;
switch (remapType.ToUpper())
{
case "A":
if (!IPAddress.TryParse(remapValue, out ipaddress))
{
// Invalid argument
continue;
}
records.Add(new ARecord(question.Name, Configuration.RemapTtl, ipaddress));
break;
case "MX":
ushort priority = 0;
if (remapValue.Contains(" "))
{
ushort.TryParse(remapValue.Split(' ')[0], out priority);
}
records.Add(new MxRecord(question.Name, Configuration.RemapTtl, priority, remapValue.Split(' ')[0]));
break;
case "NS":
records.Add(new NsRecord(question.Name, Configuration.RemapTtl, remapValue.Trim()));
break;
}
}
}
return records.ToArray();
}
private FilterAction ApplyFilters(DnsQuestion question)
{
// Default : Proxy
FilterAction result = FilterAction.Proxy;
foreach (var entry in Configuration.Where(c => c.Key.StartsWith("filter-", StringComparison.InvariantCultureIgnoreCase)))
{
switch(entry.Key.ToLower())
{
case "filter-proxy":
if (Glob.Match(question.Name, entry.Value ))
{
result = FilterAction.Proxy;
}
break;
case "filter-reject":
if (Glob.Match(question.Name, entry.Value))
{
result = FilterAction.Reject;
}
break;
case "filter-skip-proxy":
if (Glob.Match(question.Name, entry.Value))
{
result = FilterAction.SkipProxy;
}
break;
}
}
return result;
}
public void ResolveSubdomainsTest()
{
var resolver = new DotBitResolver(mockResolveDns, new dotBitNs.Server.DotBitResolver.LookupDomainValueRootHandler(mockLookupDotBit));
var qWww = new DnsQuestion("www.json1.bit", RecordType.Any, RecordClass.Any);
var answer = resolver.GetAnswer(qWww);
var expectedWwwName = "json1.com.";
var expectedWwwAddress = dnsMockRecords[expectedWwwName];
Assert.IsNotNull(answer);
Assert.IsInstanceOfType(answer.AnswerRecords.First(), typeof(ARecord));
Assert.AreEqual(expectedWwwName, answer.AnswerRecords.First().Name);
Assert.AreEqual(expectedWwwAddress, ((ARecord)answer.AnswerRecords.First()).Address);
}
private DnsMessage ResolveDotBitAddress(DnsQuestion question)
{
string name = question.Name;
return GetDotBitAnswerForName(question, name);
}
private void ParseQuestions(byte[] resultData, ref int currentPosition, int recordCount)
{
for (int i = 0; i < recordCount; i++)
{
DnsQuestion question = new DnsQuestion { Name = ParseDomainName(resultData, ref currentPosition), RecordType = (RecordType) ParseUShort(resultData, ref currentPosition), RecordClass = (RecordClass) ParseUShort(resultData, ref currentPosition) };
_questions.Add(question);
}
}
public DnsMessage GetAnswer(DnsQuestion question)
{
lock (lockResolver)
return InternalGetAnswer(question);
}
