/usr/lib/python3.6/site-packages/dns/__pycache__
Edit: /usr/lib/python3.6/site-packages/dns/__pycache__/rdata.cpython-36.pyc (14355B)
3
bW: @ s d Z ddlmZ ddlZddlZddlZddlZddlZddl Zddl
Zddl Zddl m
Z
mZmZ dZefddZdZefd d
Zed Zd d
Zdd ZG dd deZG dd deZi ZdZ dd Z d ddZ d ddZ dS ) a DNS rdata.
@var _rdata_modules: A dictionary mapping a (rdclass, rdtype) tuple to
the module which implements that type.
@type _rdata_modules: dict
@var _module_prefix: The prefix to use when forming modules names. The
default is 'dns.rdtypes'. Changing this value will break the library.
@type _module_prefix: string
@var _hex_chunk: At most this many octets that will be represented in each
chunk of hexstring that _hexify() produces before whitespace occurs.
@type _hex_chunk: int )BytesION )xrange string_types text_type c s4 t j| dj fddtdt D j S )a Convert a binary string into its hex encoding, broken up into chunks
of I{chunksize} characters separated by a space.
@param data: the binary string
@type data: string
@param chunksize: the chunk size. Default is L{dns.rdata._hex_chunksize}
@rtype: string
c s g | ]}|| qS r ).0i) chunksizeliner /usr/lib/python3.6/rdata.py
6 s z_hexify..r )binasciiZhexlifyjoinrangelendecode)datar r )r r
r _hexify+ s
r c s4 t j| dj fddtdt D j S )a$ Convert a binary string into its base64 encoding, broken up into chunks
of I{chunksize} characters separated by a space.
@param data: the binary string
@type data: string
@param chunksize: the chunk size. Default is
L{dns.rdata._base64_chunksize}
@rtype: string
r c s g | ]}|| qS r r )r
r )r r
r r r I s z _base64ify..r )base64Z b64encoder r r r )r r r )r r
r
_base64ify= s
r s "\c C s~ t | tr| j } t | ts$t| } d}xP| D ]H}|tkrL|dt| 7 }q.|dkrj|dk rj|t|7 }q.|d| 7 }q.W |S )zEscape the characters in a quoted string which need it.
@param qstring: the string
@type qstring: string
@returns: the escaped string
@rtype: string
\r z\%03d)
isinstancer encode bytearray __escapedchr)Zqstringtextcr r r _escapifyO s
r# c C sF x8t t| d ddD ] }| | dkr| d|d S qW | dd S )zDetermine the index of greatest byte that isn't all zeros, and
return the bitmap that contains all the bytes less than that index.
@param what: a string of octets representing a bitmap.
@type what: string
@rtype: string
r r r$ )r r )Zwhatr r r r _truncate_bitmaph s r% c @ s e Zd ZdZddgZdd Zdd Zdd Zd.d d
Zd/ddZ d0ddZ
dd Z dd Z dd Z
dd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' Zed1d(d)Zed2d*d+Zd3d,d-Zd
S )4Rdataz(Base class for all DNS rdata types.
rdclassrdtypec C s || _ || _dS )zInitialize an rdata.
@param rdclass: The rdata class
@type rdclass: int
@param rdtype: The rdata type
@type rdtype: int
N)r' r( )selfr' r( r r r __init__~ s zRdata.__init__c C s t jjS )a_ 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).
@rtype: int
)dns rdatatypeNONE)r) r r r covers s z Rdata.coversc C s | j d> | jB S )zReturn 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.
@rtype: int
)r. r( )r) r r r extended_rdatatype s zRdata.extended_rdatatypeNTc K s t dS )z@Convert an rdata to text format.
@rtype: string
N)NotImplementedError)r) origin
relativizekwr r r to_text s z
Rdata.to_textc C s t dS )z@Convert an rdata to wire format.
@rtype: string
N)r1 )r) filecompressr2 r r r to_wire s z
Rdata.to_wirec C s t }| j|d| |j S )zlConvert rdata to a format suitable for digesting in hashes. This
is also the DNSSEC canonical form.N)r r8 getvalue)r) r2 fr r r
to_digestable s zRdata.to_digestablec C s t jj| j| j| j dS )zCheck that the current contents of the rdata's fields are
valid. If you change an rdata by assigning to its fields,
it is a good idea to call validate() when you are done making
changes.
N)r+ rdata from_textr' r( r5 )r) r r r validate s zRdata.validatec C sf | j }|tjjkrd}ndtjj| d }dtjj| j d tjj| j | d t| d S )Nr ()z) r. r+ r, r- r5
rdataclassr' r( str)r) r. Zctextr r r __repr__ s
zRdata.__repr__c C s | j S )N)r5 )r) r r r __str__ s z
Rdata.__str__c C s8 | j tjj}|j tjj}||kr(dS ||kr4dS dS )zCompare an rdata with another rdata of the same rdtype and
rdclass. Return < 0 if self < other in the DNSSEC ordering,
0 if self == other, and > 0 if self > other.
r r r$ )r; r+ nameroot)r) otherZourZtheirr r r _cmp s z
Rdata._cmpc C s8 t |tsdS | j|jks&| j|jkr*dS | j|dkS )NFr )r r& r' r( rJ )r) rI r r r __eq__ s
z Rdata.__eq__c C s8 t |tsdS | j|jks&| j|jkr*dS | j|dkS )NTr )r r& r' r( rJ )r) rI r r r __ne__ s
z Rdata.__ne__c C s6 t |t s$| j|jks$| j|jkr(tS | j|dk S )Nr )r r& r' r( NotImplementedrJ )r) rI r r r __lt__ s z Rdata.__lt__c C s6 t |t s$| j|jks$| j|jkr(tS | j|dkS )Nr )r r& r' r( rM rJ )r) rI r r r __le__ s z Rdata.__le__c C s6 t |t s$| j|jks$| j|jkr(tS | j|dkS )Nr )r r& r' r( rM rJ )r) rI r r r __ge__ s z Rdata.__ge__c C s6 t |t s$| j|jks$| j|jkr(tS | j|dkS )Nr )r r& r' r( rM rJ )r) rI r r r __gt__ s z Rdata.__gt__c C s t | jtjjS )N)hashr; r+ rG rH )r) r r r __hash__ s zRdata.__hash__c C s t dS )a Build an rdata object from text format.
@param rdclass: The rdata class
@type rdclass: int
@param rdtype: The rdata type
@type rdtype: int
@param tok: The tokenizer
@type tok: dns.tokenizer.Tokenizer
@param origin: The origin to use for relative names
@type origin: dns.name.Name
@param relativize: should names be relativized?
@type relativize: bool
@rtype: dns.rdata.Rdata instance
N)r1 )clsr' r( tokr2 r3 r r r r= s zRdata.from_textc C s t dS )a< Build an rdata object from wire format
@param rdclass: The rdata class
@type rdclass: int
@param rdtype: The rdata type
@type rdtype: int
@param wire: The wire-format message
@type wire: string
@param current: The offset in wire of the beginning of the rdata.
@type current: int
@param rdlen: The length of the wire-format rdata
@type rdlen: int
@param origin: The origin to use for relative names
@type origin: dns.name.Name
@rtype: dns.rdata.Rdata instance
N)r1 )rT r' r( wirecurrentrdlenr2 r r r from_wire s zRdata.from_wirec C s dS )zWConvert any domain names in the rdata to the specified
relativization.
Nr )r) r2 r3 r r r choose_relativity& s zRdata.choose_relativity)NT)NN)N)NT)N)NT)__name__
__module__ __qualname____doc__ __slots__r* r. r0 r5 r8 r; r> rE rF rJ rK rL rN rO rP rQ rS classmethodr= rY rZ r r r r r& w s0
r& c sV e Zd ZdZdgZ fddZdddZedd d
Zdd d Z edd
dZ
Z S ) GenericRdatazGenerate Rdata Class
This class is used for rdata types for which we have no better
implementation. It implements the DNS "unknown RRs" scheme.
r c s t t| j|| || _d S )N)superra r* r )r) r' r( r ) __class__r r r* 8 s zGenericRdata.__init__NTc K s dt | j t| j S )Nz\# %d )r r r )r) r2 r3 r4 r r r r5 < s zGenericRdata.to_textc C s |j }|j s |jdkr(tjjd|j }g }x&|j }|j rHP |j|jj q6W dj
|} t j | }
t
|
|krtjjd| |||
S )Nz\#z$generic rdata does not start with \# z'generic rdata hex data has wrong length)get
is_identifiervaluer+ Z exception SyntaxErrorZget_intZ
is_eol_or_eofappendr r r Z unhexlifyr ) rT r' r( rU r2 r3 tokenZlengthZchunkshexr r r r r= ? s"
zGenericRdata.from_textc C s |j | j d S )N)writer )r) r6 r7 r2 r r r r8 S s zGenericRdata.to_wirec C s | |||||| S )Nr )rT r' r( rV rW rX r2 r r r rY V s zGenericRdata.from_wire)NT)NT)NN)N) r[ r\ r] r^ r_ r* r5 r` r= r8 rY
__classcell__r r )rc r ra . s
ra z dns.rdtypesc C s dd }t j| |f}tjj| }tjj|}|jdd}|st jtjj|f}|sy$|djt ||g}|t | |f< W nV t
k
r y(|djt d|g}|t tjj|f< W n t
k
r d }Y nX Y nX |rt ||}nt }|S )Nc S s6 t | }| jd}x |dd D ]}t||}q W |S )N.r )
__import__splitgetattr)rG modZ
componentscompr r r
import_module` s
z&get_rdata_class..import_module-_rn ANY)
_rdata_modulesre r+ rC r5 r, replacerw r _module_prefix ImportErrorrq ra )r' r( rt rr Z rdclass_textZ rdtype_textrT r r r get_rdata_class^ s. r| Tc C s t |trtjj|}t| |}|tkrx|j }|j| |j rx|j
dkrxtj | ||||}t | ||j
dt|j
|S |j | ||||S )ad Build an rdata object from text format.
This function attempts to dynamically load a class which
implements the specified rdata class and type. If there is no
class-and-type-specific implementation, the GenericRdata class
is used.
Once a class is chosen, its from_text() class method is called
with the parameters to this function.
If I{tok} is a string, then a tokenizer is created and the string
is used as its input.
@param rdclass: The rdata class
@type rdclass: int
@param rdtype: The rdata type
@type rdtype: int
@param tok: The tokenizer or input text
@type tok: dns.tokenizer.Tokenizer or string
@param origin: The origin to use for relative names
@type origin: dns.name.Name
@param relativize: Should names be relativized?
@type relativize: bool
@rtype: dns.rdata.Rdata instancez\#r )r r r+ Z tokenizer Tokenizerr| ra re Zungetrf rg r= rY r r )r' r( rU r2 r3 rT rj r< r r r r= s
r= c C s* t jj|}t| |}|j| |||||S )a> Build an rdata object from wire format
This function attempts to dynamically load a class which
implements the specified rdata class and type. If there is no
class-and-type-specific implementation, the GenericRdata class
is used.
Once a class is chosen, its from_wire() class method is called
with the parameters to this function.
@param rdclass: The rdata class
@type rdclass: int
@param rdtype: The rdata type
@type rdtype: int
@param wire: The wire-format message
@type wire: string
@param current: The offset in wire of the beginning of the rdata.
@type current: int
@param rdlen: The length of the wire-format rdata
@type rdlen: int
@param origin: The origin to use for relative names
@type origin: dns.name.Name
@rtype: dns.rdata.Rdata instance)r+ ZwiredataZ
maybe_wrapr| rY )r' r( rV rW rX r2 rT r r r rY s
rY )NT)N) r^ ior r r Z
dns.exceptionr+ Zdns.nameZdns.rdataclassZ
dns.rdatatypeZ
dns.tokenizerZ dns.wiredataZ_compatr r r Z_hex_chunksizer Z_base64_chunksizer r r r# r% objectr& ra rx rz r| r= rY r r r r s2 8,"
/