/// <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> /// 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> /// 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> /// 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> /// 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> /// 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); }
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); } }