def _as_bytes(cls, value, encode=False, max_length=None):
if encode and isinstance(value, str):
value = value.encode()
+ elif isinstance(value, bytearray):
+ value = bytes(value)
elif not isinstance(value, bytes):
raise ValueError('not bytes')
if max_length is not None and len(value) > max_length:
super().__init__(rdclass, rdtype)
self.serial = self._as_uint32(serial)
self.flags = self._as_uint16(flags)
- self.windows = dns.rdata._constify(windows)
+ if isinstance(windows, Bitmap):
+ bitmap = windows
+ else:
+ bitmap = Bitmap(windows)
+ self.windows = tuple(bitmap.windows)
def to_text(self, origin=None, relativize=True, **kw):
text = Bitmap(self.windows).to_text()
relativize_to=None):
serial = tok.get_uint32()
flags = tok.get_uint16()
- windows = Bitmap().from_text(tok)
- return cls(rdclass, rdtype, serial, flags, windows)
+ bitmap = Bitmap.from_text(tok)
+ return cls(rdclass, rdtype, serial, flags, bitmap)
def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
file.write(struct.pack('!IH', self.serial, self.flags))
@classmethod
def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
(serial, flags) = parser.get_struct("!IH")
- windows = Bitmap().from_wire_parser(parser)
- return cls(rdclass, rdtype, serial, flags, windows)
+ bitmap = Bitmap.from_wire_parser(parser)
+ return cls(rdclass, rdtype, serial, flags, bitmap)
self.hit = self._as_bytes(hit, True, 255)
self.algorithm = self._as_uint8(algorithm)
self.key = self._as_bytes(key, True)
- self.servers = dns.rdata._constify([dns.rdata.Rdata._as_name(s)
- for s in servers])
+ self.servers = tuple([dns.rdata.Rdata._as_name(s) for s in servers])
def to_text(self, origin=None, relativize=True, **kw):
hit = binascii.hexlify(self.hit).decode()
if isinstance(latitude, float):
latitude = _float_to_tuple(latitude)
_check_coordinate_list(latitude, -90, 90)
- self.latitude = dns.rdata._constify(latitude)
+ self.latitude = tuple(latitude)
if isinstance(longitude, int):
longitude = float(longitude)
if isinstance(longitude, float):
longitude = _float_to_tuple(longitude)
_check_coordinate_list(longitude, -180, 180)
- self.longitude = dns.rdata._constify(longitude)
+ self.longitude = tuple(longitude)
self.altitude = float(altitude)
self.size = float(size)
self.horizontal_precision = float(hprec)
def __init__(self, rdclass, rdtype, next, windows):
super().__init__(rdclass, rdtype)
self.next = self._as_name(next)
- self.windows = dns.rdata._constify(windows)
+ if isinstance(windows, Bitmap):
+ bitmap = windows
+ else:
+ bitmap = Bitmap(windows)
+ self.windows = tuple(bitmap.windows)
def to_text(self, origin=None, relativize=True, **kw):
next = self.next.choose_relativity(origin, relativize)
def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
relativize_to=None):
next = tok.get_name(origin, relativize, relativize_to)
- windows = Bitmap().from_text(tok)
+ windows = Bitmap.from_text(tok)
return cls(rdclass, rdtype, next, windows)
def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
@classmethod
def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
next = parser.get_name(origin)
- windows = Bitmap().from_wire_parser(parser)
- return cls(rdclass, rdtype, next, windows)
+ bitmap = Bitmap.from_wire_parser(parser)
+ return cls(rdclass, rdtype, next, bitmap)
self.iterations = self._as_uint16(iterations)
self.salt = self._as_bytes(salt, True, 255)
self.next = self._as_bytes(next, True, 255)
- self.windows = dns.rdata._constify(windows)
+ if isinstance(windows, Bitmap):
+ bitmap = windows
+ else:
+ bitmap = Bitmap(windows)
+ self.windows = tuple(bitmap.windows)
def to_text(self, origin=None, relativize=True, **kw):
next = base64.b32encode(self.next).translate(
next = tok.get_string().encode(
'ascii').upper().translate(b32_hex_to_normal)
next = base64.b32decode(next)
- windows = Bitmap().from_text(tok)
+ bitmap = Bitmap.from_text(tok)
return cls(rdclass, rdtype, algorithm, flags, iterations, salt, next,
- windows)
+ bitmap)
def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
l = len(self.salt)
(algorithm, flags, iterations) = parser.get_struct('!BBH')
salt = parser.get_counted_bytes()
next = parser.get_counted_bytes()
- windows = Bitmap().from_wire_parser(parser)
+ bitmap = Bitmap.from_wire_parser(parser)
return cls(rdclass, rdtype, algorithm, flags, iterations, salt, next,
- windows)
+ bitmap)
for option in options:
if not isinstance(option, dns.edns.Option):
raise ValueError('option is not a dns.edns.option')
- self.options = dns.rdata._constify(options)
+ self.options = tuple(options)
def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
for opt in self.options:
self.algorithm = self._as_name(algorithm)
self.time_signed = self._as_uint48(time_signed)
self.fudge = self._as_uint16(fudge)
- self.mac = dns.rdata._constify(self._as_bytes(mac))
+ self.mac = self._as_bytes(mac)
self.original_id = self._as_uint16(original_id)
self.error = dns.rcode.Rcode.make(error)
self.other = self._as_bytes(other)
for item in items:
if not isinstance(item, APLItem):
raise ValueError('item not an APLItem')
- self.items = dns.rdata._constify(items)
+ self.items = tuple(items)
def to_text(self, origin=None, relativize=True, **kw):
return ' '.join(map(str, self.items))
super().__init__(rdclass, rdtype)
self.address = self._as_ipv4_address(address)
self.protocol = self._as_uint8(protocol)
- self.bitmap = self._as_bytes(dns.rdata._constify(bitmap))
+ self.bitmap = self._as_bytes(bitmap)
def to_text(self, origin=None, relativize=True, **kw):
bits = []
for string in strings:
string = self._as_bytes(string, True, 255)
encoded_strings.append(string)
- self.strings = dns.rdata._constify(encoded_strings)
+ self.strings = tuple(encoded_strings)
def to_text(self, origin=None, relativize=True, **kw):
txt = ''
type_name = ""
def __init__(self, windows=None):
+ last_window = -1
self.windows = windows
+ for (window, bitmap) in self.windows:
+ if not isinstance(window, int):
+ raise ValueError(f"bad {self.type_name} window type")
+ if not isinstance(window, int):
+ raise ValueError(f"bad {self.type_name} window type")
+ if window <= last_window:
+ raise ValueError(f"bad {self.type_name} window order")
+ if window > 256:
+ raise ValueError(f"bad {self.type_name} window number")
+ last_window = window
+ if not isinstance(bitmap, bytes):
+ raise ValueError(f"bad {self.type_name} octets type")
+ if len(bitmap) == 0 or len(bitmap) > 32:
+ raise ValueError(f"bad {self.type_name} octets")
def to_text(self):
text = ""
text += (' ' + ' '.join(bits))
return text
- def from_text(self, tok):
+ @classmethod
+ def from_text(cls, tok):
rdtypes = []
for token in tok.get_remaining():
rdtype = dns.rdatatype.from_text(token.unescape().value)
if rdtype == 0:
- raise dns.exception.SyntaxError(f"{self.type_name} with bit 0")
+ raise dns.exception.SyntaxError(f"{cls.type_name} with bit 0")
rdtypes.append(rdtype)
rdtypes.sort()
window = 0
new_window = rdtype // 256
if new_window != window:
if octets != 0:
- windows.append((window, bitmap[0:octets]))
+ windows.append((window, bytes(bitmap[0:octets])))
bitmap = bytearray(b'\0' * 32)
window = new_window
offset = rdtype % 256
octets = byte + 1
bitmap[byte] = bitmap[byte] | (0x80 >> bit)
if octets != 0:
- windows.append((window, bitmap[0:octets]))
- return windows
+ windows.append((window, bytes(bitmap[0:octets])))
+ return cls(windows)
def to_wire(self, file):
for (window, bitmap) in self.windows:
file.write(struct.pack('!BB', window, len(bitmap)))
file.write(bitmap)
- def from_wire_parser(self, parser):
+ @classmethod
+ def from_wire_parser(cls, parser):
windows = []
- last_window = -1
while parser.remaining() > 0:
window = parser.get_uint8()
- if window <= last_window:
- raise dns.exception.FormError(f"bad {self.type_name} bitmap")
bitmap = parser.get_counted_bytes()
- if len(bitmap) == 0 or len(bitmap) > 32:
- raise dns.exception.FormError(f"bad {self.type_name} octets")
windows.append((window, bitmap))
- last_window = window
- return windows
+ return cls(windows)
g.from_wire_parser(None)
def test_Bitmap(self):
- b = dns.rdtypes.util.Bitmap([])
+ b = dns.rdtypes.util.Bitmap
tok = dns.tokenizer.Tokenizer('A MX')
- windows = b.from_text(tok)
+ windows = b.from_text(tok).windows
ba = bytearray()
ba.append(0x40) # bit 1, for A
ba.append(0x01) # bit 15, for MX
- self.assertEqual(windows, [(0, ba)])
+ self.assertEqual(windows, [(0, bytes(ba))])
def test_Bitmap_with_duplicate_types(self):
- b = dns.rdtypes.util.Bitmap([])
+ b = dns.rdtypes.util.Bitmap
tok = dns.tokenizer.Tokenizer('A MX A A MX')
- windows = b.from_text(tok)
+ windows = b.from_text(tok).windows
ba = bytearray()
ba.append(0x40) # bit 1, for A
ba.append(0x01) # bit 15, for MX
- self.assertEqual(windows, [(0, ba)])
+ self.assertEqual(windows, [(0, bytes(ba))])
def test_Bitmap_with_out_of_order_types(self):
- b = dns.rdtypes.util.Bitmap([])
+ b = dns.rdtypes.util.Bitmap
tok = dns.tokenizer.Tokenizer('MX A')
- windows = b.from_text(tok)
+ windows = b.from_text(tok).windows
ba = bytearray()
ba.append(0x40) # bit 1, for A
ba.append(0x01) # bit 15, for MX
- self.assertEqual(windows, [(0, ba)])
+ self.assertEqual(windows, [(0, bytes(ba))])
def test_Bitmap_zero_padding_works(self):
- b = dns.rdtypes.util.Bitmap([])
+ b = dns.rdtypes.util.Bitmap
tok = dns.tokenizer.Tokenizer('SRV')
- windows = b.from_text(tok)
+ windows = b.from_text(tok).windows
ba = bytearray()
ba.append(0)
ba.append(0)
ba.append(0)
ba.append(0)
ba.append(0x40) # bit 33, for SRV
- self.assertEqual(windows, [(0, ba)])
+ self.assertEqual(windows, [(0, bytes(ba))])
def test_Bitmap_has_type_0_set(self):
- b = dns.rdtypes.util.Bitmap([])
+ b = dns.rdtypes.util.Bitmap
with self.assertRaises(dns.exception.SyntaxError):
tok = dns.tokenizer.Tokenizer('NONE A MX')
b.from_text(tok)
def test_Bitmap_empty_window_not_written(self):
- b = dns.rdtypes.util.Bitmap([])
+ b = dns.rdtypes.util.Bitmap
tok = dns.tokenizer.Tokenizer('URI CAA') # types 256 and 257
- windows = b.from_text(tok)
+ windows = b.from_text(tok).windows
ba = bytearray()
ba.append(0xc0) # bits 0 and 1 in window 1
- self.assertEqual(windows, [(1, ba)])
+ self.assertEqual(windows, [(1, bytes(ba))])
def test_Bitmap_ok_parse(self):
parser = dns.wire.Parser(b'\x00\x01\x40')
b = dns.rdtypes.util.Bitmap([])
- windows = b.from_wire_parser(parser)
+ windows = b.from_wire_parser(parser).windows
self.assertEqual(windows, [(0, b'@')])
def test_Bitmap_0_length_window_parse(self):
parser = dns.wire.Parser(b'\x00\x00')
- with self.assertRaises(dns.exception.FormError):
+ with self.assertRaises(ValueError):
b = dns.rdtypes.util.Bitmap([])
b.from_wire_parser(parser)
def test_Bitmap_too_long_parse(self):
parser = dns.wire.Parser(b'\x00\x21' + b'\x01' * 33)
- with self.assertRaises(dns.exception.FormError):
+ with self.assertRaises(ValueError):
b = dns.rdtypes.util.Bitmap([])
b.from_wire_parser(parser)
projects / thirdparty / dnspython.git / commitdiff
