+2014-09-05 Bob Halley <halley@dnspython.org>
+
+ * Comparing two rdata is now always done by comparing the binary
+ data of the DNSSEC digestable forms. This corrects a number of
+ errors where dnspython's rdata comparsion order was not the
+ DNSSEC order.
+
+ * Add CAA implementation. Thanks to Brian Wellington for the
+ patch.
+
2014-09-01 Bob Halley <halley@dnspython.org>
* (Version 1.12.0 released)
rdclass. Return < 0 if self < other in the DNSSEC ordering,
0 if self == other, and > 0 if self > other.
"""
- raise NotImplementedError
+ return dns.util.cmp(self.to_digestable(dns.name.root),
+ other.to_digestable(dns.name.root))
def __eq__(self, other):
if not isinstance(other, Rdata):
def __hash__(self):
return hash(self.to_digestable(dns.name.root))
- def _wire_cmp(self, other):
- # A number of types compare rdata in wire form, so we provide
- # the method here instead of duplicating it.
- #
- # We specifiy an arbitrary origin of '.' when doing the
- # comparison, since the rdata may have relative names and we
- # can't convert a relative name to wire without an origin.
- b1 = io.BytesIO()
- self.to_wire(b1, None, dns.name.root)
- b2 = io.BytesIO()
- other.to_wire(b2, None, dns.name.root)
- return dns.util.cmp(b1.getvalue(), b2.getvalue())
-
@classmethod
def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True):
"""Build an rdata object from text format.
def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None):
return cls(rdclass, rdtype, wire[current : current + rdlen])
- def _cmp(self, other):
- return dns.util.cmp(self.data, other.data)
-
_rdata_modules = {}
_module_prefix = 'dns.rdtypes'
certificate)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- f = io.BytesIO()
- self.to_wire(f)
- wire1 = f.getvalue()
- f.seek(0)
- f.truncate()
- other.to_wire(f)
- wire2 = f.getvalue()
- f.close()
-
- return dns.util.cmp(wire1, wire2)
return cls(rdclass, rdtype, header[0], header[1], header[2],
key)
- def _cmp(self, other):
- hs = struct.pack("!HBB", self.flags, self.protocol, self.algorithm)
- ho = struct.pack("!HBB", other.flags, other.protocol, other.algorithm)
- v = dns.util.cmp(hs, ho)
- if v == 0:
- v = dns.util.cmp(self.key, other.key)
- return v
-
def flags_to_text_set(self):
"""Convert a DNSKEY flags value to set texts
@rtype: set([string])"""
from_wire = classmethod(from_wire)
- def _cmp(self, other):
- v = dns.util.cmp(self.latitude, other.latitude)
- if v == 0:
- v = dns.util.cmp(self.longitude, other.longitude)
- if v == 0:
- v = dns.util.cmp(self.altitude, other.altitude)
- return v
-
def _get_float_latitude(self):
return float(self.latitude)
return cls(rdclass, rdtype, cpu, os)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- v = dns.util.cmp(self.cpu, other.cpu)
- if v == 0:
- v = dns.util.cmp(self.os, other.os)
- return v
server = server.choose_relativity(origin, relativize)
servers.append(server)
self.servers = servers
-
- def _cmp(self, other):
- b1 = io.BytesIO()
- lh = len(self.hit)
- lk = len(self.key)
- b1.write(struct.pack("!BBH", lh, self.algorithm, lk))
- b1.write(self.hit)
- b1.write(self.key)
- b2 = io.BytesIO()
- lh = len(other.hit)
- lk = len(other.key)
- b2.write(struct.pack("!BBH", lh, other.algorithm, lk))
- b2.write(other.hit)
- b2.write(other.key)
- v = dns.util.cmp(b1.getvalue(), b2.getvalue())
- if v != 0:
- return v
- ls = len(self.servers)
- lo = len(other.servers)
- count = min(ls, lo)
- i = 0
- while i < count:
- v = dns.util.cmp(self.servers[i], other.servers[i])
- if v != 0:
- return v
- i += 1
- return ls - lo
return cls(rdclass, rdtype, address, subaddress)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- v = dns.util.cmp(self.address, other.address)
- if v == 0:
- v = dns.util.cmp(self.subaddress, other.subaddress)
- return v
from_wire = classmethod(from_wire)
- def _cmp(self, other):
- f = io.BytesIO()
- self.to_wire(f)
- wire1 = f.getvalue()
- f.seek(0)
- f.truncate()
- other.to_wire(f)
- wire2 = f.getvalue()
- f.close()
-
- return dns.util.cmp(wire1, wire2)
-
def _get_float_latitude(self):
return _tuple_to_float(self.latitude)
def choose_relativity(self, origin = None, relativize = True):
self.next = self.next.choose_relativity(origin, relativize)
-
- def _cmp(self, other):
- return self._wire_cmp(other)
return cls(rdclass, rdtype, algorithm, flags, iterations, salt, next, windows)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- return self._wire_cmp(other)
return cls(rdclass, rdtype, algorithm, flags, iterations, salt)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- return self._wire_cmp(other)
def choose_relativity(self, origin = None, relativize = True):
self.mbox = self.mbox.choose_relativity(origin, relativize)
self.txt = self.txt.choose_relativity(origin, relativize)
-
- def _cmp(self, other):
- v = dns.util.cmp(self.mbox, other.mbox)
- if v == 0:
- v = dns.util.cmp(self.txt, other.txt)
- return v
def choose_relativity(self, origin = None, relativize = True):
self.signer = self.signer.choose_relativity(origin, relativize)
-
- def _cmp(self, other):
- hs = struct.pack('!HBBIIIH', self.type_covered,
- self.algorithm, self.labels,
- self.original_ttl, self.expiration,
- self.inception, self.key_tag)
- ho = struct.pack('!HBBIIIH', other.type_covered,
- other.algorithm, other.labels,
- other.original_ttl, other.expiration,
- other.inception, other.key_tag)
- v = dns.util.cmp(hs, ho)
- if v == 0:
- v = dns.util.cmp(self.signer, other.signer)
- if v == 0:
- v = dns.util.cmp(self.signature, other.signature)
- return v
def choose_relativity(self, origin = None, relativize = True):
self.mname = self.mname.choose_relativity(origin, relativize)
self.rname = self.rname.choose_relativity(origin, relativize)
-
- def _cmp(self, other):
- v = dns.util.cmp(self.mname, other.mname)
- if v == 0:
- v = dns.util.cmp(self.rname, other.rname)
- if v == 0:
- self_ints = struct.pack('!IIIII', self.serial, self.refresh,
- self.retry, self.expire, self.minimum)
- other_ints = struct.pack('!IIIII', other.serial, other.refresh,
- other.retry, other.expire,
- other.minimum)
- v = dns.util.cmp(self_ints, other_ints)
- return v
return cls(rdclass, rdtype, header[0], header[1], fingerprint)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- hs = struct.pack("!BB", self.algorithm, self.fp_type)
- ho = struct.pack("!BB", other.algorithm, other.fp_type)
- v = dns.util.cmp(hs, ho)
- if v == 0:
- v = dns.util.cmp(self.fingerprint, other.fingerprint)
- return v
return cls(rdclass, rdtype, header[0], header[1], header[2], cert)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- hs = struct.pack("!BBB", self.usage, self.selector, self.mtype)
- ho = struct.pack("!BBB", other.usage, other.selector, other.mtype)
- v = dns.util.cmp(hs, ho)
- if v == 0:
- v = dns.util.cmp(self.cert, other.cert)
- return v
return cls(rdclass, rdtype, address)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- return dns.util.cmp(self.address, other.address)
return cls(rdclass, rdtype, address)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- sa = dns.ipv4.inet_aton(self.address)
- oa = dns.ipv4.inet_aton(other.address)
- return dns.util.cmp(sa, oa)
return cls(rdclass, rdtype, address)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- sa = dns.inet.inet_pton(dns.inet.AF_INET6, self.address)
- oa = dns.inet.inet_pton(dns.inet.AF_INET6, other.address)
- return dns.util.cmp(sa, oa)
return cls(rdclass, rdtype, items)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- f = io.BytesIO()
- self.to_wire(f)
- wire1 = f.getvalue()
- f.seek(0)
- f.truncate()
- other.to_wire(f)
- wire2 = f.getvalue()
- f.close()
-
- return dns.util.cmp(wire1, wire2)
return cls(rdclass, rdtype, data)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- return dns.util.cmp(self.data, other.data)
gateway, key)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- f = io.BytesIO()
- self.to_wire(f)
- wire1 = f.getvalue()
- f.seek(0)
- f.truncate()
- other.to_wire(f)
- wire2 = f.getvalue()
- f.close()
-
- return dns.util.cmp(wire1, wire2)
def choose_relativity(self, origin = None, relativize = True):
self.replacement = self.replacement.choose_relativity(origin,
relativize)
-
- def _cmp(self, other):
- sp = struct.pack("!HH", self.order, self.preference)
- op = struct.pack("!HH", other.order, other.preference)
- v = dns.util.cmp(sp, op)
- if v == 0:
- v = dns.util.cmp(self.flags, other.flags)
- if v == 0:
- v = dns.util.cmp(self.service, other.service)
- if v == 0:
- v = dns.util.cmp(self.regexp, other.regexp)
- if v == 0:
- v = dns.util.cmp(self.replacement, other.replacement)
- return v
return cls(rdclass, rdtype, address)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- return dns.util.cmp(self.address, other.address)
def choose_relativity(self, origin = None, relativize = True):
self.map822 = self.map822.choose_relativity(origin, relativize)
self.mapx400 = self.mapx400.choose_relativity(origin, relativize)
-
- def _cmp(self, other):
- sp = struct.pack("!H", self.preference)
- op = struct.pack("!H", other.preference)
- v = dns.util.cmp(sp, op)
- if v == 0:
- v = dns.util.cmp(self.map822, other.map822)
- if v == 0:
- v = dns.util.cmp(self.mapx400, other.mapx400)
- return v
def choose_relativity(self, origin = None, relativize = True):
self.target = self.target.choose_relativity(origin, relativize)
-
- def _cmp(self, other):
- sp = struct.pack("!HHH", self.priority, self.weight, self.port)
- op = struct.pack("!HHH", other.priority, other.weight, other.port)
- v = dns.util.cmp(sp, op)
- if v == 0:
- v = dns.util.cmp(self.target, other.target)
- return v
return cls(rdclass, rdtype, address, protocol, bitmap)
from_wire = classmethod(from_wire)
-
- def _cmp(self, other):
- sa = dns.ipv4.inet_aton(self.address)
- oa = dns.ipv4.inet_aton(other.address)
- v = dns.util.cmp(sa, oa)
- if v == 0:
- sp = struct.pack('!B', self.protocol)
- op = struct.pack('!B', other.protocol)
- v = dns.util.cmp(sp, op)
- if v == 0:
- v = dns.util.cmp(self.bitmap, other.bitmap)
- return v
rdlen -= 4
digest = wire[current : current + rdlen].unwrap()
return cls(rdclass, rdtype, header[0], header[1], header[2], digest)
-
- def _cmp(self, other):
- hs = struct.pack("!HBB", self.key_tag, self.algorithm,
- self.digest_type)
- ho = struct.pack("!HBB", other.key_tag, other.algorithm,
- other.digest_type)
- v = dns.util.cmp(hs, ho)
- if v == 0:
- v = dns.util.cmp(self.digest, other.digest)
- return v
"""MX-like base classes."""
+import io
import struct
import dns.exception
def choose_relativity(self, origin = None, relativize = True):
self.exchange = self.exchange.choose_relativity(origin, relativize)
- def _cmp(self, other):
- sp = struct.pack("!H", self.preference)
- op = struct.pack("!H", other.preference)
- v = dns.util.cmp(sp, op)
- if v == 0:
- v = dns.util.cmp(self.exchange, other.exchange)
- return v
-
class UncompressedMX(MXBase):
"""Base class for rdata that is like an MX record, but whose name
is not compressed when converted to DNS wire format, and whose
super(UncompressedMX, self).to_wire(file, None, origin)
def to_digestable(self, origin = None):
- return self.to_wire(f, None, origin)
+ f = io.BytesIO()
+ self.to_wire(f, None, origin)
+ return f.getvalue()
class UncompressedDowncasingMX(MXBase):
"""Base class for rdata that is like an MX record, but whose name
def choose_relativity(self, origin = None, relativize = True):
self.target = self.target.choose_relativity(origin, relativize)
- def _cmp(self, other):
- return dns.util.cmp(self.target, other.target)
-
class UncompressedNS(NSBase):
"""Base class for rdata that is like an NS record, but whose name
is not compressed when convert to DNS wire format, and whose
super(UncompressedNS, self).to_wire(file, None, origin)
def to_digestable(self, origin = None):
- return self.to_wire(None, None, origin)
+ return self.target.to_wire(None, None, origin)
rdlen -= l
strings.append(s)
return cls(rdclass, rdtype, strings)
-
- def _cmp(self, other):
- return dns.util.cmp(self.strings, other.strings)
projects / thirdparty / dnspython.git / commitdiff
