DNS Rdata Base Class

All Rdata objects are instances of some subclass of dns.rdata.Rdata, and are immutable. The Rdata factory functions described in Making DNS Rdata will create objects which are instances of the most appropriate subclass. For example, a AAAA record will be an instance of the dns.rdtypes.IN.AAAA class, but a record of TYPE12345, which we don’t know anything specific about, will be an instance of dns.rdata.GenericRdata.

Rdata of the same type and class are ordered. For rdata that do not contain domain names, or which contain absolute domain names, the order is the same as the DNSSEC ordering. For rdata containing at least one relative name, that rdata will sort before any rdata with an absolute name. This makes comparison well defined (compared to earlier versions of dnspython), but is a stop-gap measure for backwards compatibility. We want to disallow this type of comparison because it easily leads to bugs. Consider this rdataset:

$ORIGIN example.
name 300 IN NS a    ; 1
            NS a.   ; 2

In this case the record marked “2” sorts before the one marked “1” when all the names are made absolute and the DNSSEC ordering is used. But when relative comparisons are allowed, “1” sorts before “2”. This isn’t merely cosmetic, as code making a DNSSEC signature or computing a zone checksum would get different answers for the same content if it failed to make all names absolute before sorting.

Comparing relative rdata with absolute is thus deprecated and will be removed in a future version of dnspython. Setting dns.rdata._allow_relative_comparisons to True will allow the future behavior to be tested with existing code.

class dns.rdata.Rdata(*args, **kwargs)

covers() → RdataType

Return the type a Rdata covers.

DNS SIG/RRSIG rdatas apply to a specific type; this type is returned by the covers() function. If the rdata type is not SIG or RRSIG, dns.rdatatype.NONE is returned. This is useful when creating rdatasets, allowing the rdataset to contain only RRSIGs of a particular type, e.g. RRSIG(NS).

Returns a dns.rdatatype.RdataType.

extended_rdatatype() → int

Return a 32-bit type value, the least significant 16 bits of which are the ordinary DNS type, and the upper 16 bits of which are the “covered” type, if any.

Returns an int.

replace(**kwargs: Any) → Rdata

Create a new Rdata instance based on the instance replace was invoked on. It is possible to pass different parameters to override the corresponding properties of the base Rdata.

Any field specific to the Rdata type can be replaced, but the rdtype and rdclass fields cannot.

Returns an instance of the same Rdata subclass as self.

to_digestable(origin: Name | None = None) → bytes

Convert rdata to a format suitable for digesting in hashes. This is also the DNSSEC canonical form.

Returns a bytes.

to_generic(origin: Name | None = None) → GenericRdata

Creates a dns.rdata.GenericRdata equivalent of this rdata.

Returns a dns.rdata.GenericRdata.

to_text(origin: Name | None = None, relativize: bool = True, **kw: Dict[str, Any]) → str

Convert an rdata to text format.

Returns a str.

to_wire(file: Any | None = None, compress: Dict[Name, int] | None = None, origin: Name | None = None, canonicalize: bool = False) → bytes

Convert an rdata to wire format.

Returns a bytes or None.