/** * <summary>Creates a response from the parameter fields with RData being * a memory chunk. This is for MDns which supports caching</summary> * <param name="Name">The name resolved.</param> * <param name="Type">The query type.</param> * <param name="Class">The network type.</param> * <param name="CacheFlush">Flush the dns cache in the client.</param> * <param name="Ttl">How long to hold the result in the local dns cache.</param> * <param name="RData">RData in String format.</param> */ public Response(string name, DnsPacket.Types type, DnsPacket.Classes class_type, bool cache_flush, int ttl, String rdata) { Name = name; Class = class_type; Ttl = ttl; Type = type; CacheFlush = cache_flush; RData = rdata; if (Type == DnsPacket.Types.A || Type == DnsPacket.Types.AAAA) { NameBlob = DnsPacket.HostnameStringToMemBlock(Name); RDataBlob = DnsPacket.IPStringToMemBlock(RData); } else if (Type == DnsPacket.Types.Ptr) { if (DnsPacket.StringIsIP(Name)) { NameBlob = DnsPacket.PtrStringToMemBlock(Name); } else { NameBlob = DnsPacket.HostnameStringToMemBlock(Name); } RDataBlob = DnsPacket.HostnameStringToMemBlock(RData); } else { throw new Exception("Invalid Query Type: " + Type + "!"); } RdLength = (short)RDataBlob.Length; // 2 for Type + 2 for Class + 4 for Ttl + 2 for RdLength byte[] data = new byte[10]; int idx = 0; data[idx++] = (byte)((((int)Type) >> 8) & 0xFF); data[idx++] = (byte)(((int)Type) & 0xFF); byte cf = 0x80; if (!CacheFlush) { cf = 0x00; } data[idx++] = (byte)(((((int)Class) >> 8) & 0x7F) | cf); data[idx++] = (byte)(((int)Class) & 0xFF); data[idx++] = (byte)((Ttl >> 24) & 0xFF); data[idx++] = (byte)((Ttl >> 16) & 0xFF); data[idx++] = (byte)((Ttl >> 8) & 0xFF); data[idx++] = (byte)(Ttl & 0xFF); data[idx++] = (byte)((RdLength >> 8) & 0xFF); data[idx] = (byte)(RdLength & 0xFF); _icpacket = new CopyList(NameBlob, MemBlock.Reference(data), RDataBlob); }
/// <summary>Look up a hostname given a Dns request in the form of IPPacket /// </summary> /// <param name="in_ip">An IPPacket containing the Dns request</param> /// <returns>An IPPacket containing the results</returns> public virtual IPPacket LookUp(IPPacket in_ip) { UdpPacket in_udp = new UdpPacket(in_ip.Payload); DnsPacket in_dns = new DnsPacket(in_udp.Payload); ICopyable out_dns = null; string qname = string.Empty; bool invalid_qtype = false; try { string qname_response = String.Empty; qname = in_dns.Questions[0].QName; DnsPacket.Types type = in_dns.Questions[0].QType; if(type == DnsPacket.Types.A || type == DnsPacket.Types.AAAA) { qname_response = AddressLookUp(qname); } else if(type == DnsPacket.Types.Ptr) { qname_response = NameLookUp(qname); } else { invalid_qtype = true; } if(qname_response == null) { throw new Exception("Unable to resolve"); } Response response = new Response(qname, in_dns.Questions[0].QType, in_dns.Questions[0].QClass, 1800, qname_response); //Host resolver will not accept if recursive is not available //when it is desired DnsPacket res_packet = new DnsPacket(in_dns.ID, false, in_dns.Opcode, true, in_dns.RD, in_dns.RD, in_dns.Questions, new Response[] {response}, null, null); out_dns = res_packet.ICPacket; } catch(Exception e) { bool failed_resolve = false; // The above resolver failed, let's see if another resolver works if(_forward_queries) { try { out_dns = Resolve(_name_server, (byte[]) in_dns.Packet); } catch(Exception ex) { e = ex; failed_resolve = true; } } if(!_forward_queries || failed_resolve) { ProtocolLog.WriteIf(IpopLog.Dns, "Failed to resolve: " + qname + "\n\t" + e.Message); out_dns = DnsPacket.BuildFailedReplyPacket(in_dns, !invalid_qtype); } } UdpPacket out_udp = new UdpPacket(in_udp.DestinationPort, in_udp.SourcePort, out_dns); return new IPPacket(IPPacket.Protocols.Udp, in_ip.DestinationIP, in_ip.SourceIP, out_udp.ICPacket); }
/** * <summary>Given a DnsPacket, it will generate a failure message so that * the local resolver can move on to the next nameserver without timeouting * on the this one.</summary> * <param name="Packet">The base packet to translate into a failed response * </param> */ public static MemBlock BuildFailedReplyPacket(DnsPacket Packet, bool refused_implemented) { byte[] res = new byte[Packet.Packet.Length]; Packet.Packet.CopyTo(res, 0); if (refused_implemented) { res[3] |= 5; } else { res[3] |= 4; } res[2] |= 0x80; return(MemBlock.Reference(res)); }
public void TestHostname() { String hostname = "yo-in-f104.google.com"; MemBlock hostnamem = MemBlock.Reference(new byte[] { 0x0a, 0x79, 0x6f, 0x2d, 0x69, 0x6e, 0x2d, 0x66, 0x31, 0x30, 0x34, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00 }); Assert.AreEqual(hostname, DnsPacket.HostnameMemBlockToString(hostnamem), "HostnameMemBlockToString"); Assert.AreEqual(hostnamem, DnsPacket.HostnameStringToMemBlock(hostname), "HostnameStringToMemBlock"); Assert.AreEqual(hostname, DnsPacket.HostnameMemBlockToString( DnsPacket.HostnameStringToMemBlock(hostname)), "Hostname String dual"); Assert.AreEqual(hostnamem, DnsPacket.HostnameStringToMemBlock( DnsPacket.HostnameMemBlockToString(hostnamem)), "Hostname MemBlock dual"); }
public void TestMDns() { MemBlock mdnsm = MemBlock.Reference(new byte[] { 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x12, 0x4c, 0x61, 0x70, 0x70, 0x79, 0x40, 0x64, 0x61, 0x76, 0x69, 0x64, 0x2d, 0x6c, 0x61, 0x70, 0x74, 0x6f, 0x70, 0x09, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00, 0x00, 0x21, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x14, 0xb2, 0x0c, 0x64, 0x61, 0x76, 0x69, 0x64, 0x2d, 0x6c, 0x61, 0x70, 0x74, 0x6f, 0x70, 0xc0, 0x2e, 0xc0, 0x0c, 0x00, 0x10, 0x80, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x5c, 0x04, 0x76, 0x63, 0x3d, 0x21, 0x09, 0x76, 0x65, 0x72, 0x3d, 0x32, 0x2e, 0x33, 0x2e, 0x31, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x3d, 0x6c, 0x69, 0x62, 0x70, 0x75, 0x72, 0x70, 0x6c, 0x65, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x3d, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x0e, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x32, 0x70, 0x6a, 0x3d, 0x35, 0x32, 0x39, 0x38, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x3d, 0x57, 0x6f, 0x6c, 0x69, 0x6e, 0x73, 0x6b, 0x79, 0x09, 0x31, 0x73, 0x74, 0x3d, 0x44, 0x61, 0x76, 0x69, 0x64, 0x09, 0x74, 0x78, 0x74, 0x76, 0x65, 0x72, 0x73, 0x3d, 0x31, 0x09, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x07, 0x5f, 0x64, 0x6e, 0x73, 0x2d, 0x73, 0x64, 0x04, 0x5f, 0x75, 0x64, 0x70, 0xc0, 0x2e, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc0, 0x1f, 0xc0, 0x1f, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc0, 0x0c, 0xc0, 0x45, 0x00, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x04, 0x0a, 0xe3, 0x38, 0x88 }); DnsPacket mdns = new DnsPacket(mdnsm); Assert.AreEqual(mdns.Questions.Length, 0, "Questions"); Assert.AreEqual(mdns.Answers.Length, 4, "Answers"); Assert.AreEqual(mdns.Authority.Length, 0, "Authority"); Assert.AreEqual(mdns.Additional.Length, 1, "Additional"); DnsPacket dnsp = new DnsPacket(mdns.ID, mdns.Query, mdns.Opcode, mdns.AA, mdns.RD, mdns.RA, null, mdns.Answers, null, mdns.Additional); Assert.AreEqual(mdnsm, dnsp.Packet, "Packet"); Assert.AreEqual(dnsp.Additional[0].Name, "david-laptop.local", "Name"); Assert.AreEqual(dnsp.Additional[0].Type, DnsPacket.Types.A, "Type"); Assert.AreEqual(dnsp.Additional[0].Class, DnsPacket.Classes.IN, "Class"); Assert.AreEqual(dnsp.Additional[0].CacheFlush, true, "CacheFlush"); Assert.AreEqual(dnsp.Additional[0].Ttl, 120, "Ttl"); Assert.AreEqual(dnsp.Additional[0].RData, "10.227.56.136", "RData"); }
public void TestPtr() { String ptr = "64.233.169.104"; MemBlock ptrm = MemBlock.Reference(new byte[] { 0x03, 0x31, 0x30, 0x34, 0x03, 0x31, 0x36, 0x39, 0x03, 0x32, 0x33, 0x33, 0x02, 0x36, 0x34, 0x07, 0x69, 0x6e, 0x2d, 0x61, 0x64, 0x64, 0x72, 0x04, 0x61, 0x72, 0x70, 0x61, 0x00 }); Assert.AreEqual(ptr, DnsPacket.PtrMemBlockToString(ptrm), "PtrMemBlockToString"); Assert.AreEqual(ptrm, DnsPacket.PtrStringToMemBlock(ptr), "PtrStringToMemBlock"); Assert.AreEqual(ptr, DnsPacket.PtrMemBlockToString( DnsPacket.PtrStringToMemBlock(ptr)), "Ptr String dual"); Assert.AreEqual(ptrm, DnsPacket.PtrStringToMemBlock( DnsPacket.PtrMemBlockToString(ptrm)), "Ptr MemBlock dual"); }
/** * <summary>Creates a response given the entire packet.</summary> * <remarks>The entire packet must be given, because some name servers take * advantage of pointers to reduce their size.</remarks> * <param name="Data">The entire Dns packet.</param> * <param name="Start">The starting position of the Response.</param> */ public Response(MemBlock Data, int Start) { int idx = 0; NameBlob = DnsPacket.RetrieveBlob(Data, Start, out idx); int type = (Data[idx++] << 8) + Data[idx++]; Type = (DnsPacket.Types)type; CacheFlush = ((Data[idx] & 0x80) == 0x80) ? true : false; int rclass = ((Data[idx++] << 8) & 0x7F) + Data[idx++]; Class = (DnsPacket.Classes)rclass; Ttl = (Data[idx++] << 24); Ttl |= (Data[idx++] << 16); Ttl |= (Data[idx++] << 8); Ttl |= (Data[idx++]); RdLength = (short)((Data[idx++] << 8) + Data[idx++]); RDataBlob = Data.Slice(idx, RdLength); if (Type == DnsPacket.Types.Ptr) { try { Name = DnsPacket.PtrMemBlockToString(NameBlob); } catch { Name = DnsPacket.HostnameMemBlockToString(NameBlob); } int End = 0; RDataBlob = DnsPacket.RetrieveBlob(Data, idx, out End); RData = DnsPacket.HostnameMemBlockToString(RDataBlob); } else if (Type == DnsPacket.Types.A) { Name = DnsPacket.HostnameMemBlockToString(NameBlob); RData = DnsPacket.IPMemBlockToString(RDataBlob); } _icpacket = _packet = Data.Slice(Start, idx + RdLength - Start); }
public void TestMDns0() { MemBlock mdnsm = MemBlock.Reference(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0E, 0x64, 0x61, 0x76, 0x69, 0x64, 0x69, 0x77, 0x2D, 0x6C, 0x61, 0x70, 0x74, 0x6F, 0x70, 0x05, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x00, 0x00, 0xFF, 0x00, 0x01, 0xC0, 0x0C, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x04, 0x0A, 0xFE, 0x00, 0x01 }); DnsPacket mdns = new DnsPacket(mdnsm); Assert.AreEqual(mdns.Questions.Length, 1, "Questions"); Assert.AreEqual(mdns.Answers.Length, 0, "Answers"); Assert.AreEqual(mdns.Authority.Length, 1, "Authority"); Assert.AreEqual(mdns.Additional.Length, 0, "Additional"); DnsPacket dnsp = new DnsPacket(mdns.ID, mdns.Query, mdns.Opcode, mdns.AA, mdns.RD, mdns.RA, mdns.Questions, mdns.Answers, mdns.Authority, mdns.Additional); Assert.AreEqual(dnsp.Authority[0].Name, "davidiw-laptop.local", "Name"); Assert.AreEqual(dnsp.Authority[0].Type, DnsPacket.Types.A, "Type"); Assert.AreEqual(dnsp.Authority[0].Class, DnsPacket.Classes.IN, "Class"); Assert.AreEqual(dnsp.Authority[0].CacheFlush, false, "CacheFlush"); Assert.AreEqual(dnsp.Authority[0].Ttl, 120, "Ttl"); Assert.AreEqual(dnsp.Authority[0].RData, "10.254.0.1", "RData"); Response old = mdns.Authority[0]; mdns.Authority[0] = new Response(old.Name, old.Type, old.Class, old.CacheFlush, old.Ttl, "10.254.111.252"); dnsp = new DnsPacket(mdns.ID, mdns.Query, mdns.Opcode, mdns.AA, mdns.RD, mdns.RA, mdns.Questions, mdns.Answers, mdns.Authority, mdns.Additional); Assert.AreEqual(dnsp.Authority[0].Name, "davidiw-laptop.local", "Name"); Assert.AreEqual(dnsp.Authority[0].Type, DnsPacket.Types.A, "Type"); Assert.AreEqual(dnsp.Authority[0].Class, DnsPacket.Classes.IN, "Class"); Assert.AreEqual(dnsp.Authority[0].CacheFlush, false, "CacheFlush"); Assert.AreEqual(dnsp.Authority[0].Ttl, 120, "Ttl"); Assert.AreEqual(dnsp.Authority[0].RData, "10.254.111.252", "RData"); }
public void TestIP() { String ip = "208.80.152.3"; MemBlock ipm = MemBlock.Reference(new byte[] { 0xd0, 0x50, 0x98, 0x03 }); Assert.AreEqual(ip, DnsPacket.IPMemBlockToString(ipm), "IPMemBlockToString"); Assert.AreEqual(ipm, DnsPacket.IPStringToMemBlock(ip), "IPStringToMemBlock"); Assert.AreEqual(ip, DnsPacket.IPMemBlockToString( DnsPacket.IPStringToMemBlock(ip)), "IP String dual"); Assert.AreEqual(ipm, DnsPacket.IPStringToMemBlock( DnsPacket.IPMemBlockToString(ipm)), "IP MemBlock dual"); String bad_ip = "Test.Test.Test.123"; MemBlock bad_ipm = null; try { bad_ipm = DnsPacket.IPStringToMemBlock(bad_ip); } catch {} Assert.AreEqual(null, bad_ipm, "Bad IP"); }
/** <summary>Constructor when creating a Dns Query</summary> <param name="QName">the name of resource you are looking up, IP Address when QType = Ptr otherwise hostname</param> <param name="QType"> the type of look up to perform</param> <param name="QClass">should always be IN</param> */ public Question(String QName, DnsPacket.Types QType, DnsPacket.Classes QClass) { this.QName = QName; this.QType = QType; this.QClass = QClass; if(QType == DnsPacket.Types.A || QType == DnsPacket.Types.AAAA) { QNameBlob = DnsPacket.HostnameStringToMemBlock(QName); } else if(QType == DnsPacket.Types.Ptr) { QNameBlob = DnsPacket.PtrStringToMemBlock(QName); } else { throw new Exception("Invalid QType: " + QType + "!"); } // 2 for QType + 2 for QClass byte[] data = new byte[4]; int idx = 0; data[idx++] = (byte) ((((int) QType) >> 8) & 0xFF); data[idx++] = (byte) (((int) QType) & 0xFF); data[idx++] = (byte) ((((int) QClass) >> 8) & 0xFF); data[idx++] = (byte) (((int) QClass) & 0xFF); _icpacket = new CopyList(QNameBlob, MemBlock.Reference(data)); }
/** * <summary>Constructor when parsing a Dns Query</summary> * <param name="Data"> must pass in the entire packet from where the question * begins, after parsing, can check Data.Length to find where next * container begins.</param> */ public Question(MemBlock Data, int Start) { int idx = 0; QNameBlob = DnsPacket.RetrieveBlob(Data, Start, out idx); int qtype = (Data[idx++] << 8) + Data[idx++]; QType = (DnsPacket.Types)qtype; int qclass = (Data[idx++] << 8) + Data[idx]; QClass = (DnsPacket.Classes)qclass; if (QType == DnsPacket.Types.A || QType == DnsPacket.Types.AAAA) { QName = DnsPacket.HostnameMemBlockToString(QNameBlob); } else if (QType == DnsPacket.Types.Ptr) { QName = DnsPacket.PtrMemBlockToString(QNameBlob); } _icpacket = _packet = Data.Slice(Start, idx + 1 - Start); }
/** <summary>Creates a response from the parameter fields with RData being a memory chunk. This is for MDns which supports caching</summary> <param name="Name">The name resolved.</param> <param name="Type">The query type.</param> <param name="Class">The network type.</param> <param name="CacheFlush">Flush the dns cache in the client.</param> <param name="Ttl">How long to hold the result in the local dns cache.</param> <param name="RData">RData in String format.</param> */ public Response(string name, DnsPacket.Types type, DnsPacket.Classes class_type, bool cache_flush, int ttl, String rdata) { Name = name; Class = class_type; Ttl = ttl; Type = type; CacheFlush = cache_flush; RData = rdata; if(Type == DnsPacket.Types.A) { NameBlob = DnsPacket.HostnameStringToMemBlock(Name); RDataBlob = DnsPacket.IPStringToMemBlock(RData); } else if(Type == DnsPacket.Types.Ptr) { if(DnsPacket.StringIsIP(Name)) { NameBlob = DnsPacket.PtrStringToMemBlock(Name); } else { NameBlob = DnsPacket.HostnameStringToMemBlock(Name); } RDataBlob = DnsPacket.HostnameStringToMemBlock(RData); } else { throw new Exception("Invalid Query Type: " + Type + "!"); } RdLength = (short) RDataBlob.Length; // 2 for Type + 2 for Class + 4 for Ttl + 2 for RdLength byte[] data = new byte[10]; int idx = 0; data[idx++] = (byte) ((((int) Type) >> 8) & 0xFF); data[idx++] = (byte) (((int) Type) & 0xFF); byte cf = 0x80; if(!CacheFlush) { cf = 0x00; } data[idx++] = (byte) (((((int) Class) >> 8) & 0x7F) | cf); data[idx++] = (byte) (((int) Class) & 0xFF); data[idx++] = (byte) ((Ttl >> 24) & 0xFF); data[idx++] = (byte) ((Ttl >> 16) & 0xFF); data[idx++] = (byte) ((Ttl >> 8) & 0xFF); data[idx++] = (byte) (Ttl & 0xFF); data[idx++] = (byte) ((RdLength >> 8) & 0xFF); data[idx] = (byte) (RdLength & 0xFF); _icpacket = new CopyList(NameBlob, MemBlock.Reference(data), RDataBlob); }
/** <summary>Creates a response from the parameter fields with RData being a memory chunk. This is for regular dns which has no notion of caching. </summary> <param name="Name">The name resolved.</param> <param name="Type">The query type.</param> <param name="Class">The network type.</param> <param name="CacheFlush">Flush the dns cache in the client.</param> <param name="Ttl">How long to hold the result in the local dns cache.</param> <param name="RData">RData in String format.</param> */ public Response(String Name, DnsPacket.Types Type, DnsPacket.Classes Class, int Ttl, String RData): this(Name, Type, Class, false, Ttl, RData) {}
public void TestPtrRPacketWithoutCompression() { int id = 55885; short ID = (short) id; bool Query = false; byte Opcode = 0; bool AA = false; String QName = "64.233.169.104"; DnsPacket.Types QType = DnsPacket.Types.Ptr; DnsPacket.Classes QClass = DnsPacket.Classes.IN; Question qp = new Question(QName, QType, QClass); String Name = "64.233.169.104"; DnsPacket.Types Type = DnsPacket.Types.Ptr; DnsPacket.Classes Class = DnsPacket.Classes.IN; int Ttl = 30; String RData = "yo-in-f104.google.com"; Response rp = new Response(Name, Type, Class, Ttl, RData); DnsPacket dp = new DnsPacket(ID, Query, Opcode, AA, false, false, new Question[] {qp}, new Response[] {rp}, null, null); MemBlock ptrm = MemBlock.Reference(new byte[] {0xda, 0x4d, 0x80, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x31, 0x30, 0x34, 0x03, 0x31, 0x36, 0x39, 0x03, 0x32, 0x33, 0x33, 0x02, 0x36, 0x34, 0x07, 0x69, 0x6e, 0x2d, 0x61, 0x64, 0x64, 0x72, 0x04, 0x61, 0x72, 0x70, 0x61, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x03, 0x31, 0x30, 0x34, 0x03, 0x31, 0x36, 0x39, 0x03, 0x32, 0x33, 0x33, 0x02, 0x36, 0x34, 0x07, 0x69, 0x6e, 0x2d, 0x61, 0x64, 0x64, 0x72, 0x04, 0x61, 0x72, 0x70, 0x61, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x17, 0x0a, 0x79, 0x6f, 0x2d, 0x69, 0x6e, 0x2d, 0x66, 0x31, 0x30, 0x34, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00}); DnsPacket dm = new DnsPacket(ptrm); Assert.AreEqual(dm.ID, ID, "ID"); Assert.AreEqual(dm.Query, Query, "Query"); Assert.AreEqual(dm.Opcode, Opcode, "Opcode"); Assert.AreEqual(dm.AA, AA, "AA"); Assert.AreEqual(dm.Questions.Length, 1, "Questions"); Assert.AreEqual(dm.Answers.Length, 1, "Answers"); Assert.AreEqual(dm.Packet, ptrm, "MemBlock"); Response rm = dm.Answers[0]; Assert.AreEqual(rm.Name, Name, "Name"); Assert.AreEqual(rm.Type, Type, "Type"); Assert.AreEqual(rm.Class, Class, "Class"); Assert.AreEqual(rm.Ttl, Ttl, "Ttl"); Assert.AreEqual(rm.RData, RData, "RData"); Question qm = dm.Questions[0]; Assert.AreEqual(qm.QName, Name, "QName"); Assert.AreEqual(qm.QType, Type, "QType"); Assert.AreEqual(qm.QClass, Class, "QClass"); Assert.AreEqual(dp.Packet, ptrm, "Dns Packet"); }
public void TestMDns0() { MemBlock mdnsm = MemBlock.Reference(new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0E, 0x64, 0x61, 0x76, 0x69, 0x64, 0x69, 0x77, 0x2D, 0x6C, 0x61, 0x70, 0x74, 0x6F, 0x70, 0x05, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x00, 0x00, 0xFF, 0x00, 0x01, 0xC0, 0x0C, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x04, 0x0A, 0xFE, 0x00, 0x01}); DnsPacket mdns = new DnsPacket(mdnsm); Assert.AreEqual(mdns.Questions.Length, 1, "Questions"); Assert.AreEqual(mdns.Answers.Length, 0, "Answers"); Assert.AreEqual(mdns.Authority.Length, 1, "Authority"); Assert.AreEqual(mdns.Additional.Length, 0, "Additional"); DnsPacket dnsp = new DnsPacket(mdns.ID, mdns.Query, mdns.Opcode, mdns.AA, mdns.RD, mdns.RA, mdns.Questions, mdns.Answers, mdns.Authority, mdns.Additional); Assert.AreEqual(dnsp.Authority[0].Name, "davidiw-laptop.local", "Name"); Assert.AreEqual(dnsp.Authority[0].Type, DnsPacket.Types.A, "Type"); Assert.AreEqual(dnsp.Authority[0].Class, DnsPacket.Classes.IN, "Class"); Assert.AreEqual(dnsp.Authority[0].CacheFlush, false, "CacheFlush"); Assert.AreEqual(dnsp.Authority[0].Ttl, 120, "Ttl"); Assert.AreEqual(dnsp.Authority[0].RData, "10.254.0.1", "RData"); Response old = mdns.Authority[0]; mdns.Authority[0] = new Response(old.Name, old.Type, old.Class, old.CacheFlush, old.Ttl, "10.254.111.252"); dnsp = new DnsPacket(mdns.ID, mdns.Query, mdns.Opcode, mdns.AA, mdns.RD, mdns.RA, mdns.Questions, mdns.Answers, mdns.Authority, mdns.Additional); Assert.AreEqual(dnsp.Authority[0].Name, "davidiw-laptop.local", "Name"); Assert.AreEqual(dnsp.Authority[0].Type, DnsPacket.Types.A, "Type"); Assert.AreEqual(dnsp.Authority[0].Class, DnsPacket.Classes.IN, "Class"); Assert.AreEqual(dnsp.Authority[0].CacheFlush, false, "CacheFlush"); Assert.AreEqual(dnsp.Authority[0].Ttl, 120, "Ttl"); Assert.AreEqual(dnsp.Authority[0].RData, "10.254.111.252", "RData"); }
public void TestMDns() { MemBlock mdnsm = MemBlock.Reference(new byte[] {0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x12, 0x4c, 0x61, 0x70, 0x70, 0x79, 0x40, 0x64, 0x61, 0x76, 0x69, 0x64, 0x2d, 0x6c, 0x61, 0x70, 0x74, 0x6f, 0x70, 0x09, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00, 0x00, 0x21, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x14, 0xb2, 0x0c, 0x64, 0x61, 0x76, 0x69, 0x64, 0x2d, 0x6c, 0x61, 0x70, 0x74, 0x6f, 0x70, 0xc0, 0x2e, 0xc0, 0x0c, 0x00, 0x10, 0x80, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x5c, 0x04, 0x76, 0x63, 0x3d, 0x21, 0x09, 0x76, 0x65, 0x72, 0x3d, 0x32, 0x2e, 0x33, 0x2e, 0x31, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x3d, 0x6c, 0x69, 0x62, 0x70, 0x75, 0x72, 0x70, 0x6c, 0x65, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x3d, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x0e, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x32, 0x70, 0x6a, 0x3d, 0x35, 0x32, 0x39, 0x38, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x3d, 0x57, 0x6f, 0x6c, 0x69, 0x6e, 0x73, 0x6b, 0x79, 0x09, 0x31, 0x73, 0x74, 0x3d, 0x44, 0x61, 0x76, 0x69, 0x64, 0x09, 0x74, 0x78, 0x74, 0x76, 0x65, 0x72, 0x73, 0x3d, 0x31, 0x09, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x07, 0x5f, 0x64, 0x6e, 0x73, 0x2d, 0x73, 0x64, 0x04, 0x5f, 0x75, 0x64, 0x70, 0xc0, 0x2e, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc0, 0x1f, 0xc0, 0x1f, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc0, 0x0c, 0xc0, 0x45, 0x00, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x04, 0x0a, 0xe3, 0x38, 0x88}); DnsPacket mdns = new DnsPacket(mdnsm); Assert.AreEqual(mdns.Questions.Length, 0, "Questions"); Assert.AreEqual(mdns.Answers.Length, 4, "Answers"); Assert.AreEqual(mdns.Authority.Length, 0, "Authority"); Assert.AreEqual(mdns.Additional.Length, 1, "Additional"); DnsPacket dnsp = new DnsPacket(mdns.ID, mdns.Query, mdns.Opcode, mdns.AA, mdns.RD, mdns.RA, null, mdns.Answers, null, mdns.Additional); Assert.AreEqual(mdnsm, dnsp.Packet, "Packet"); Assert.AreEqual(dnsp.Additional[0].Name, "david-laptop.local", "Name"); Assert.AreEqual(dnsp.Additional[0].Type, DnsPacket.Types.A, "Type"); Assert.AreEqual(dnsp.Additional[0].Class, DnsPacket.Classes.IN, "Class"); Assert.AreEqual(dnsp.Additional[0].CacheFlush, true, "CacheFlush"); Assert.AreEqual(dnsp.Additional[0].Ttl, 120, "Ttl"); Assert.AreEqual(dnsp.Additional[0].RData, "10.227.56.136", "RData"); }
public void TestPtrRPacketWithoutCompression() { int id = 55885; short ID = (short)id; bool Query = false; byte Opcode = 0; bool AA = false; String QName = "64.233.169.104"; DnsPacket.Types QType = DnsPacket.Types.Ptr; DnsPacket.Classes QClass = DnsPacket.Classes.IN; Question qp = new Question(QName, QType, QClass); String Name = "64.233.169.104"; DnsPacket.Types Type = DnsPacket.Types.Ptr; DnsPacket.Classes Class = DnsPacket.Classes.IN; int Ttl = 30; String RData = "yo-in-f104.google.com"; Response rp = new Response(Name, Type, Class, Ttl, RData); DnsPacket dp = new DnsPacket(ID, Query, Opcode, AA, false, false, new Question[] { qp }, new Response[] { rp }, null, null); MemBlock ptrm = MemBlock.Reference(new byte[] { 0xda, 0x4d, 0x80, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x31, 0x30, 0x34, 0x03, 0x31, 0x36, 0x39, 0x03, 0x32, 0x33, 0x33, 0x02, 0x36, 0x34, 0x07, 0x69, 0x6e, 0x2d, 0x61, 0x64, 0x64, 0x72, 0x04, 0x61, 0x72, 0x70, 0x61, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x03, 0x31, 0x30, 0x34, 0x03, 0x31, 0x36, 0x39, 0x03, 0x32, 0x33, 0x33, 0x02, 0x36, 0x34, 0x07, 0x69, 0x6e, 0x2d, 0x61, 0x64, 0x64, 0x72, 0x04, 0x61, 0x72, 0x70, 0x61, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x17, 0x0a, 0x79, 0x6f, 0x2d, 0x69, 0x6e, 0x2d, 0x66, 0x31, 0x30, 0x34, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00 }); DnsPacket dm = new DnsPacket(ptrm); Assert.AreEqual(dm.ID, ID, "ID"); Assert.AreEqual(dm.Query, Query, "Query"); Assert.AreEqual(dm.Opcode, Opcode, "Opcode"); Assert.AreEqual(dm.AA, AA, "AA"); Assert.AreEqual(dm.Questions.Length, 1, "Questions"); Assert.AreEqual(dm.Answers.Length, 1, "Answers"); Assert.AreEqual(dm.Packet, ptrm, "MemBlock"); Response rm = dm.Answers[0]; Assert.AreEqual(rm.Name, Name, "Name"); Assert.AreEqual(rm.Type, Type, "Type"); Assert.AreEqual(rm.Class, Class, "Class"); Assert.AreEqual(rm.Ttl, Ttl, "Ttl"); Assert.AreEqual(rm.RData, RData, "RData"); Question qm = dm.Questions[0]; Assert.AreEqual(qm.QName, Name, "QName"); Assert.AreEqual(qm.QType, Type, "QType"); Assert.AreEqual(qm.QClass, Class, "QClass"); Assert.AreEqual(dp.Packet, ptrm, "Dns Packet"); }
/** <summary>Given a DnsPacket, it will generate a failure message so that the local resolver can move on to the next nameserver without timeouting on the this one.</summary> <param name="Packet">The base packet to translate into a failed response </param> */ public static MemBlock BuildFailedReplyPacket(DnsPacket Packet) { byte[] res = new byte[Packet.Packet.Length]; Packet.Packet.CopyTo(res, 0); res[3] |= 5; res[2] |= 0x80; return MemBlock.Reference(res); }
/** <summary>Given a DnsPacket, it will generate a failure message so that the local resolver can move on to the next nameserver without timeouting on the this one.</summary> <param name="Packet">The base packet to translate into a failed response </param> */ public static MemBlock BuildFailedReplyPacket(DnsPacket Packet, bool refused_implemented) { byte[] res = new byte[Packet.Packet.Length]; Packet.Packet.CopyTo(res, 0); if(refused_implemented) { res[3] |= 5; } else { res[3] |= 4; } res[2] |= 0x80; return MemBlock.Reference(res); }
public void PtrNoIP() { MemBlock mdnsm = MemBlock.Reference(new byte[] { 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x10, 0x50, 0x69, 0x65, 0x72, 0x72, 0x65, 0xe2, 0x80, 0x99, 0x73, 0x20, 0x4d, 0x75, 0x73, 0x69, 0x63, 0x05, 0x5f, 0x64, 0x61, 0x61, 0x70, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00, 0x00, 0x21, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x69, 0x06, 0x70, 0x69, 0x65, 0x72, 0x72, 0x65, 0xc0, 0x28, 0xc0, 0x0c, 0x00, 0x10, 0x80, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0xb4, 0x09, 0x74, 0x78, 0x74, 0x76, 0x65, 0x72, 0x73, 0x3d, 0x31, 0x0c, 0x4f, 0x53, 0x73, 0x69, 0x3d, 0x30, 0x78, 0x32, 0x44, 0x46, 0x34, 0x35, 0x0e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x39, 0x36, 0x36, 0x31, 0x34, 0x1c, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x20, 0x49, 0x44, 0x3d, 0x34, 0x44, 0x30, 0x43, 0x30, 0x42, 0x32, 0x30, 0x43, 0x39, 0x34, 0x46, 0x31, 0x42, 0x36, 0x31, 0x1d, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x50, 0x69, 0x65, 0x72, 0x72, 0x65, 0xe2, 0x80, 0x99, 0x73, 0x20, 0x4d, 0x75, 0x73, 0x69, 0x63, 0x0e, 0x50, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x3d, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x14, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x20, 0x4b, 0x69, 0x6e, 0x64, 0x73, 0x20, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x3d, 0x30, 0x16, 0x4d, 0x49, 0x44, 0x3d, 0x30, 0x78, 0x39, 0x30, 0x32, 0x43, 0x39, 0x44, 0x45, 0x34, 0x46, 0x35, 0x44, 0x46, 0x37, 0x45, 0x36, 0x46, 0x17, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x20, 0x49, 0x44, 0x3d, 0x32, 0x31, 0x42, 0x44, 0x36, 0x44, 0x37, 0x45, 0x31, 0x30, 0x36, 0x46, 0x09, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x07, 0x5f, 0x64, 0x6e, 0x73, 0x2d, 0x73, 0x64, 0x04, 0x5f, 0x75, 0x64, 0x70, 0xc0, 0x28, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc0, 0x1d, 0xc0, 0x1d, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc0, 0x0c, 0x1c, 0x69, 0x54, 0x75, 0x6e, 0x65, 0x73, 0x5f, 0x43, 0x74, 0x72, 0x6c, 0x5f, 0x34, 0x32, 0x36, 0x35, 0x37, 0x38, 0x32, 0x41, 0x43, 0x32, 0x46, 0x43, 0x46, 0x31, 0x41, 0x43, 0x05, 0x5f, 0x64, 0x61, 0x63, 0x70, 0xc0, 0x23, 0x00, 0x21, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x69, 0xc0, 0x3f, 0xc1, 0x3b, 0x00, 0x10, 0x80, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x37, 0x09, 0x74, 0x78, 0x74, 0x76, 0x65, 0x72, 0x73, 0x3d, 0x31, 0x09, 0x56, 0x65, 0x72, 0x3d, 0x36, 0x35, 0x35, 0x33, 0x37, 0x0c, 0x4f, 0x53, 0x73, 0x69, 0x3d, 0x30, 0x78, 0x32, 0x44, 0x46, 0x34, 0x35, 0x15, 0x44, 0x62, 0x49, 0x64, 0x3d, 0x34, 0x44, 0x30, 0x43, 0x30, 0x42, 0x32, 0x30, 0x43, 0x39, 0x34, 0x46, 0x31, 0x42, 0x36, 0x31, 0xc1, 0x08, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc1, 0x58, 0xc1, 0x58, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc1, 0x3b, 0xc0, 0x3f, 0x00, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x04, 0x0a, 0xfe, 0x00, 0x01, 0xc0, 0x3f, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x10, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa9, 0xff, 0xfe, 0xe4, 0x23, 0x5f }); DnsPacket mdns = new DnsPacket(mdnsm); Assert.AreEqual(mdns.Questions.Length, 0, "Questions"); Assert.AreEqual(mdns.Answers.Length, 8, "Answers"); Assert.AreEqual(mdns.Authority.Length, 0, "Authority"); Assert.AreEqual(mdns.Additional.Length, 2, "Additional"); MemBlock test = MemBlock.Reference(new byte[] { 0x1c, 0x69, 0x54, 0x75, 0x6e, 0x65, 0x73, 0x5f, 0x43, 0x74, 0x72, 0x6c, 0x5f, 0x34, 0x32, 0x36, 0x35, 0x37, 0x38, 0x32, 0x41, 0x43, 0x32, 0x46, 0x43, 0x46, 0x31, 0x41, 0x43, 0x05, 0x5f, 0x64, 0x61, 0x63, 0x70, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00 }); Assert.AreEqual(mdns.Answers[5].NameBlob, test, "Answers[5].Name"); Assert.AreEqual(mdns.Additional[0].Name, "pierre.local", "Additional[0].Name"); Assert.AreEqual(mdns.Additional[0].RData, "10.254.0.1", "Additional[0].RData"); Assert.AreEqual(mdns.Answers[2].Type, DnsPacket.Types.Ptr, "Answers[2].Type"); Response original = mdns.Answers[2]; Response copy = new Response(original.Name, original.Type, original.Class, original.CacheFlush, original.Ttl, original.RData); MemBlock original_expanded = MemBlock.Reference(new byte[] { 0x09, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x07, 0x5f, 0x64, 0x6e, 0x73, 0x2d, 0x73, 0x64, 0x04, 0x5f, 0x75, 0x64, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x12, 0x05, 0x5f, 0x64, 0x61, 0x61, 0x70, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00 }); Assert.AreEqual(original_expanded, copy.Packet, "original"); }
public void PtrNoIP() { MemBlock mdnsm = MemBlock.Reference(new byte[] {0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x10, 0x50, 0x69, 0x65, 0x72, 0x72, 0x65, 0xe2, 0x80, 0x99, 0x73, 0x20, 0x4d, 0x75, 0x73, 0x69, 0x63, 0x05, 0x5f, 0x64, 0x61, 0x61, 0x70, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00, 0x00, 0x21, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x69, 0x06, 0x70, 0x69, 0x65, 0x72, 0x72, 0x65, 0xc0, 0x28, 0xc0, 0x0c, 0x00, 0x10, 0x80, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0xb4, 0x09, 0x74, 0x78, 0x74, 0x76, 0x65, 0x72, 0x73, 0x3d, 0x31, 0x0c, 0x4f, 0x53, 0x73, 0x69, 0x3d, 0x30, 0x78, 0x32, 0x44, 0x46, 0x34, 0x35, 0x0e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31, 0x39, 0x36, 0x36, 0x31, 0x34, 0x1c, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x20, 0x49, 0x44, 0x3d, 0x34, 0x44, 0x30, 0x43, 0x30, 0x42, 0x32, 0x30, 0x43, 0x39, 0x34, 0x46, 0x31, 0x42, 0x36, 0x31, 0x1d, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x50, 0x69, 0x65, 0x72, 0x72, 0x65, 0xe2, 0x80, 0x99, 0x73, 0x20, 0x4d, 0x75, 0x73, 0x69, 0x63, 0x0e, 0x50, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x3d, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x14, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x20, 0x4b, 0x69, 0x6e, 0x64, 0x73, 0x20, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x3d, 0x30, 0x16, 0x4d, 0x49, 0x44, 0x3d, 0x30, 0x78, 0x39, 0x30, 0x32, 0x43, 0x39, 0x44, 0x45, 0x34, 0x46, 0x35, 0x44, 0x46, 0x37, 0x45, 0x36, 0x46, 0x17, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x20, 0x49, 0x44, 0x3d, 0x32, 0x31, 0x42, 0x44, 0x36, 0x44, 0x37, 0x45, 0x31, 0x30, 0x36, 0x46, 0x09, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x07, 0x5f, 0x64, 0x6e, 0x73, 0x2d, 0x73, 0x64, 0x04, 0x5f, 0x75, 0x64, 0x70, 0xc0, 0x28, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc0, 0x1d, 0xc0, 0x1d, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc0, 0x0c, 0x1c, 0x69, 0x54, 0x75, 0x6e, 0x65, 0x73, 0x5f, 0x43, 0x74, 0x72, 0x6c, 0x5f, 0x34, 0x32, 0x36, 0x35, 0x37, 0x38, 0x32, 0x41, 0x43, 0x32, 0x46, 0x43, 0x46, 0x31, 0x41, 0x43, 0x05, 0x5f, 0x64, 0x61, 0x63, 0x70, 0xc0, 0x23, 0x00, 0x21, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x69, 0xc0, 0x3f, 0xc1, 0x3b, 0x00, 0x10, 0x80, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x37, 0x09, 0x74, 0x78, 0x74, 0x76, 0x65, 0x72, 0x73, 0x3d, 0x31, 0x09, 0x56, 0x65, 0x72, 0x3d, 0x36, 0x35, 0x35, 0x33, 0x37, 0x0c, 0x4f, 0x53, 0x73, 0x69, 0x3d, 0x30, 0x78, 0x32, 0x44, 0x46, 0x34, 0x35, 0x15, 0x44, 0x62, 0x49, 0x64, 0x3d, 0x34, 0x44, 0x30, 0x43, 0x30, 0x42, 0x32, 0x30, 0x43, 0x39, 0x34, 0x46, 0x31, 0x42, 0x36, 0x31, 0xc1, 0x08, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc1, 0x58, 0xc1, 0x58, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x02, 0xc1, 0x3b, 0xc0, 0x3f, 0x00, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x04, 0x0a, 0xfe, 0x00, 0x01, 0xc0, 0x3f, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x10, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa9, 0xff, 0xfe, 0xe4, 0x23, 0x5f}); DnsPacket mdns = new DnsPacket(mdnsm); Assert.AreEqual(mdns.Questions.Length, 0, "Questions"); Assert.AreEqual(mdns.Answers.Length, 8, "Answers"); Assert.AreEqual(mdns.Authority.Length, 0, "Authority"); Assert.AreEqual(mdns.Additional.Length, 2, "Additional"); MemBlock test = MemBlock.Reference(new byte[]{0x1c, 0x69, 0x54, 0x75, 0x6e, 0x65, 0x73, 0x5f, 0x43, 0x74, 0x72, 0x6c, 0x5f, 0x34, 0x32, 0x36, 0x35, 0x37, 0x38, 0x32, 0x41, 0x43, 0x32, 0x46, 0x43, 0x46, 0x31, 0x41, 0x43, 0x05, 0x5f, 0x64, 0x61, 0x63, 0x70, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00}); Assert.AreEqual(mdns.Answers[5].NameBlob, test, "Answers[5].Name"); Assert.AreEqual(mdns.Additional[0].Name, "pierre.local", "Additional[0].Name"); Assert.AreEqual(mdns.Additional[0].RData, "10.254.0.1", "Additional[0].RData"); Assert.AreEqual(mdns.Answers[2].Type, DnsPacket.Types.Ptr, "Answers[2].Type"); Response original = mdns.Answers[2]; Response copy = new Response(original.Name, original.Type, original.Class, original.CacheFlush, original.Ttl, original.RData); MemBlock original_expanded = MemBlock.Reference(new byte[]{0x09, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x07, 0x5f, 0x64, 0x6e, 0x73, 0x2d, 0x73, 0x64, 0x04, 0x5f, 0x75, 0x64, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x11, 0x94, 0x00, 0x12, 0x05, 0x5f, 0x64, 0x61, 0x61, 0x70, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00}); Assert.AreEqual(original_expanded, copy.Packet, "original"); }
public void Testdaap() { MemBlock mdnsm = MemBlock.Reference(new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x10, 0x50, 0x69, 0x65, 0x72, 0x72, 0x65, 0x27, 0x73, 0x20, 0x4C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x05, 0x5F, 0x64, 0x61, 0x61, 0x70, 0x04, 0x5F, 0x74, 0x63, 0x70, 0x05, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x00, 0x00, 0xFF, 0x00, 0x01, 0xC0, 0x0C, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x69, 0x04, 0x50, 0x49, 0x42, 0x4D, 0xC0, 0x2}); DnsPacket mdns = new DnsPacket(mdnsm); Assert.AreEqual(mdns.Questions.Length, 1, "Questions"); Assert.AreEqual(mdns.Answers.Length, 0, "Answers"); Assert.AreEqual(mdns.Authority.Length, 1, "Authority"); Assert.AreEqual(mdns.Additional.Length, 0, "Additional"); Assert.AreEqual(mdns.Questions[0].QNameBlob, MemBlock.Reference(new byte[]{0x10, 0x50, 0x69, 0x65, 0x72, 0x72, 0x65, 0x27, 0x73, 0x20, 0x4C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x05, 0x5F, 0x64, 0x61, 0x61, 0x70, 0x04, 0x5F, 0x74, 0x63, 0x70, 0x05, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x00}), "QName"); Assert.AreEqual(mdns.Questions[0].QType, (DnsPacket.Types) 0xFF, "QType"); Assert.AreEqual(mdns.Questions[0].QClass, DnsPacket.Classes.IN, "QClass"); }