public void SendLength(ushort count)
{
DnsBuffer lengthBuffer = new DnsBuffer(2);
lengthBuffer.AddUshort(count);
m_socket.Send(lengthBuffer.Buffer, lengthBuffer.Count, SocketFlags.None);
}
public void Send(DnsRequest request)
{
DnsBuffer requestBuffer = new DnsBuffer();
request.Serialize(requestBuffer);
this.SendBuffer(requestBuffer);
}
public void Send(DnsResponse response)
{
DnsBuffer buffer = new DnsBuffer();
response.Serialize(buffer);
this.SendBuffer(buffer);
}
public void SendLength(ushort length)
{
DnsBuffer buffer = new DnsBuffer(2);
buffer.AddUshort(length);
this.Send(buffer.Buffer);
}
/// <summary>
/// simple method to get the bytes from a given DnsResourceRecord
/// </summary>
/// <param name="record">DnsResourceRecord instance</param>
/// <returns>byte[] representation the DnsResourceRecord instance</returns>
protected byte[] GetBytesFromRecord(DnsResourceRecord record)
{
DnsBuffer buff = new DnsBuffer();
record.Serialize(buff);
return(buff.Buffer);
}
public DnsResponse ProcessRequest(DnsBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException();
}
return(this.ProcessRequest(this.DeserializeRequest(buffer.Buffer, buffer.Count)));
}
public DnsBuffer ReceiveBuffer()
{
ushort length = this.ReceiveLength();
DnsBuffer buffer = this.ReceiveBuffer(length);
Assert.True(buffer.Count == length);
return(buffer);
}
public DnsRequest ReceiveRequest()
{
DnsBuffer responseBuffer = this.ReceiveBuffer();
DnsRequest request = new DnsRequest(responseBuffer.CreateReader());
Assert.True(!string.IsNullOrEmpty(request.Question.Domain));
return(request);
}
public DnsResourceRecord Receive()
{
DnsBuffer responseBuffer = this.ReceiveBuffer();
DnsResponse response = new DnsResponse(responseBuffer.CreateReader());
Assert.True(response.AnswerRecords.Count != 0);
return(response.AnswerRecords[0]);
}
public ushort ReceiveLength()
{
DnsBuffer lengthBuffer = new DnsBuffer(2);
lengthBuffer.Count = m_socket.Receive(lengthBuffer.Buffer, 2, SocketFlags.None);
DnsBufferReader reader = lengthBuffer.CreateReader();
return(reader.ReadUShort());
}
public void Send(DnsBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException();
}
this.Socket.SendTo(buffer.Buffer, buffer.Count, SocketFlags.None, this.RemoteEndPoint);
}
/// <summary>
/// Writes this RR in DNS wire format to the <paramref name="buffer"/>
/// </summary>
/// <param name="buffer">The buffer to which DNS wire data are written</param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddDomainName(m_mname);
buffer.AddDomainName(m_rname);
buffer.AddInt(this.SerialNumber);
buffer.AddInt(this.Refresh);
buffer.AddInt(this.Retry);
buffer.AddInt(this.Expire);
buffer.AddInt(this.Minimum);
}
T Roundtrip <T>(T record)
where T : DnsResourceRecord
{
DnsBuffer buffer = new DnsBuffer(1024);
record.Serialize(buffer);
DnsBufferReader reader = buffer.CreateReader();
return((T)DnsResourceRecord.Deserialize(ref reader));
}
protected void Serialize(DnsResponse response, DnsBuffer buffer, int maxResponse)
{
buffer.Clear();
response.Serialize(buffer);
if (buffer.Count > maxResponse)
{
response.Truncate();
buffer.Clear();
response.Serialize(buffer);
}
}
/// <summary>
/// Receive bytes into the given buffer
/// </summary>
/// <param name="buffer"></param>
/// <param name="count"></param>
public void Receive(DnsBuffer buffer, int count)
{
if (buffer == null)
{
throw new ArgumentNullException();
}
buffer.Clear();
buffer.ReserveCapacity(count);
if (!base.Receive(buffer.Buffer, count))
{
throw new DnsServerException(DnsStandard.ResponseCode.Refused);
}
buffer.Count = count;
}
public void CreateAResponseDumps(string domain)
{
DnsBuffer buff = new DnsBuffer(DnsStandard.MaxUdpMessageLength * 2);
m_client.Resolve(DnsRequest.CreateA(domain)).Serialize(buff);
byte[] bytes = buff.CreateReader().ReadBytes();
string path = Path.Combine(DnsResponsePath, string.Format("aname.{0}.bin", domain)).Replace("www.", "");
Console.WriteLine("Creating {0}", path);
using (FileStream s = new FileStream(path, FileMode.OpenOrCreate)){
s.Write(bytes
, 0
, bytes.Length);
s.Close();
}
}
internal void Serialize(DnsBuffer buffer)
{
buffer.AddUshort(UniqueID);
buffer.AddByte((byte)((this.IsRequest ? 0x00 : 0x80) |
((byte)OpCode << 3) |
(this.IsAuthoritativeAnswer ? 0x04 : 0x00) |
(this.IsTruncated ? 0x02 : 0x00) |
(this.IsRecursionDesired ? 0x01 : 0x00)));
buffer.AddByte((byte)((this.IsRecursionAvailable ? 0x80 : 0x00) | (byte)this.ResponseCode));
buffer.AddShort(this.QuestionCount);
buffer.AddShort(this.AnswerCount);
buffer.AddShort(this.NameServerAnswerCount);
buffer.AddShort(this.AdditionalAnswerCount);
}
public DnsBuffer ReceiveBuffer(ushort length)
{
DnsBuffer buffer = new DnsBuffer(length);
int countRead = 0;
while (buffer.Count < length)
{
countRead = m_socket.Receive(buffer.Buffer, buffer.Count, Math.Min(this.ReceiveChunk, length - buffer.Count), SocketFlags.None);
if (countRead <= 0)
{
break;
}
buffer.Count += countRead;
}
return(buffer);
}
public void SendBuffer(DnsBuffer buffer)
{
// Send size first
this.SendLength((ushort)buffer.Count);
int sendChunk = buffer.Count;
if (this.SendChunk > 0)
{
sendChunk = Math.Min(this.SendChunk, buffer.Count / 2);
}
int countSent = 0;
while (countSent < buffer.Count)
{
int countToSend = Math.Min(sendChunk, buffer.Count - countSent);
countSent += m_socket.Send(buffer.Buffer, countSent, countToSend, SocketFlags.None);
}
Assert.True(countSent == buffer.Count);
}
/// <summary>
/// Serializes the raw record
/// </summary>
/// <param name="buffer"></param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddBytes(m_bytes);
}
public DnsUdpContext()
{
m_buffer = new DnsBuffer(DnsStandard.MaxUdpMessageLength);
}
/// <summary>
/// Serialize the CName record
/// </summary>
/// <param name="buffer"></param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddDomainName(m_name);
}
/// <summary>
/// Writes this RR in DNS wire format to the <paramref name="buffer"/>
/// </summary>
/// <param name="buffer">The buffer to which DNS wire data are written</param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddDomainName(m_nameserver);
}
/// <summary>
/// Writes this RR in DNS wire format to the <paramref name="buffer"/>
/// </summary>
/// <param name="buffer">The buffer to which DNS wire data are written</param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddDomainName(m_mname);
buffer.AddDomainName(m_rname);
buffer.AddInt(this.SerialNumber);
buffer.AddInt(this.Refresh);
buffer.AddInt(this.Retry);
buffer.AddInt(this.Expire);
buffer.AddInt(this.Minimum);
}
public void CreateDnsResourceRecords(string domain)
{
DnsBuffer buff = new DnsBuffer();
byte[] bytes;
AddressRecord arec = new AddressRecord(domain
, "127.0.0.1")
{
TTL = 1000
};
arec.Serialize(buff);
string path = Path.Combine(DNSRECORDSEPATH, string.Format("aname.{0}.bin", domain));
Console.WriteLine("Creating {0}", path);
using (FileStream s = new FileStream(path, FileMode.OpenOrCreate))
{
s.Write(buff.Buffer
, 0
, buff.Buffer.Length);
s.Close();
}
//----------------------------------------------------------------------------------------------------
//---read the stream from the bytes
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
Console.WriteLine("checking [{0}]", path);
bytes = new BinaryReader(fs).ReadBytes((int)new FileInfo(path).Length);
DnsBufferReader rdr = new DnsBufferReader(bytes, 0, bytes.Length);
arec = (AddressRecord)DnsResourceRecord.Deserialize(ref rdr);
}
Console.WriteLine(arec.IPAddress);
Console.WriteLine(arec.TTL);
Console.WriteLine(arec.Name);
//----------------------------------------------------------------------------------------------------------------
SOARecord soa = new SOARecord(domain
, domain + ".dom"
, "somebody"
, 1
, 2
, 3
, 4
, 5)
{
TTL = 2000
};
buff = new DnsBuffer();
soa.Serialize(buff);
path = Path.Combine(DNSRECORDSEPATH, string.Format("soa.{0}.bin", domain));
Console.WriteLine("Creating {0}", path);
using (FileStream s = new FileStream(path, FileMode.OpenOrCreate))
{
s.Write(buff.Buffer
, 0
, buff.Buffer.Length);
s.Close();
}
//----------------------------------------------------------------------------------------------------
//---read the stream from the bytes
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
Console.WriteLine("checking [{0}]", path);
bytes = new BinaryReader(fs).ReadBytes((int)new FileInfo(path).Length);
DnsBufferReader rdr = new DnsBufferReader(bytes, 0, bytes.Length);
soa = (SOARecord)DnsResourceRecord.Deserialize(ref rdr);
}
Console.WriteLine(soa.ResponsibleName);
Console.WriteLine(soa.SerialNumber);
Console.WriteLine(soa.Retry);
Console.WriteLine(soa.Refresh);
Console.WriteLine(soa.Expire);
Console.WriteLine(soa.Minimum);
Console.WriteLine(soa.TTL);
Console.WriteLine(soa.Name);
//----------------------------------------------------------------------------------------------------------------
MXRecord mx = new MXRecord(domain
, string.Format("mx.{0}", domain)
, 1)
{
TTL = 2000
};
buff = new DnsBuffer();
mx.Serialize(buff);
path = Path.Combine(DNSRECORDSEPATH, string.Format("mx.{0}.bin", domain));
Console.WriteLine("Creating {0}", path);
using (FileStream s = new FileStream(path, FileMode.OpenOrCreate))
{
s.Write(buff.Buffer
, 0
, buff.Buffer.Length);
s.Close();
}
//----------------------------------------------------------------------------------------------------
//---read the stream from the bytes
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
Console.WriteLine("checking [{0}]", path);
bytes = new BinaryReader(fs).ReadBytes((int)new FileInfo(path).Length);
DnsBufferReader rdr = new DnsBufferReader(bytes, 0, bytes.Length);
mx = (MXRecord)DnsResourceRecord.Deserialize(ref rdr);
}
Console.WriteLine(mx.Exchange);
Console.WriteLine(mx.Name);
Console.WriteLine(mx.Preference);
//----------------------------------------------------------------------------------------------------------------
//---create the cert on the fly
CertRecord cert = new CertRecord(new DnsX509Cert(CreateNamedKeyCertificate(new CertData(domain
, domain
, string.Format("CN={0}", domain)
, ""))))
{
TTL = 2000
};
buff = new DnsBuffer();
cert.Serialize(buff);
path = Path.Combine(DNSRECORDSEPATH, string.Format("cert.{0}.bin", domain));
Console.WriteLine("Creating {0}", path);
using (FileStream s = new FileStream(path, FileMode.OpenOrCreate))
{
s.Write(buff.Buffer
, 0
, buff.Buffer.Length);
s.Close();
}
//----------------------------------------------------------------------------------------------------
//---read the stream from the bytes
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
Console.WriteLine("checking [{0}]", path);
bytes = new BinaryReader(fs).ReadBytes((int)new FileInfo(path).Length);
DnsBufferReader rdr = new DnsBufferReader(bytes, 0, bytes.Length);
cert = (CertRecord)DnsResourceRecord.Deserialize(ref rdr);
}
Console.WriteLine(cert.Name);
Console.WriteLine(cert.Cert.Certificate.NotBefore);
Console.WriteLine(cert.Cert.Certificate.NotAfter);
}
/// <summary>
/// Serializes the raw record
/// </summary>
/// <param name="buffer"></param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddBytes(m_bytes);
}
/// <summary>
/// Writes this RR in DNS wire format to the <paramref name="buffer"/>
/// </summary>
/// <param name="buffer">The buffer to which DNS wire data are written</param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddShort(this.Preference);
buffer.AddDomainName(m_exchange);
}
internal void Serialize(DnsBuffer buffer)
{
buffer.AddUshort(UniqueID);
buffer.AddByte((byte)((this.IsRequest ? 0x00 : 0x80) |
((byte)OpCode << 3) |
(this.IsAuthoritativeAnswer ? 0x04 : 0x00) |
(this.IsTruncated ? 0x02 : 0x00) |
(this.IsRecursionDesired ? 0x01 : 0x00)));
buffer.AddByte((byte)((this.IsRecursionAvailable ? 0x80 : 0x00) | (byte) this.ResponseCode));
buffer.AddShort(this.QuestionCount);
buffer.AddShort(this.AnswerCount);
buffer.AddShort(this.NameServerAnswerCount);
buffer.AddShort(this.AdditionalAnswerCount);
}
/// <summary>
/// Writes this RR in DNS wire format to the <paramref name="buffer"/>
/// </summary>
/// <param name="buffer">The buffer to which DNS wire data are written</param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddShort(this.Preference);
buffer.AddDomainName(m_exchange);
}
/// <summary>
/// Create a new processing context.
/// This constructor can also be used to build contexts for pooling
/// </summary>
/// <param name="server"></param>
public DnsTcpContext()
{
m_buffer = new DnsBuffer(DnsStandard.MaxUdpMessageLength);
m_sizeBuffer = new DnsBuffer(2);
}
