public DNSResource(string aName, [DefaultParameterValue(DNSClass.Internet)] DNSClass aClass, [DefaultParameterValue(false)] bool aClearCache, [DefaultParameterValue((ushort) 120)] ushort aTTL)
{
this.fName = aName;
this.fClass = aClass;
this.fClearCache = aClearCache;
this.fTTL = aTTL;
}
/// <summary>
/// Construit un éléments de requête/réponse DNS avec la définition de tous les éléments
/// </summary>
/// <param name="name">Nom de la requête</param>
/// <param name="dnsType">Type de requête/réponse</param>
/// <param name="dnsClass">Classe de requête/réponse</param>
public DNSQuestion(string name, string dnsType, DNSClass dnsClass)
{
Name = name;
switch (dnsType)
{
case "ALL":
Type = 0xFF;
break;
case "AXFR":
Type = 0xFC;
break;
case "MAILB":
Type = 0xFD;
break;
case "MAILA":
Type = 0xFE;
break;
default:
Type = (ushort)ResourceDetailsLoader.Invoke(DNSServiceName[dnsType], "Service");
break;
}
Class = dnsClass;
}
/// <summary>
/// Construit un éléments de requête/réponse DNS avec la définition de tous les éléments
/// </summary>
/// <param name="name">Nom de la requête</param>
/// <param name="dnsType">Type de requête/réponse</param>
/// <param name="dnsClass">Classe de requête/réponse</param>
public DNSResourceRecord(DNSRequest dnsrequest, string name, ushort dnsType, DNSClass dnsClass)
{
Name = name;
Type = dnsType;
Class = dnsClass;
TimeToLive = 0;
}
public static DNSResource ReadFrom(BinaryReader aSrc)
{
DNSResource resource;
string str = DNSPacket.ParseName(aSrc, aSrc.BaseStream);
DNSType aType = (DNSType)DNSPacket.N2H(aSrc.ReadUInt16());
DNSClass class2 = (DNSClass)DNSPacket.N2H(aSrc.ReadUInt16());
bool flag = false;
if (0 != (((ushort)class2) & 0x8000))
{
flag = true;
}
class2 &= (DNSClass)(-32769);
uint num = DNSPacket.N2H(aSrc.ReadUInt32());
ushort num2 = DNSPacket.N2H(aSrc.ReadUInt16());
byte[] aData = aSrc.ReadBytes((int)num2);
DNSType type2 = aType;
if (type2 == DNSType.A)
{
resource = new DNSARecord();
}
else if (type2 == DNSType.AAAA)
{
resource = new DNSAAAARecord();
}
else if (type2 == DNSType.PTR)
{
resource = new DNSPTRRecord();
}
else if (type2 == DNSType.NS)
{
resource = new DNSNSRecord();
}
else if (type2 == DNSType.TXT)
{
resource = new DNSTXTRecord();
}
else if (type2 == DNSType.CNAME)
{
resource = new DNSCNameRecord();
}
else if (type2 == DNSType.SRV)
{
resource = new DNSSRVRecord();
}
else
{
resource = new DNSUnknownRecord(aType);
}
resource.fName = str;
resource.fParseTime = DateTime.UtcNow;
resource.fClass = class2;
resource.fClearCache = flag;
resource.fTTL = (ushort)num;
resource.BodyReadFrom(aData, aSrc.BaseStream);
return(resource);
}
public DNSEntry(string name, DNSType type, DNSClass cls)
{
this.Key = name.ToLower();
this.Name = name;
this.Type = type;
this.Class = cls & DNSClass.MASK;
this.Unique = (cls & DNSClass.UNIQUE) != 0;
}
private static DNSRRBase ReadResourceRecord(byte[] data, DataReader reader)
{
DNSRRBase rr = null;
string name = ReadString(data, reader);
DNSType type = (DNSType)reader.ReadUInt16(false);
DNSClass cls = (DNSClass)reader.ReadUInt16(false);
uint ttl = reader.ReadUInt32(false);
ushort rlen = reader.ReadUInt16(false);
byte[] rdata = reader.ReadBytes(rlen);
switch (type)
{
case DNSType.CNAME:
{
CNameDNSRR newRec = new CNameDNSRR(data, rdata);
rr = newRec;
}
break;
case DNSType.A:
{
ADNSRR aRec = new ADNSRR(rdata);
rr = aRec;
}
break;
case DNSType.AAAA:
{
AAAADNSRR aRec = new AAAADNSRR(rdata);
rr = aRec;
}
break;
case DNSType.PTR:
{
PTRDNSRR aRec = new PTRDNSRR(data, rdata);
rr = aRec;
}
break;
default:
{
UnknownDNSRR newRec = new UnknownDNSRR();
newRec.RData = rdata;
rr = newRec;
}
break;
}
rr.Name = name;
rr.Class = cls;
rr.Type = type;
rr.TimeToLive = ttl;
return(rr);
}
public DNSService(String name, DNSType type, DNSClass cls, uint ttl,
ushort priority, ushort weight, ushort port, string server)
: base(name, type, cls, ttl)
{
this.Priority = priority;
this.Weight = weight;
this.Port = port;
this.Server = server;
}
public static string GetClass(DNSClass cls)
{
string ret;
if (!Mapping.ClassType.TryGetValue(cls, out ret))
{
ret = String.Format("?({0})", (int)cls);
}
return(ret);
}
public void ReadFrom(BinaryReader aSrc)
{
this.fName = DNSPacket.ParseName(aSrc, aSrc.BaseStream);
this.fType = (DNSType)DNSPacket.N2H(aSrc.ReadUInt16());
ushort num = DNSPacket.N2H(aSrc.ReadUInt16());
if (0 != (num & 0x8000))
{
this.fClearCache = true;
}
this.fClass = ((DNSClass)num) & ((DNSClass)(-32769));
}
public void BeginRequest(DNSClass cl, DNSType type, string name, bool clearcache, Action<DNSResource> action)
{
DNSQuestion q= new DNSQuestion();
q.Class = cl;
q.ClearCache = clearcache;
if (!name.EndsWith("."))
name += "."; // domain names technically end with a .
q.Name = name;
q.Type = type;
BeginRequest(q, action);
}
public void BeginRequest(DNSClass cl, DNSType type, string name, bool clearcache, Action <DNSResource> action)
{
DNSQuestion q = new DNSQuestion();
q.Class = cl;
q.ClearCache = clearcache;
if (!name.EndsWith("."))
{
name += "."; // domain names technically end with a .
}
q.Name = name;
q.Type = type;
BeginRequest(q, action);
}
public DNSTXTRecord(string aName, DNSClass aClass, bool aClearCache, ushort aTTL)
: base(aName, aClass, aClearCache, aTTL)
{
}
public DNSHinfo(String name, DNSType type, DNSClass cls, uint ttl, String cpu, String os)
: base(name, type, cls, ttl)
{
this.CPU = cpu;
this.OS = cpu;
}
/// <summary>
/// Gets an entry by details
/// </summary>
/// <returns><c>DNSEntry</c> if entry is found, <c>null</c> otherwise</returns>
/// <param name="name">Name.</param>
/// <param name="type">Type.</param>
/// <param name="cls">Cls.</param>
public DNSEntry GetByDetails(string name, DNSType type, DNSClass cls)
{
DNSEntry entry = new DNSEntry(name, type, cls);
return(Get(entry));
}
public DNSText(String name, DNSType type, DNSClass cls, uint ttl, byte[] text)
: base(name, type, cls, ttl)
{
this.Text = text;
}
public DNSRecord(String name, DNSType type, DNSClass cls, uint ttl) : base(name, type, cls)
{
this.TTL = ttl;
this.Created = Utilities.CurrentTimeMilliseconds();
}
public DNSQuestion(String name, DNSType type, DNSClass cls) : base(name, type, cls)
{
}
public DNSPointer(String name, DNSType type, DNSClass cls, uint ttl, String alias)
: base(name, type, cls, ttl)
{
this.Alias = alias;
}
/// <summary>
/// Construit un éléments de requête/réponse DNS avec la définition de tous les éléments
/// </summary>
/// <param name="name">Nom de la requête</param>
/// <param name="dnsType">Type de requête/réponse</param>
/// <param name="dnsClass">Classe de requête/réponse</param>
public DNSQuestion(string name, ushort dnsType, DNSClass dnsClass)
{
Name = name;
Type = dnsType;
Class = dnsClass;
}
/// <summary>
/// Lit le flux sous-jacent
/// </summary>
public override void Read(DNSRequest request)
{
name = request.ReadDNSName();
Type = request.ReadShort();
Class = (DNSClass)request.ReadShort();
}
public DNSAAAARecord(string aName, DNSClass aClass, bool aClearCache, ushort aTTL)
: base(aName, aClass, aClearCache, aTTL)
{
}
public DNSAddress(String name, DNSType type, DNSClass cls, uint ttl,
byte[] address)
: base(name, type, cls, ttl)
{
this.Address = address;
}
public DNSResource(string aName, [DefaultParameterValue(DNSClass.Internet)] DNSClass aClass, [DefaultParameterValue(false)] bool aClearCache, [DefaultParameterValue((ushort)120)] ushort aTTL)
{
this.fName = aName;
this.fClass = aClass;
this.fClearCache = aClearCache;
this.fTTL = aTTL;
}
public void ReadFrom(BinaryReader aSrc)
{
this.fName = DNSPacket.ParseName(aSrc, aSrc.BaseStream);
this.fType = (DNSType)DNSPacket.N2H(aSrc.ReadUInt16());
ushort num = DNSPacket.N2H(aSrc.ReadUInt16());
if (0 != (num & 0x8000))
{
this.fClearCache = true;
}
this.fClass = ((DNSClass)num) & ((DNSClass)(-32769));
}
