public DnsResponse Get(DnsRequest request)
{
ushort requestID = request.RequestID;
DnsResponse response = null;
try
{
using (DnsClient client = new DnsClient(m_serverIP))
{
if (m_timeout != null)
{
client.Timeout = m_timeout.Value;
}
response = client.Resolve(request);
}
}
finally
{
if (response != null)
{
response.RequestID = requestID;
}
request.RequestID = requestID;
}
return response;
}
DnsResponse ProcessRequest(DnsRequest request)
{
DnsStandard.RecordType questionType = request.Question.Type;
DnsResponse response = new DnsResponse(request);
response.Header.IsAuthoritativeAnswer = true;
switch (response.Question.Type)
{
default:
throw new DnsServerException(DnsStandard.ResponseCode.NotImplemented);
case DnsStandard.RecordType.ANAME:
ProcessANAMEQuestion(response);
break;
case DnsStandard.RecordType.NS:
ProcessNSQuestion(response);
break;
case DnsStandard.RecordType.MX:
ProcessMXQuestion(response);
break;
case DnsStandard.RecordType.SOA:
ProcessSOAQuestion(response);
break;
case DnsStandard.RecordType.CERT:
ProcessCERTQuestion(response);
break;
case DnsStandard.RecordType.CNAME:
ProcessCNAMEQuestion(response);
break;
}
return response;
}
public DnsRequest ReceiveRequest()
{
DnsBuffer responseBuffer = this.ReceiveBuffer();
DnsRequest request = new DnsRequest(responseBuffer.CreateReader());
Assert.True(!string.IsNullOrEmpty(request.Question.Domain));
return request;
}
DnsResponse CreateResponse(DnsRequest request, IEnumerable<DnsResourceRecord> matches)
{
DnsStandard.RecordType questionType = request.Question.Type;
DnsResponse response = new DnsResponse(request);
int matchCount = 0;
foreach (DnsResourceRecord record in matches)
{
if (record.Type == questionType)
{
++matchCount;
switch (record.Type)
{
default:
response.AnswerRecords.Add(record);
break;
case DnsStandard.RecordType.NS:
case DnsStandard.RecordType.SOA:
response.AnswerRecords.Add(record);
break;
}
}
}
if (matchCount == 0)
{
throw new DnsServerException(DnsStandard.ResponseCode.NameError);
}
return response;
}
/// <summary>
/// Convenience method resolving and returning SOA RRs.
/// </summary>
/// <param name="domain">
/// The domain name to resolve.
/// </param>
/// <returns>
/// An enumeration of SOA Records. See <see cref="SOARecord"/>
/// </returns>
public IEnumerable <SOARecord> ResolveSOA(string domain)
{
DnsResponse response = this.Resolve(DnsRequest.CreateSOA(domain));
if (response != null)
{
if (response.HasNameServerRecords)
{
return(response.NameServerRecords.SOA);
}
if (response.HasAnswerRecords)
{
return(response.AnswerRecords.SOA);
}
}
return(null);
}
public DnsResponse Get(DnsRequest request)
{
if (request == null)
{
throw new ArgumentNullException();
}
DnsQuestion question = request.Question;
if (question == null || question.Class != DnsStandard.Class.IN)
{
throw new DnsServerException(DnsStandard.ResponseCode.NotImplemented);
}
DnsResponse response = this.ProcessRequest(request);
//
// Usually need some post-processing on the response
//
return this.ProcessResponse(response);
}
public DnsResponse Get(DnsRequest request)
{
if (request == null)
{
throw new ArgumentNullException();
}
DnsQuestion question = request.Question;
if (question == null || question.Class != DnsStandard.Class.IN)
{
return null;
}
IEnumerable<DnsResourceRecord> matches = m_records[request.Question.Domain];
if (matches == null)
{
return null;
}
return this.CreateResponse(request, matches);
}
public DnsResponse ProcessRequest(DnsRequest request)
{
if (request == null)
{
throw new ArgumentNullException();
}
this.Received.SafeInvoke(request);
DnsResponse response = null;
try
{
this.Validate(request);
response = m_store.Get(request);
if (response == null || !response.IsSuccess)
{
throw new DnsServerException(DnsStandard.ResponseCode.NameError);
}
this.FixupTTL(response);
}
catch (DnsProtocolException)
{
response = this.ProcessError(request, DnsStandard.ResponseCode.FormatError);
}
catch (DnsServerException serverEx)
{
response = this.ProcessError(request, serverEx.ResponseCode);
}
catch(Exception ex)
{
this.HandleException(ex);
response = this.ProcessError(request, DnsStandard.ResponseCode.ServerFailure);
}
this.Responding.SafeInvoke(response);
return response;
}
/// <summary>
/// Handle the DNS query.
/// </summary>
public DnsResponse Get(DnsRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
DnsQuestion question = request.Question;
if (question == null || question.Class != DnsStandard.Class.IN)
{
throw new DnsServerException(DnsStandard.ResponseCode.NotImplemented);
}
/* Don't handle NS and SOA record recursilvey since these are retrieved from the primary
* DNS servers and are cached. So, we would always end up retrieving the cached values
* from the primary DNS servers. */
if (request.Question.Type != DnsStandard.RecordType.ANAME &&
request.Question.Type != DnsStandard.RecordType.CERT &&
request.Question.Type != DnsStandard.RecordType.CNAME &&
request.Question.Type != DnsStandard.RecordType.MX)
{
throw new DnsServerException(DnsStandard.ResponseCode.NotImplemented);
}
DnsResponse response = ProcessRequest(request);
return response;
}
static IEnumerable<SRVRecord> RequestSrv(DnsClient client, string domain)
{
var dnsRequest = new DnsRequest(DnsStandard.RecordType.SRV, domain);
var response = client.Resolve(dnsRequest);
if (response == null || !response.HasAnswerRecords)
{
return null;
}
return response.AnswerRecords.SRV
.OrderBy(r => r.Priority)
.OrderByDescending(r => r.Weight);
}
public DnsResponse Get(DnsRequest request)
{
long requestNumber = System.Threading.Interlocked.Increment(ref m_requestCount);
if (this.SuccessInterval <= 0 || (requestNumber % this.SuccessInterval) != 0)
{
if (this.ThrowDnsException)
{
throw new DnsServerException(ErrorCode);
}
throw new InvalidOperationException();
}
return m_innerStore.Get(request);
}
protected void Validate(DnsRequest request)
{
request.Validate();
if (request.Header.QuestionCount < 1)
{
throw new DnsProtocolException(DnsProtocolError.InvalidQuestionCount);
}
if (request.Header.QuestionCount > this.Settings.MaxQuestionCount)
{
throw new DnsServerException(DnsStandard.ResponseCode.Refused);
}
}
void SerializeRequest(DnsRequest request)
{
m_requestBuffer.Clear();
request.Serialize(m_requestBuffer);
}
public void Send(DnsRequest request)
{
DnsBuffer requestBuffer = new DnsBuffer();
request.Serialize(requestBuffer);
this.SendBuffer(requestBuffer);
}
/// <summary>
/// overrides base resolve method to provide cache funcationality at time of resolution
/// </summary>
/// <param name="request"></param>
/// <returns>DnsResponse containing the results either pulled from cache or manually resolved</returns>
public override DnsResponse Resolve(DnsRequest request)
{
//----------------------------------------------------------------------------------------------------
//---check to see if the item is in the cache
DnsResponse dr = m_cache.Get(request);
if (dr != null)
{
return dr;
}
//----------------------------------------------------------------------------------------------------
//---item as not found in cache, try to get it from the base class
dr = base.Resolve(request);
if (dr != null)
{
//----------------------------------------------------------------------------------------------------
//---if found store in the cache for future use
//---Potential for negative caching here
m_cache.Put(dr);
}
return dr;
}
DnsResponse ProcessRequest(DnsRequest request)
{
IEnumerable<IPAddress> nameServers = GetNameServers(request.Question.Domain);
if (nameServers == null)
{
throw new DnsServerException(DnsStandard.ResponseCode.NameError);
}
bool useUdp = request.Question.Type == DnsStandard.RecordType.CERT ? false : true;
int count = 0;
DnsResponse response = null;
foreach (IPAddress nameserver in nameServers)
{
DnsClient client = null;
try
{
if (m_doCache)
{
client = new DnsClientWithCache(new IPEndPoint(nameserver, m_dnsResolutionPort));
}
else
{
client = new DnsClient(new IPEndPoint(nameserver, m_dnsResolutionPort));
}
client.Timeout = Timeout;
client.UseUDPFirst = useUdp;
DnsRequest newRequest = new DnsRequest(new DnsQuestion(request.Question));
response = client.Resolve(newRequest);
if (response != null)
{
// Clone the response before returning it since the response may be cached
// and we don't want the cached response to be modified.
response = response.Clone();
// updates the TTL of records to reflect the elapsed time since the
// record was cached.
response.UpdateRecordsTTL();
break;
}
}
catch (DnsException)
{
continue;
}
finally
{
if (client != null)
{
client.Dispose();
}
}
count++;
if (count > m_maxNameServersToAttempt)
{
break;
}
}
if (response == null)
{
throw new DnsServerException(DnsStandard.ResponseCode.ServerFailure);
}
response.RequestID = request.RequestID;
return response;
}
/// <summary>
/// Resolves a DNS Request and returns a DnsResponse response instance.
/// </summary>
/// <param name="request">
/// The DNS Request to resolve. See <see cref="DnsRequest"/>
/// </param>
/// <returns>
/// A DNS Response instance representing the response. See <see cref="DnsResponse"/>
/// </returns>
/// <exception cref="DnsException">Thrown for network failure (e.g. max retries exceeded) or badly formed responses.</exception>
public virtual DnsResponse Resolve(DnsRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Validate();
request.RequestID = this.NextID();
this.SerializeRequest(request);
bool useUDPFirst = this.UseUDPFirst;
int attempt = 0;
int maxAttempts = this.m_maxRetries + 1;
while (attempt < maxAttempts)
{
attempt++;
try
{
if (useUDPFirst)
{
this.ExecuteUDP();
}
else
{
this.ExecuteTCP();
}
DnsResponse response = this.DeserializeResponse();
response.Validate();
if (request.RequestID != response.RequestID || !response.Question.Equals(request.Question))
{
// Hmm. Not a response to any query we'd sent.
// Could be a spoof, a server misbehaving, or some other socket (UDP) oddity (delayed message etc)
// If this is TCP, then this should not happen and we will hit max attempts and stop
// Ignore and retry
continue;
}
if (response.IsNameError)
{
return response;
}
if (!response.IsSuccess)
{
throw new DnsServerException(response.Header.ResponseCode);
}
if (!response.Header.IsTruncated)
{
return response;
}
useUDPFirst = false;
}
catch(DnsServerException se)
{
//
// Server failures deserve a retry
//
if (se.ResponseCode != DnsStandard.ResponseCode.ServerFailure)
{
throw;
}
}
catch(DnsProtocolException pe)
{
//
// Random failures also deserve a retry
//
if (pe.Error != DnsProtocolError.Failed)
{
throw;
}
}
catch(DnsException)
{
throw;
}
catch(Exception error)
{
//
// Typically, a socket exception or network error...
//
if (attempt >= maxAttempts)
{
throw;
}
this.NotifyError(error);
}
this.CloseUdpSocket();
if (m_postFailurePause != null)
{
System.Threading.Thread.Sleep(m_postFailurePause.Value);
}
}
throw new DnsProtocolException(DnsProtocolError.MaxAttemptsReached, Server.Address);
}
void OnTcpRequest(DnsRequest request)
{
if (m_logger.IsTraceEnabled)
{
m_logger.Debug(this.Summarize("TCP", request));
}
else if (m_logger.IsDebugEnabled)
{
m_logger.Info("TCP Request {0} {1}", request.Question.Domain, request.Question.Type);
}
}
DnsResponse ProcessError(DnsRequest request, DnsStandard.ResponseCode code)
{
DnsResponse errorResponse = new DnsResponse(request);
errorResponse.Header.ResponseCode = code;
return errorResponse;
}
string Summarize(string type, DnsRequest request)
{
using (StringWriter writer = new StringWriter())
{
writer.WriteLine();
writer.Write(type);
writer.WriteLine(" Request");
DnsRecordPrinter printer = new DnsRecordPrinter(writer);
printer.Print(request);
return writer.ToString();
}
}
private void Resolve(DnsRequest request)
{
DnsResponse matches = m_client.Resolve(request);
Assert.NotNull(matches);
Assert.True(matches.HasAnswerRecords, string.Format("{0}:{1}", request.Question.Type, request.Question.Domain));
}
/// <summary>
/// Initialize a response to the given request
/// </summary>
public void Init(DnsRequest request)
{
if (request == null)
{
throw new ArgumentNullException();
}
this.RequestID = request.RequestID;
this.Header.IsRecursionDesired = request.Header.IsRecursionDesired;
this.Header.IsRequest = false;
this.Question = request.Question;
}
/// <summary>
/// Resolves a DNS Request and returns a DnsResponse response instance.
/// </summary>
/// <param name="request">
/// The DNS Request to resolve. See <see cref="DnsRequest"/>
/// </param>
/// <returns>
/// A DNS Response instance representing the response. See <see cref="DnsResponse"/>
/// </returns>
/// <exception cref="DnsException">Thrown for network failure (e.g. max retries exceeded) or badly formed responses.</exception>
public virtual DnsResponse Resolve(DnsRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Validate();
request.RequestID = this.NextID();
this.SerializeRequest(request);
bool useUDPFirst = this.UseUDPFirst;
int attempt = 0;
int maxAttempts = this.m_maxRetries + 1;
while (attempt < maxAttempts)
{
attempt++;
try
{
if (useUDPFirst)
{
this.ExecuteUDP();
}
else
{
this.ExecuteTCP();
}
DnsResponse response = this.DeserializeResponse();
response.Validate();
if (request.RequestID != response.RequestID || !response.Question.Equals(request.Question))
{
// Hmm. Not a response to any query we'd sent.
// Could be a spoof, a server misbehaving, or some other socket (UDP) oddity (delayed message etc)
// If this is TCP, then this should not happen and we will hit max attempts and stop
// Ignore and retry
continue;
}
if (response.IsNameError)
{
return(response);
}
if (!response.IsSuccess)
{
throw new DnsServerException(response.Header.ResponseCode);
}
if (!response.Header.IsTruncated)
{
return(response);
}
useUDPFirst = false;
}
catch (DnsServerException se)
{
//
// Server failures deserve a retry
//
if (se.ResponseCode != DnsStandard.ResponseCode.ServerFailure)
{
throw;
}
}
catch (DnsProtocolException pe)
{
//
// Random failures also deserve a retry
//
if (pe.Error != DnsProtocolError.Failed)
{
throw;
}
}
catch (DnsException)
{
throw;
}
catch (Exception error)
{
//
// Typically, a socket exception or network error...
//
if (attempt >= maxAttempts)
{
throw;
}
this.NotifyError(error);
}
this.CloseUdpSocket();
if (m_postFailurePause != null)
{
System.Threading.Thread.Sleep(m_postFailurePause.Value);
}
}
throw new DnsProtocolException(DnsProtocolError.MaxAttemptsReached, Server.Address);
}
/// <summary>
/// Construct a response to a request
/// </summary>
/// <param name="request"></param>
public DnsResponse(DnsRequest request)
: base()
{
this.Init(request);
}
void SerializeRequest(DnsRequest request)
{
m_requestBuffer.Clear();
request.Serialize(m_requestBuffer);
}
/// <summary>
/// Construct a response to a request
/// </summary>
/// <param name="request"></param>
public DnsResponse(DnsRequest request)
: base()
{
this.Init(request);
}
