internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < MinimumLength)
            {
                return(null);
            }

            byte prefixLength = dns[offsetInDns + Offset.PrefixLength];

            if (prefixLength > MaxPrefixLength)
            {
                return(null);
            }
            offsetInDns += ConstantPartLength;
            length      -= ConstantPartLength;

            int addressSuffixLength = CalculateAddressSuffixLength(prefixLength);

            if (length < addressSuffixLength)
            {
                return(null);
            }
            IpV6Address addressSuffix = new IpV6Address((UInt128)dns.ReadUnsignedBigInteger(offsetInDns, addressSuffixLength, Endianity.Big));

            offsetInDns += addressSuffixLength;
            length      -= addressSuffixLength;

            if (IsAddressSuffixTooSmall(prefixLength, addressSuffix) || IsAddressSuffixTooBig(prefixLength, addressSuffix))
            {
                return(null);
            }

            DnsDomainName prefixName;
            int           prefixNameLength;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length, out prefixName, out prefixNameLength))
            {
                return(null);
            }
            if (prefixNameLength != length)
            {
                return(null);
            }

            return(new DnsResourceDataA6(prefixLength, addressSuffix, prefixName));
        }
Beispiel #2
0
        private static bool TryReadLabels(DnsDatagram dns, int offsetInDns, out int numBytesRead, List <DataSegment> labels)
        {
            numBytesRead = 0;
            byte labelLength;

            do
            {
                if (offsetInDns >= dns.Length)
                {
                    return(false);  // Can't read label's length.
                }
                labelLength = dns[offsetInDns];
                ++numBytesRead;
                if (labelLength > MaxLabelLength)
                {
                    // Compression.
                    if (offsetInDns + 1 >= dns.Length)
                    {
                        return(false);  // Can't read compression pointer.
                    }
                    int newOffsetInDns = dns.ReadUShort(offsetInDns, Endianity.Big) & OffsetMask;
                    if (newOffsetInDns >= offsetInDns)
                    {
                        return(false);  // Can't handle pointers that are not back pointers.
                    }
                    ++numBytesRead;
                    int internalBytesRead;
                    return(TryReadLabels(dns, newOffsetInDns, out internalBytesRead, labels));
                }

                if (labelLength != 0)
                {
                    ++offsetInDns;
                    if (offsetInDns + labelLength >= dns.Length)
                    {
                        return(false);  // Can't read label.
                    }
                    labels.Add(dns.Subsegment(offsetInDns, labelLength));
                    numBytesRead += labelLength;
                    offsetInDns  += labelLength;
                }
            } while (labelLength != 0);

            return(true);
        }
        internal static List <DnsDomainName> ReadDomainNames(DnsDatagram dns, int offsetInDns, int length, int numExpected = 0)
        {
            List <DnsDomainName> list = new List <DnsDomainName>(numExpected);

            while (length != 0)
            {
                DnsDomainName domainName;
                int           numBytesRead;
                if (!DnsDomainName.TryParse(dns, offsetInDns, length, out domainName, out numBytesRead))
                {
                    return((List <DnsDomainName>)null);
                }
                offsetInDns += numBytesRead;
                length      -= numBytesRead;
                list.Add(domainName);
            }
            return(list);
        }
Beispiel #4
0
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            int           numBytesRead;
            DnsDomainName domainName;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length, out domainName, out numBytesRead))
            {
                return(null);
            }
            length -= numBytesRead;

            if (length != 0)
            {
                return(null);
            }

            return(new DnsResourceDataDomainName(domainName));
        }
Beispiel #5
0
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < 17)
            {
                return((DnsResourceData)null);
            }
            DnsDomainName domainName;
            int           numBytesRead;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length - 16, out domainName, out numBytesRead))
            {
                return((DnsResourceData)null);
            }
            offsetInDns += numBytesRead;
            length      -= numBytesRead;
            if (length < 16)
            {
                return((DnsResourceData)null);
            }
            UInt48 timeSigned = dns.ReadUInt48(offsetInDns, Endianity.Big);
            ushort fudge      = dns.ReadUShort(offsetInDns + 6, Endianity.Big);
            int    length1    = (int)dns.ReadUShort(offsetInDns + 8, Endianity.Big);

            if (length < 16 + length1)
            {
                return((DnsResourceData)null);
            }
            DataSegment messageAuthenticationCode = dns.Subsegment(offsetInDns + 10, length1);
            int         num = 10 + length1;

            offsetInDns += num;
            length      -= num;
            ushort          originalId = dns.ReadUShort(offsetInDns, Endianity.Big);
            DnsResponseCode error      = (DnsResponseCode)dns.ReadUShort(offsetInDns + 2, Endianity.Big);
            int             length2    = (int)dns.ReadUShort(offsetInDns + 4, Endianity.Big);

            if (length != 6 + length2)
            {
                return((DnsResourceData)null);
            }
            DataSegment other = dns.Subsegment(offsetInDns + 6, length2);

            return((DnsResourceData) new DnsResourceDataTransactionSignature(domainName, timeSigned, fudge, messageAuthenticationCode, originalId, error, other));
        }
Beispiel #6
0
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < 17)
            {
                return((DnsResourceData)null);
            }
            DnsDomainName domainName;
            int           numBytesRead;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length - 16, out domainName, out numBytesRead))
            {
                return((DnsResourceData)null);
            }
            offsetInDns += numBytesRead;
            length      -= numBytesRead;
            if (length < 16)
            {
                return((DnsResourceData)null);
            }
            uint num1 = dns.ReadUInt(offsetInDns, Endianity.Big);
            uint num2 = dns.ReadUInt(offsetInDns + 4, Endianity.Big);
            DnsTransactionKeyMode mode  = (DnsTransactionKeyMode)dns.ReadUShort(offsetInDns + 8, Endianity.Big);
            DnsResponseCode       error = (DnsResponseCode)dns.ReadUShort(offsetInDns + 10, Endianity.Big);
            int length1 = (int)dns.ReadUShort(offsetInDns + 12, Endianity.Big);

            if (length < 16 + length1)
            {
                return((DnsResourceData)null);
            }
            DataSegment key  = dns.Subsegment(offsetInDns + 14, length1);
            int         num3 = 14 + length1;

            offsetInDns += num3;
            length      -= num3;
            int length2 = (int)dns.ReadUShort(offsetInDns, Endianity.Big);

            if (length != 2 + length2)
            {
                return((DnsResourceData)null);
            }
            DataSegment other = dns.Subsegment(offsetInDns + 2, length2);

            return((DnsResourceData) new DnsResourceDataTransactionKey(domainName, (SerialNumber32)num1, (SerialNumber32)num2, mode, error, key, other));
        }
        internal static bool TryRead(out ushort value, out DnsDomainName domainName, DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < 2)
            {
                value      = (ushort)0;
                domainName = (DnsDomainName)null;
                return(false);
            }
            value   = dns.ReadUShort(offsetInDns, Endianity.Big);
            length -= 2;
            int numBytesRead;

            if (!DnsDomainName.TryParse(dns, offsetInDns + 2, length, out domainName, out numBytesRead))
            {
                return(false);
            }
            length -= numBytesRead;
            return(length == 0);
        }
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            DnsDomainName domainName;
            int           numBytesRead;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length, out domainName, out numBytesRead))
            {
                return((DnsResourceData)null);
            }
            offsetInDns += numBytesRead;
            length      -= numBytesRead;
            DnsTypeBitmaps instance = DnsTypeBitmaps.CreateInstance(dns.Buffer, dns.StartOffset + offsetInDns, length);

            if (instance == null)
            {
                return((DnsResourceData)null);
            }
            return((DnsResourceData) new DnsResourceDataNextDomainSecure(domainName, instance));
        }
        internal static List <DnsDomainName> ReadDomainNames(DnsDatagram dns, int offsetInDns, int length, int numExpected = 0)
        {
            List <DnsDomainName> domainNames = new List <DnsDomainName>(numExpected);

            while (length != 0)
            {
                DnsDomainName domainName;
                int           domainNameLength;
                if (!DnsDomainName.TryParse(dns, offsetInDns, length, out domainName, out domainNameLength))
                {
                    return(null);
                }
                offsetInDns += domainNameLength;
                length      -= domainNameLength;
                domainNames.Add(domainName);
            }

            return(domainNames);
        }
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < 3)
            {
                return((DnsResourceData)null);
            }
            byte                  precedence  = dns[offsetInDns];
            DnsGatewayType        gatewayType = (DnsGatewayType)dns[offsetInDns + 1];
            DnsPublicKeyAlgorithm algorithm   = (DnsPublicKeyAlgorithm)dns[offsetInDns + 2];
            DnsGateway            instance    = DnsGateway.CreateInstance(gatewayType, dns, offsetInDns + 3, length - 3);

            if (instance == null)
            {
                return((DnsResourceData)null);
            }
            DataSegment publicKey = dns.Subsegment(offsetInDns + 3 + instance.Length, length - 3 - instance.Length);

            return((DnsResourceData) new DnsResourceDataIpSecKey(precedence, instance, algorithm, publicKey));
        }
        internal static bool TryParseBase(DnsDatagram dns, int offsetInDns,
                                          out DnsDomainName domainName, out DnsType type, out DnsClass dnsClass, out int numBytesRead)
        {
            type     = DnsType.Any;
            dnsClass = DnsClass.Any;
            if (!DnsDomainName.TryParse(dns, offsetInDns, dns.Length - offsetInDns, out domainName, out numBytesRead))
            {
                return(false);
            }

            if (offsetInDns + numBytesRead + MinimumLengthAfterDomainName > dns.Length)
            {
                return(false);
            }

            type          = (DnsType)dns.ReadUShort(offsetInDns + numBytesRead + OffsetAfterDomainName.Type, Endianity.Big);
            dnsClass      = (DnsClass)dns.ReadUShort(offsetInDns + numBytesRead + OffsetAfterDomainName.DnsClass, Endianity.Big);
            numBytesRead += MinimumLengthAfterDomainName;
            return(true);
        }
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < ConstPartLength)
            {
                return(null);
            }

            byte                  precedence  = dns[offsetInDns + Offset.Precedence];
            DnsGatewayType        gatewayType = (DnsGatewayType)dns[offsetInDns + Offset.GatewayType];
            DnsPublicKeyAlgorithm algorithm   = (DnsPublicKeyAlgorithm)dns[offsetInDns + Offset.Algorithm];
            DnsGateway            gateway     = DnsGateway.CreateInstance(gatewayType, dns, offsetInDns + Offset.Gateway, length - ConstPartLength);

            if (gateway == null)
            {
                return(null);
            }
            DataSegment publicKey = dns.Subsegment(offsetInDns + ConstPartLength + gateway.Length, length - ConstPartLength - gateway.Length);

            return(new DnsResourceDataIpSecKey(precedence, gateway, algorithm, publicKey));
        }
Beispiel #13
0
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < 2)
            {
                return((DnsResourceData)null);
            }
            byte prefixLength = dns[offsetInDns];

            if ((int)prefixLength > 128)
            {
                return((DnsResourceData)null);
            }
            ++offsetInDns;
            --length;
            int length1 = DnsResourceDataA6.CalculateAddressSuffixLength(prefixLength);

            if (length < length1)
            {
                return((DnsResourceData)null);
            }
            IpV6Address addressSuffix = new IpV6Address((UInt128)dns.ReadUnsignedBigInteger(offsetInDns, length1, Endianity.Big));

            offsetInDns += length1;
            length      -= length1;
            if (DnsResourceDataA6.IsAddressSuffixTooSmall(prefixLength, addressSuffix) || DnsResourceDataA6.IsAddressSuffixTooBig(prefixLength, addressSuffix))
            {
                return((DnsResourceData)null);
            }
            DnsDomainName domainName;
            int           numBytesRead;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length, out domainName, out numBytesRead))
            {
                return((DnsResourceData)null);
            }
            if (numBytesRead != length)
            {
                return((DnsResourceData)null);
            }
            return((DnsResourceData) new DnsResourceDataA6(prefixLength, addressSuffix, domainName));
        }
Beispiel #14
0
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < 8)
            {
                return((DnsResourceData)null);
            }
            ushort      order      = dns.ReadUShort(offsetInDns, Endianity.Big);
            ushort      preference = dns.ReadUShort(offsetInDns + 2, Endianity.Big);
            DataSegment data       = dns.Subsegment(offsetInDns + 4, length - 4);
            int         offset     = 0;
            DataSegment flags      = DnsResourceData.ReadString(data, ref offset);

            if (flags == null || !DnsResourceDataNamingAuthorityPointer.IsLegalFlags(flags))
            {
                return((DnsResourceData)null);
            }
            DataSegment services = DnsResourceData.ReadString(data, ref offset);

            if (services == null)
            {
                return((DnsResourceData)null);
            }
            DataSegment regularExpression = DnsResourceData.ReadString(data, ref offset);

            if (regularExpression == null)
            {
                return((DnsResourceData)null);
            }
            DnsDomainName domainName;
            int           numBytesRead;

            if (!DnsDomainName.TryParse(dns, offsetInDns + 4 + offset, length - 4 - offset, out domainName, out numBytesRead))
            {
                return((DnsResourceData)null);
            }
            if (4 + offset + numBytesRead != length)
            {
                return((DnsResourceData)null);
            }
            return((DnsResourceData) new DnsResourceDataNamingAuthorityPointer(order, preference, flags, services, regularExpression, domainName));
        }
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            DnsDomainName nextDomainName;
            int           nextDomainNameLength;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length, out nextDomainName, out nextDomainNameLength))
            {
                return(null);
            }
            offsetInDns += nextDomainNameLength;
            length      -= nextDomainNameLength;

            DnsTypeBitmaps typeBitmaps = DnsTypeBitmaps.CreateInstance(dns.Buffer, dns.StartOffset + offsetInDns, length);

            if (typeBitmaps == null)
            {
                return(null);
            }

            return(new DnsResourceDataNextDomainSecure(nextDomainName, typeBitmaps));
        }
Beispiel #16
0
 private static bool TryReadLabels(DnsDatagram dns, int offsetInDns, out int numBytesRead, List <DataSegment> labels)
 {
     numBytesRead = 0;
     while (offsetInDns < dns.Length)
     {
         byte num = dns[offsetInDns];
         ++numBytesRead;
         if ((int)num > 63)
         {
             if (offsetInDns + 1 >= dns.Length)
             {
                 return(false);
             }
             int offsetInDns1 = (int)dns.ReadUShort(offsetInDns, Endianity.Big) & 16383;
             if (offsetInDns1 >= offsetInDns)
             {
                 return(false);
             }
             ++numBytesRead;
             int numBytesRead1;
             return(DnsDomainName.TryReadLabels(dns, offsetInDns1, out numBytesRead1, labels));
         }
         if ((int)num != 0)
         {
             ++offsetInDns;
             if (offsetInDns + (int)num >= dns.Length)
             {
                 return(false);
             }
             labels.Add(dns.Subsegment(offsetInDns, (int)num));
             numBytesRead += (int)num;
             offsetInDns  += (int)num;
         }
         if ((int)num == 0)
         {
             return(true);
         }
     }
     return(false);
 }
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < 6)
            {
                return((DnsResourceData)null);
            }
            ushort        priority = dns.ReadUShort(offsetInDns, Endianity.Big);
            ushort        weight   = dns.ReadUShort(offsetInDns + 2, Endianity.Big);
            ushort        port     = dns.ReadUShort(offsetInDns + 4, Endianity.Big);
            DnsDomainName domainName;
            int           numBytesRead;

            if (!DnsDomainName.TryParse(dns, offsetInDns + 6, length - 6, out domainName, out numBytesRead))
            {
                return((DnsResourceData)null);
            }
            if (6 + numBytesRead != length)
            {
                return((DnsResourceData)null);
            }
            return((DnsResourceData) new DnsResourceDataServerSelection(priority, weight, port, domainName));
        }
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < ConstantPartLength)
            {
                return(null);
            }

            int hostIdentityTagLength = dns[offsetInDns + Offset.HostIdentityTagLength];
            DnsPublicKeyAlgorithm publicKeyAlgorithm = (DnsPublicKeyAlgorithm)dns[offsetInDns + Offset.PublicKeyAlgorithm];
            int publicKeyLength = dns.ReadUShort(offsetInDns + Offset.PublicKeyLength, Endianity.Big);

            if (length < ConstantPartLength + hostIdentityTagLength + publicKeyLength)
            {
                return(null);
            }
            DataSegment hostIdentityTag = dns.Subsegment(offsetInDns + Offset.HostIdentityTag, hostIdentityTagLength);
            int         publicKeyOffset = offsetInDns + ConstantPartLength + hostIdentityTagLength;
            DataSegment publicKey       = dns.Subsegment(publicKeyOffset, publicKeyLength);

            offsetInDns += ConstantPartLength + hostIdentityTagLength + publicKeyLength;
            length      -= ConstantPartLength + hostIdentityTagLength + publicKeyLength;

            List <DnsDomainName> rendezvousServers = new List <DnsDomainName>();

            while (length != 0)
            {
                DnsDomainName rendezvousServer;
                int           rendezvousServerLength;
                if (!DnsDomainName.TryParse(dns, offsetInDns, length, out rendezvousServer, out rendezvousServerLength))
                {
                    return(null);
                }
                rendezvousServers.Add(rendezvousServer);
                offsetInDns += rendezvousServerLength;
                length      -= rendezvousServerLength;
            }

            return(new DnsResourceDataHostIdentityProtocol(hostIdentityTag, publicKeyAlgorithm, publicKey, rendezvousServers));
        }
Beispiel #19
0
        internal static DnsDataResourceRecord Parse(DnsDatagram dns, int offsetInDns, out int numBytesRead)
        {
            DnsDomainName domainName;
            DnsType       type;
            DnsClass      dnsClass;

            if (!TryParseBase(dns, offsetInDns, out domainName, out type, out dnsClass, out numBytesRead))
            {
                return(null);
            }

            if (offsetInDns + numBytesRead + MinimumLengthAfterBase > dns.Length)
            {
                return(null);
            }

            int    ttl        = dns.ReadInt(offsetInDns + numBytesRead + OffsetAfterBase.Ttl, Endianity.Big);
            ushort dataLength = dns.ReadUShort(offsetInDns + numBytesRead + OffsetAfterBase.DataLength, Endianity.Big);

            numBytesRead += MinimumLengthAfterBase;
            if (offsetInDns + numBytesRead + dataLength > dns.Length)
            {
                return(null);
            }
            DnsResourceData data = DnsResourceData.Read(dns, type, offsetInDns + numBytesRead, dataLength);

            if (data == null)
            {
                return(null);
            }
            numBytesRead += dataLength;

            if (type == DnsType.Opt)
            {
                return(new DnsOptResourceRecord(domainName, dnsClass, ttl, data));
            }
            return(new DnsDataResourceRecord(domainName, type, dnsClass, ttl, data));
        }
Beispiel #20
0
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < ConstantPartLength)
            {
                return(null);
            }

            ushort preference = dns.ReadUShort(offsetInDns + Offset.Preference, Endianity.Big);

            offsetInDns += ConstantPartLength;
            length      -= ConstantPartLength;

            DnsDomainName map822;
            int           map822Length;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length, out map822, out map822Length))
            {
                return(null);
            }
            offsetInDns += map822Length;
            length      -= map822Length;

            DnsDomainName mapX400;
            int           mapX400Length;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length, out mapX400, out mapX400Length))
            {
                return(null);
            }
            length -= mapX400Length;

            if (length != 0)
            {
                return(null);
            }

            return(new DnsResourceDataX400Pointer(preference, map822, mapX400));
        }
Beispiel #21
0
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            DnsDomainName domainName;
            int           numBytesRead;

            if (!DnsDomainName.TryParse(dns, offsetInDns, length, out domainName, out numBytesRead))
            {
                return((DnsResourceData)null);
            }
            offsetInDns += numBytesRead;
            length      -= numBytesRead;
            if (length > 16)
            {
                return((DnsResourceData)null);
            }
            DataSegment typeBitmap = dns.Subsegment(offsetInDns, length);

            if (length != 0 && (int)typeBitmap.Last == 0)
            {
                return((DnsResourceData)null);
            }
            return((DnsResourceData) new DnsResourceDataNextDomain(domainName, typeBitmap));
        }
        internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
        {
            if (length < 4)
            {
                return((DnsResourceData)null);
            }
            int length1 = (int)dns[offsetInDns];
            DnsPublicKeyAlgorithm publicKeyAlgorithm = (DnsPublicKeyAlgorithm)dns[offsetInDns + 1];
            int length2 = (int)dns.ReadUShort(offsetInDns + 2, Endianity.Big);

            if (length < 4 + length1 + length2)
            {
                return((DnsResourceData)null);
            }
            DataSegment hostIdentityTag = dns.Subsegment(offsetInDns + 4, length1);
            int         offset          = offsetInDns + 4 + length1;
            DataSegment publicKey       = dns.Subsegment(offset, length2);

            offsetInDns += 4 + length1 + length2;
            length      -= 4 + length1 + length2;
            List <DnsDomainName> list = new List <DnsDomainName>();

            while (length != 0)
            {
                DnsDomainName domainName;
                int           numBytesRead;
                if (!DnsDomainName.TryParse(dns, offsetInDns, length, out domainName, out numBytesRead))
                {
                    return((DnsResourceData)null);
                }
                list.Add(domainName);
                offsetInDns += numBytesRead;
                length      -= numBytesRead;
            }
            return((DnsResourceData) new DnsResourceDataHostIdentityProtocol(hostIdentityTag, publicKeyAlgorithm, publicKey, (IEnumerable <DnsDomainName>)list));
        }
 internal override sealed DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
 {
     return(this.CreateInstance(dns.Subsegment(offsetInDns, length)));
 }
        internal static bool TryRead(out DnsDomainName first, out DnsDomainName second, DnsDatagram dns, int offsetInDns, int length)
        {
            List <DnsDomainName> list = DnsResourceDataDomainNames.ReadDomainNames(dns, offsetInDns, length, 2);

            if (list == null || list.Count != 2)
            {
                first  = (DnsDomainName)null;
                second = (DnsDomainName)null;
                return(false);
            }
            first  = list[0];
            second = list[1];
            return(true);
        }
Beispiel #25
0
 protected override void Write(byte[] buffer, int offset)
 {
     DnsDatagram.Write(buffer, offset, this.Id, this.IsResponse, this.OpCode, this.IsAuthoritativeAnswer, this.IsTruncated, this.IsRecursionDesired, this.IsRecursionAvailable, this.FutureUse, this.IsAuthenticData, this.IsCheckingDisabled, this.ResponseCode, this.Queries, this.Answers, this.Authorities, this.Additionals, this.DomainNameCompressionMode);
 }
Beispiel #26
0
 internal abstract DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length);