return hash(self.to_digestable(dns.name.root))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
raise NotImplementedError
@classmethod
return r'\# %d ' % len(self.data) + _hexify(self.data)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
token = tok.get()
if not token.is_identifier() or token.value != r'\#':
raise dns.exception.SyntaxError(
return cls
-def from_text(rdclass, rdtype, tok, origin=None, relativize=True):
+def from_text(rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
"""Build an rdata object from text format.
This function attempts to dynamically load a class which
*origin*, a ``dns.name.Name`` (or ``None``), the
origin to use for relative names.
- *relativize*, a ``bool``. If true, name will be relativized to
- the specified origin.
+ *relativize*, a ``bool``. If true, name will be relativized.
+
+ *relativize_to*, a ``dns.name.Name`` (or ``None``), the origin to use
+ when relativizing names. If not set, the *origin* value will be used.
Returns an instance of the chosen Rdata subclass.
"""
# from_wire on it.
#
rdata = GenericRdata.from_text(rdclass, rdtype, tok, origin,
- relativize)
+ relativize, relativize_to)
return from_wire(rdclass, rdtype, rdata.data, 0, len(rdata.data),
origin)
- return cls.from_text(rdclass, rdtype, tok, origin, relativize)
+ return cls.from_text(rdclass, rdtype, tok, origin, relativize,
+ relativize_to)
def from_wire(rdclass, rdtype, wire, current, rdlen, origin=None):
...
_rdata_modules : Dict[Tuple[Any,Rdata],Any]
-def from_text(rdclass : int, rdtype : int, tok : Optional[str], origin : Optional[Name] = None, relativize : bool = True):
+def from_text(rdclass : int, rdtype : int, tok : Optional[str], origin : Optional[Name] = None, relativize : bool = True, relativize_to : Optional[Name] = None):
...
def from_wire(rdclass : int, rdtype : int, wire : bytes, current : int, rdlen : int, origin : Optional[Name] = None):
dns.rdata._escapify(self.value))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
flags = tok.get_uint8()
tag = tok.get_string().encode()
if len(tag) > 255:
dns.rdata._base64ify(self.certificate))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
certificate_type = _ctype_from_text(tok.get_string())
key_tag = tok.get_uint16()
algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
return '%d %d%s' % (self.serial, self.flags, text)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
serial = tok.get_uint32()
flags = tok.get_uint16()
rdtypes = []
self.altitude.decode())
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
latitude = tok.get_string()
longitude = tok.get_string()
altitude = tok.get_string()
dns.rdata._escapify(self.os))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
cpu = tok.get_string()
os = tok.get_string()
tok.get_eol()
return '%u %s %s%s' % (self.algorithm, hit, key, text)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
algorithm = tok.get_uint8()
hit = binascii.unhexlify(tok.get_string().encode())
if len(hit) > 255:
return '"%s"' % dns.rdata._escapify(self.address)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
address = tok.get_string()
t = tok.get()
if not t.is_eol_or_eof():
return text
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
latitude = [0, 0, 0, 0, 1]
longitude = [0, 0, 0, 0, 1]
size = _default_size
return '{}{}'.format(next, text)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
- next = tok.get_name()
- next = 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)
rdtypes = []
while 1:
token = tok.get().unescape()
self.iterations, salt, next, text)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
algorithm = tok.get_uint8()
flags = tok.get_uint8()
iterations = tok.get_uint16()
salt)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
algorithm = tok.get_uint8()
flags = tok.get_uint8()
iterations = tok.get_uint16()
return dns.rdata._base64ify(self.key)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
chunks = []
while 1:
t = tok.get().unescape()
return "{} {}".format(str(mbox), str(txt))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
- mbox = tok.get_name()
- txt = tok.get_name()
- mbox = mbox.choose_relativity(origin, relativize)
- txt = txt.choose_relativity(origin, relativize)
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
+ mbox = tok.get_name(origin, relativize, relativize_to)
+ txt = tok.get_name(origin, relativize, relativize_to)
tok.get_eol()
return cls(rdclass, rdtype, mbox, txt)
)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
type_covered = dns.rdatatype.from_text(tok.get_string())
algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
labels = tok.get_int()
expiration = sigtime_to_posixtime(tok.get_string())
inception = sigtime_to_posixtime(tok.get_string())
key_tag = tok.get_int()
- signer = tok.get_name()
- signer = signer.choose_relativity(origin, relativize)
+ signer = tok.get_name(origin, relativize, relativize_to)
chunks = []
while 1:
t = tok.get().unescape()
self.expire, self.minimum)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
- mname = tok.get_name()
- rname = tok.get_name()
- mname = mname.choose_relativity(origin, relativize)
- rname = rname.choose_relativity(origin, relativize)
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
+ mname = tok.get_name(origin, relativize, relativize_to)
+ rname = tok.get_name(origin, relativize, relativize_to)
serial = tok.get_uint32()
refresh = tok.get_ttl()
retry = tok.get_ttl()
chunksize=128))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
algorithm = tok.get_uint8()
fp_type = tok.get_uint8()
chunks = []
chunksize=128))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
usage = tok.get_uint8()
selector = tok.get_uint8()
mtype = tok.get_uint8()
self.target.decode())
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
priority = tok.get_uint16()
weight = tok.get_uint16()
target = tok.get().unescape()
return '"%s"' % dns.rdata._escapify(self.address)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
address = tok.get_string()
tok.get_eol()
return cls(rdclass, rdtype, address)
return '%s %o' % (domain, self.address)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
- domain = tok.get_name()
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
+ domain = tok.get_name(origin, relativize, relativize_to)
address = tok.get_uint16(base=8)
- domain = domain.choose_relativity(origin, relativize)
tok.get_eol()
return cls(rdclass, rdtype, address, domain)
return self.address
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
address = tok.get_identifier()
tok.get_eol()
return cls(rdclass, rdtype, address)
return self.address
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
address = tok.get_identifier()
tok.get_eol()
return cls(rdclass, rdtype, address)
return ' '.join(map(str, self.items))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
items = []
while 1:
token = tok.get().unescape()
return dns.rdata._base64ify(self.data)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
chunks = []
while 1:
t = tok.get().unescape()
dns.rdata._base64ify(self.key))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
precedence = tok.get_uint8()
gateway_type = tok.get_uint8()
algorithm = tok.get_uint8()
if gateway_type == 3:
- gateway = tok.get_name().choose_relativity(origin, relativize)
+ gateway = tok.get_name(origin, relativize, relativize_to)
else:
gateway = tok.get_string()
chunks = []
replacement)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
order = tok.get_uint16()
preference = tok.get_uint16()
flags = tok.get_string()
service = tok.get_string()
regexp = tok.get_string()
- replacement = tok.get_name()
- replacement = replacement.choose_relativity(origin, relativize)
+ replacement = tok.get_name(origin, relativize, relativize_to)
tok.get_eol()
return cls(rdclass, rdtype, order, preference, flags, service,
regexp, replacement)
return "0x%s" % binascii.hexlify(self.address).decode()
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
address = tok.get_string()
tok.get_eol()
if address[0:2] != '0x':
return '%d %s %s' % (self.preference, map822, mapx400)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
preference = tok.get_uint16()
- map822 = tok.get_name()
- map822 = map822.choose_relativity(origin, relativize)
- mapx400 = tok.get_name(None)
- mapx400 = mapx400.choose_relativity(origin, relativize)
+ map822 = tok.get_name(origin, relativize, relativize_to)
+ mapx400 = tok.get_name(origin, relativize, relativize_to)
tok.get_eol()
return cls(rdclass, rdtype, preference, map822, mapx400)
target)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
priority = tok.get_uint16()
weight = tok.get_uint16()
port = tok.get_uint16()
- target = tok.get_name(None)
- target = target.choose_relativity(origin, relativize)
+ target = tok.get_name(origin, relativize, relativize_to)
tok.get_eol()
return cls(rdclass, rdtype, priority, weight, port, target)
return '%s %d %s' % (self.address, self.protocol, text)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
address = tok.get_string()
protocol = tok.get_string()
if protocol.isdigit():
dns.rdata._base64ify(self.key))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
flags = tok.get_uint16()
protocol = tok.get_uint8()
algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
...
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
...
def to_wire(self, file, compress=None, origin=None):
chunksize=128))
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
key_tag = tok.get_uint16()
algorithm = tok.get_uint8()
digest_type = tok.get_uint8()
return dns.rdata._hexify(self.eui, chunksize=2).replace(' ', '-')
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
text = tok.get_string()
tok.get_eol()
if len(text) != cls.text_len:
return '%d %s' % (self.preference, exchange)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
preference = tok.get_uint16()
- exchange = tok.get_name()
- exchange = exchange.choose_relativity(origin, relativize)
+ exchange = tok.get_name(origin, relativize, relativize_to)
tok.get_eol()
return cls(rdclass, rdtype, preference, exchange)
return str(target)
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
- target = tok.get_name()
- target = target.choose_relativity(origin, relativize)
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
+ target = tok.get_name(origin, relativize, relativize_to)
tok.get_eol()
return cls(rdclass, rdtype, target)
return txt
@classmethod
- def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+ def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+ relativize_to=None):
strings = []
while 1:
token = tok.get().unescape()
raise dns.exception.SyntaxError('expecting an identifier')
return token.value
- def get_name(self, origin=None):
+ def get_name(self, origin=None, relativize=False, relativize_to=None):
"""Read the next token and interpret it as a DNS name.
Raises dns.exception.SyntaxError if not a name.
token = self.get()
if not token.is_identifier():
raise dns.exception.SyntaxError('expecting an identifier')
- return dns.name.from_text(token.value, origin)
+ name = dns.name.from_text(token.value, origin)
+ return name.choose_relativity(relativize_to or origin, relativize)
def get_eol(self):
"""Read the next token and raise an exception if it isn't EOL or
self.zone.nodes[name] = n
try:
rd = dns.rdata.from_text(rdclass, rdtype, self.tok,
- self.current_origin, False)
+ self.current_origin, self.relativize,
+ self.zone.origin)
except dns.exception.SyntaxError:
# Catch and reraise.
(ty, va) = sys.exc_info()[:2]
else:
ttl = self.last_ttl
- rd.choose_relativity(self.zone.origin, self.relativize)
covers = rd.covers()
rds = n.find_rdataset(rdclass, rdtype, covers, True)
rds.add(rd, ttl)
self.zone.nodes[name] = n
try:
rd = dns.rdata.from_text(rdclass, rdtype, rdata,
- self.current_origin, False)
+ self.current_origin, self.relativize,
+ self.zone.origin)
except dns.exception.SyntaxError:
# Catch and reraise.
(ty, va) = sys.exc_info()[:2]
raise dns.exception.SyntaxError("caught exception %s: %s" %
(str(ty), str(va)))
- rd.choose_relativity(self.zone.origin, self.relativize)
covers = rd.covers()
rds = n.find_rdataset(rdclass, rdtype, covers, True)
rds.add(rd, ttl)
projects / thirdparty / dnspython.git / commitdiff
