/// <summary>
/// Deserialize the record from the give buffer
/// </summary>
/// <param name="buffer">buffer containing dns info</param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddUshort(this.Priority);
buffer.AddUshort(this.Weight);
buffer.AddUshort(this.Port);
buffer.AddDomainName(m_target);
}
/// <summary>
/// Serialize this DnsResourceRecord into a byte array, as per the DNS RFC
/// </summary>
/// <returns>buffer containing serialized record</returns>
public byte[] Serialize()
{
DnsBuffer buff = new DnsBuffer();
this.Serialize(buff);
return(buff.Buffer);
}
/// <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.AddUshort((ushort)m_certType);
buffer.AddUshort(m_keyTag);
buffer.AddByte(m_algorithm);
buffer.AddBytes(m_certData);
}
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();
}
internal void Serialize(DnsBuffer buffer)
{
for (int i = 0, count = this.Count; i < count; ++i)
{
this[i].Serialize(buffer);
}
}
public DnsResponse ProcessRequest(DnsBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException();
}
return this.ProcessRequest(this.DeserializeRequest(buffer.Buffer, buffer.Count));
}
internal void Serialize(DnsBuffer buffer)
{
buffer.AddDomainName(this.Name);
buffer.AddShort((short)this.Type);
buffer.AddShort((short)this.Class);
buffer.AddInt(this.TTL);
buffer.AddShort(this.RecordDataLength);
}
/// <summary>
/// Serialize this Dns Message into the given DnsBuffer
/// </summary>
/// <param name="buffer">buffer to serialize into</param>
public virtual void Serialize(DnsBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
m_header.Serialize(buffer);
m_question.Serialize(buffer);
}
/// <summary>
/// Clone this DnsResponse.
/// </summary>
public DnsResponse Clone()
{
DnsBuffer buffer = new DnsBuffer(DnsStandard.MaxUdpMessageLength);
this.Serialize(buffer);
DnsResponse newResponse = new DnsResponse(buffer.CreateReader());
newResponse.TTLOrigin = this.TTLOrigin;
return(newResponse);
}
/// <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)
{
foreach (string text in this.m_strings)
{
if (text.Length > byte.MaxValue)
{
throw new DnsProtocolException(DnsProtocolError.StringTooLong);
}
buffer.AddByte((byte)text.Length);
buffer.AddChars(text);
}
}
/// <summary>
/// Creates a DnsClient instance specifying an IPEndPoint representation of the IP address and port and
/// specifying the timeout and buffer size to use.
/// </summary>
/// <param name="server">
/// A <see cref="IPEndPoint"/>
/// </param>
/// <param name="timeout">
/// Timeout value.
/// </param>
/// <param name="maxUdpBufferSize">
/// Maximum buffer size to use for UDP communication.
/// </param>
public DnsClient(IPEndPoint server, TimeSpan timeout, int maxUdpBufferSize)
{
if (server == null)
{
throw new ArgumentNullException("server");
}
this.m_dnsServer = server;
m_lengthBuffer = new DnsBuffer(2);
m_requestBuffer = new DnsBuffer(1024);
m_responseBuffer = new DnsBuffer(maxUdpBufferSize);
this.Timeout = timeout;
this.UseUDPFirst = true;
m_requestIDGenerator = new Random();
}
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;
}
/// <summary>
/// Serialize this DnsResourceRecord into the given buffer, as per the DNS RFC
/// </summary>
/// <param name="buffer">buffer to write into</param>
public void Serialize(DnsBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
m_header.Serialize(buffer);
int headerSize = buffer.Count;
int recordLengthOffset = headerSize - sizeof(short);
this.SerializeRecordData(buffer);
this.RecordDataLength = (short)(buffer.Count - headerSize);
buffer.Buffer[recordLengthOffset++] = (byte)((short)this.RecordDataLength >> 8);
buffer.Buffer[recordLengthOffset] = ((byte)(this.RecordDataLength));
}
/// <summary>
/// Serialize this DnsResponse to the buffer as DNS wire format data.
/// </summary>
/// <param name="buffer">The buffer to which to serialize</param>
public override void Serialize(DnsBuffer buffer)
{
this.UpdateAnswerCountsInHeader();
base.Serialize(buffer);
if (this.HasAnswerRecords)
{
this.AnswerRecords.Serialize(buffer);
}
if (this.HasNameServerRecords)
{
this.NameServerRecords.Serialize(buffer);
}
if (this.HasAdditionalRecords)
{
this.AdditionalRecords.Serialize(buffer);
}
}
/// <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.AddUint(this.Address);
}
public void Send(DnsRequest request)
{
DnsBuffer requestBuffer = new DnsBuffer();
request.Serialize(requestBuffer);
this.SendBuffer(requestBuffer);
}
/// <summary>
/// Override to serialize record specific information
/// </summary>
/// <param name="buffer"></param>
protected virtual void SerializeRecordData(DnsBuffer buffer)
{
throw new NotSupportedException();
}
/// <summary>
/// Deserialize the record from the give buffer
/// </summary>
/// <param name="buffer">buffer containing dns info</param>
protected override void SerializeRecordData(DnsBuffer buffer)
{
buffer.AddUshort(this.Priority);
buffer.AddUshort(this.Weight);
buffer.AddUshort(this.Port);
buffer.AddDomainName(m_target);
}
/// <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 SendLength(ushort length)
{
DnsBuffer buffer = new DnsBuffer(2);
buffer.AddUshort(length);
this.Send(buffer.Buffer);
}
/// <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.AddUint(this.Address);
}
/// <summary>
/// Serialize this DnsResourceRecord into a byte array, as per the DNS RFC
/// </summary>
/// <returns>buffer containing serialized record</returns>
public byte[] Serialize()
{
DnsBuffer buff = new DnsBuffer();
this.Serialize(buff);
return buff.Buffer;
}
public void SendLength(ushort count)
{
DnsBuffer lengthBuffer = new DnsBuffer(2);
lengthBuffer.AddUshort(count);
m_socket.Send(lengthBuffer.Buffer, lengthBuffer.Count, SocketFlags.None);
}
public void CreateCertResponseDumps(string domain)
{
DnsBuffer buff = new DnsBuffer(DnsStandard.MaxUdpMessageLength * 2);
m_client.Resolve(DnsRequest.CreateCERT(domain)).Serialize(buff);
byte[] bytes = buff.CreateReader().ReadBytes();
string path = Path.Combine(DnsResponsePath, string.Format("cert.{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.AddDomainName(this.Domain);
buffer.AddShort((short)Type);
buffer.AddShort((short)Class);
}
/// <summary>
/// Override to serialize record specific information
/// </summary>
/// <param name="buffer"></param>
protected virtual void SerializeRecordData(DnsBuffer buffer)
{
throw new NotSupportedException();
}
/// <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.AddUshort((ushort) m_certType);
buffer.AddUshort(m_keyTag);
buffer.AddByte(m_algorithm);
buffer.AddBytes(m_certData);
}
public void Send(DnsResponse response)
{
DnsBuffer buffer = new DnsBuffer();
response.Serialize(buffer);
this.SendBuffer(buffer);
}
/// <summary>
/// Serialize this DnsResponse to the buffer as DNS wire format data.
/// </summary>
/// <param name="buffer">The buffer to which to serialize</param>
public override void Serialize(DnsBuffer buffer)
{
this.UpdateAnswerCountsInHeader();
base.Serialize(buffer);
if (this.HasAnswerRecords)
{
this.AnswerRecords.Serialize(buffer);
}
if (this.HasNameServerRecords)
{
this.NameServerRecords.Serialize(buffer);
}
if (this.HasAdditionalRecords)
{
this.AdditionalRecords.Serialize(buffer);
}
}
/// <summary>
/// Clone this DnsResponse.
/// </summary>
public DnsResponse Clone()
{
DnsBuffer buffer = new DnsBuffer(DnsStandard.MaxUdpMessageLength);
this.Serialize(buffer);
DnsResponse newResponse = new DnsResponse(buffer.CreateReader());
newResponse.TTLOrigin = this.TTLOrigin;
return newResponse;
}
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);
}
public DnsUdpContext()
{
m_buffer = new DnsBuffer(DnsStandard.MaxUdpMessageLength);
}
/// <summary>
/// Serialize this Dns Message into the given DnsBuffer
/// </summary>
/// <param name="buffer">buffer to serialize into</param>
public virtual void Serialize(DnsBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
m_header.Serialize(buffer);
m_question.Serialize(buffer);
}
/// <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);
}
/// <summary>
/// Serialize this DnsResourceRecord into the given buffer, as per the DNS RFC
/// </summary>
/// <param name="buffer">buffer to write into</param>
public void Serialize(DnsBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
m_header.Serialize(buffer);
int headerSize = buffer.Count;
int recordLengthOffset = headerSize - sizeof(short);
this.SerializeRecordData(buffer);
this.RecordDataLength = (short) (buffer.Count - headerSize);
buffer.Buffer[recordLengthOffset++] = (byte) ((short) this.RecordDataLength >> 8);
buffer.Buffer[recordLengthOffset] = ((byte)(this.RecordDataLength));
}
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);
}
internal void Serialize(DnsBuffer buffer)
{
buffer.AddDomainName(this.Name);
buffer.AddShort((short) this.Type);
buffer.AddShort((short) this.Class);
buffer.AddInt(this.TTL);
buffer.AddShort(this.RecordDataLength);
}
/// <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)
{
foreach(string text in this.m_strings)
{
if (text.Length > byte.MaxValue)
{
throw new DnsProtocolException(DnsProtocolError.StringTooLong);
}
buffer.AddByte((byte) text.Length);
buffer.AddChars(text);
}
}
public void Send(DnsBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException();
}
this.Socket.SendTo(buffer.Buffer, buffer.Count, SocketFlags.None, this.RemoteEndPoint);
}
/// <summary>
/// Creates a DnsClient instance specifying an IPEndPoint representation of the IP address and port and
/// specifying the timeout and buffer size to use.
/// </summary>
/// <param name="server">
/// A <see cref="IPEndPoint"/>
/// </param>
/// <param name="timeout">
/// Timeout value.
/// </param>
/// <param name="maxUdpBufferSize">
/// Maximum buffer size to use for UDP communication.
/// </param>
public DnsClient(IPEndPoint server, TimeSpan timeout, int maxUdpBufferSize)
{
if (server == null)
{
throw new ArgumentNullException("server");
}
this.m_dnsServer = server;
m_lengthBuffer = new DnsBuffer(2);
m_requestBuffer = new DnsBuffer(1024);
m_responseBuffer = new DnsBuffer(maxUdpBufferSize);
this.Timeout = timeout;
this.UseUDPFirst = true;
m_requestIDGenerator = new Random();
}
internal void Serialize(DnsBuffer buffer)
{
buffer.AddDomainName(this.Domain);
buffer.AddShort((short)Type);
buffer.AddShort((short)Class);
}
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);
}
}
