a sd_¬¶ã@s2dZddlZddlZddlZddlZddlZddlZddlZddl Zddl Zddl Zddl Zddl ZddlZddlZddlZddlZGdd„dejjƒZGdd„deƒZGdd„deƒZGd d „d eƒZGd d „d ƒZGd d„dƒZdejjdeddddfdd„Zdejjdedddfdd„Zeddfdd„ZdS)z DNS Zones.éNc@seZdZdZdS)ÚBadZonezThe DNS zone is malformed.N©Ú__name__Ú __module__Ú __qualname__Ú__doc__©rrú*/usr/lib/python3/dist-packages/dns/zone.pyr'src@seZdZdZdS)ÚNoSOAz)The DNS zone has no SOA RR at its origin.Nrrrrr r ,sr c@seZdZdZdS)ÚNoNSz+The DNS zone has no NS RRset at its origin.Nrrrrr r 1sr c@seZdZdZdS)Ú UnknownOriginz!The DNS zone's origin is unknown.Nrrrrr r 6sr c@sReZdZdZejjZgd¢Zej j dfdd„Z dd„Z dd „Z d d „Zd d „Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd6d7„Z&d?d8d9„Z'd:d;„Z(d5S)@ÚZoneazA DNS zone. A ``Zone`` is a mapping from names to nodes. The zone object may be treated like a Python dictionary, e.g. ``zone[name]`` will retrieve the node associated with that name. The *name* may be a ``dns.name.Name object``, or it may be a string. In either case, if the name is relative it is treated as relative to the origin of the zone. )ÚrdclassÚoriginÚnodesÚ relativizeTcCsb|durFt|tƒr tj |¡}nt|tjjƒs6tdƒ‚| ¡sFtdƒ‚||_||_ i|_ ||_ dS)aÔInitialize a zone object. *origin* is the origin of the zone. It may be a ``dns.name.Name``, a ``str``, or ``None``. If ``None``, then the zone's origin will be set by the first ``$ORIGIN`` line in a masterfile. *rdclass*, an ``int``, the zone's rdata class; the default is class IN. *relativize*, a ``bool``, determine's whether domain names are relativized to the zone's origin. The default is ``True``. Nz2origin parameter must be convertible to a DNS namez)origin parameter must be an absolute name) Ú isinstanceÚstrÚdnsÚnameÚ from_textÚNameÚ ValueErrorÚ is_absoluterrrr)Úselfrrrrrr Ú__init__Ks  z Zone.__init__cCs:t|tƒsdS|j|jks2|j|jks2|j|jkr6dSdS)zqTwo zones are equal if they have the same origin, class, and nodes. Returns a ``bool``. FT)rr rrr©rÚotherrrr Ú__eq__es   ÿ þz Zone.__eq__cCs | |¡ S)z>Are two zones not equal? Returns a ``bool``. )rrrrr Ú__ne__tsz Zone.__ne__cCsbt|tƒrtj |d¡}nt|tjjƒs0tdƒ‚| ¡r^| |j ¡sLtdƒ‚|j r^|  |j ¡}|S)Nz0name parameter must be convertible to a DNS namez5name parameter must be a subdomain of the zone origin) rrrrrrÚKeyErrorrÚ is_subdomainrr©rrrrr Ú_validate_name|s  ÿ zZone._validate_namecCs| |¡}|j|S©N©r#r©rÚkeyrrr Ú __getitem__‰s zZone.__getitem__cCs| |¡}||j|<dSr$r%)rr'Úvaluerrr Ú __setitem__s zZone.__setitem__cCs| |¡}|j|=dSr$r%r&rrr Ú __delitem__‘s zZone.__delitem__cCs |j ¡Sr$)rÚ__iter__©rrrr r,•sz Zone.__iter__cCs |j ¡Sr$)rÚkeysr-rrr r.˜sz Zone.keyscCs |j ¡Sr$)rÚvaluesr-rrr r/›sz Zone.valuescCs |j ¡Sr$)rÚitemsr-rrr r0žsz Zone.itemscCs| |¡}|j |¡Sr$)r#rÚgetr&rrr r1¡s zZone.getcCs ||jvSr$)rrrrr Ú __contains__¥szZone.__contains__FcCs<| |¡}|j |¡}|dur8|s&t‚| ¡}||j|<|S)aNFind a node in the zone, possibly creating it. *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a ``str``. If absolute, the name must be a subdomain of the zone's origin. If ``zone.relativize`` is ``True``, then the name will be relativized. *create*, a ``bool``. If true, the node will be created if it does not exist. Raises ``KeyError`` if the name is not known and create was not specified, or if the name was not a subdomain of the origin. Returns a ``dns.node.Node``. N)r#rr1r Ú node_factory©rrÚcreateÚnoderrr Ú find_node¨s   zZone.find_nodecCs,z| ||¡}Wnty&d}Yn0|S)aGet a node in the zone, possibly creating it. This method is like ``find_node()``, except it returns None instead of raising an exception if the node does not exist and creation has not been requested. *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a ``str``. If absolute, the name must be a subdomain of the zone's origin. If ``zone.relativize`` is ``True``, then the name will be relativized. *create*, a ``bool``. If true, the node will be created if it does not exist. Raises ``KeyError`` if the name is not known and create was not specified, or if the name was not a subdomain of the origin. Returns a ``dns.node.Node`` or ``None``. N)r7r r4rrr Úget_nodeÂs   z Zone.get_nodecCs | |¡}||jvr|j|=dS)akDelete the specified node if it exists. *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a ``str``. If absolute, the name must be a subdomain of the zone's origin. If ``zone.relativize`` is ``True``, then the name will be relativized. It is not an error if the node does not exist. Nr%r"rrr Ú delete_nodeÝs  zZone.delete_nodecCsL| |¡}tjj |¡}|dur.tjj |¡}| ||¡}| |j|||¡S)a²Look for an rdataset with the specified name and type in the zone, and return an rdataset encapsulating it. The rdataset returned is not a copy; changes to it will change the zone. KeyError is raised if the name or type are not found. *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a ``str``. If absolute, the name must be a subdomain of the zone's origin. If ``zone.relativize`` is ``True``, then the name will be relativized. *rdtype*, an ``int`` or ``str``, the rdata type desired. *covers*, an ``int`` or ``str`` or ``None``, the covered type. Usually this value is ``dns.rdatatype.NONE``, but if the rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``, then the covers value will be the rdata type the SIG/RRSIG covers. The library treats the SIG and RRSIG types as if they were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA). This makes RRSIGs much easier to work with than if RRSIGs covering different rdata types were aggregated into a single RRSIG rdataset. *create*, a ``bool``. If true, the node will be created if it does not exist. Raises ``KeyError`` if the name is not known and create was not specified, or if the name was not a subdomain of the origin. Returns a ``dns.rdataset.Rdataset``. N)r#rÚ rdatatypeÚ RdataTypeÚmaker7Ú find_rdatasetr)rrÚrdtypeÚcoversr5r6rrr r=ìs $  zZone.find_rdatasetcCs0z| ||||¡}Wnty*d}Yn0|S)a Look for an rdataset with the specified name and type in the zone. This method is like ``find_rdataset()``, except it returns None instead of raising an exception if the rdataset does not exist and creation has not been requested. The rdataset returned is not a copy; changes to it will change the zone. *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a ``str``. If absolute, the name must be a subdomain of the zone's origin. If ``zone.relativize`` is ``True``, then the name will be relativized. *rdtype*, an ``int`` or ``str``, the rdata type desired. *covers*, an ``int`` or ``str`` or ``None``, the covered type. Usually this value is ``dns.rdatatype.NONE``, but if the rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``, then the covers value will be the rdata type the SIG/RRSIG covers. The library treats the SIG and RRSIG types as if they were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA). This makes RRSIGs much easier to work with than if RRSIGs covering different rdata types were aggregated into a single RRSIG rdataset. *create*, a ``bool``. If true, the node will be created if it does not exist. Raises ``KeyError`` if the name is not known and create was not specified, or if the name was not a subdomain of the origin. Returns a ``dns.rdataset.Rdataset`` or ``None``. N)r=r )rrr>r?r5Úrdatasetrrr Ú get_rdatasets %  zZone.get_rdatasetcCsj| |¡}tjj |¡}|dur.tjj |¡}| |¡}|durf| |j||¡t|ƒdkrf|  |¡dS)aÁDelete the rdataset matching *rdtype* and *covers*, if it exists at the node specified by *name*. It is not an error if the node does not exist, or if there is no matching rdataset at the node. If the node has no rdatasets after the deletion, it will itself be deleted. *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a ``str``. If absolute, the name must be a subdomain of the zone's origin. If ``zone.relativize`` is ``True``, then the name will be relativized. *rdtype*, an ``int`` or ``str``, the rdata type desired. *covers*, an ``int`` or ``str`` or ``None``, the covered type. Usually this value is ``dns.rdatatype.NONE``, but if the rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``, then the covers value will be the rdata type the SIG/RRSIG covers. The library treats the SIG and RRSIG types as if they were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA). This makes RRSIGs much easier to work with than if RRSIGs covering different rdata types were aggregated into a single RRSIG rdataset. Nr) r#rr:r;r<r8Údelete_rdatasetrÚlenr9)rrr>r?r6rrr rBBs   zZone.delete_rdatasetcCs.|j|jkrtdƒ‚| |d¡}| |¡dS)aÃReplace an rdataset at name. It is not an error if there is no rdataset matching I{replacement}. Ownership of the *replacement* object is transferred to the zone; in other words, this method does not store a copy of *replacement* at the node, it stores *replacement* itself. If the node does not exist, it is created. *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a ``str``. If absolute, the name must be a subdomain of the zone's origin. If ``zone.relativize`` is ``True``, then the name will be relativized. *replacement*, a ``dns.rdataset.Rdataset``, the replacement rdataset. z#replacement.rdclass != zone.rdclassTN)rrr7Úreplace_rdataset)rrZ replacementr6rrr rDhs  zZone.replace_rdatasetcCsf| |¡}tjj |¡}|dur.tjj |¡}|j| |j||¡}tj  ||j||¡}|  |¡|S)a®Look for an rdataset with the specified name and type in the zone, and return an RRset encapsulating it. This method is less efficient than the similar ``find_rdataset()`` because it creates an RRset instead of returning the matching rdataset. It may be more convenient for some uses since it returns an object which binds the owner name to the rdataset. This method may not be used to create new nodes or rdatasets; use ``find_rdataset`` instead. *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a ``str``. If absolute, the name must be a subdomain of the zone's origin. If ``zone.relativize`` is ``True``, then the name will be relativized. *rdtype*, an ``int`` or ``str``, the rdata type desired. *covers*, an ``int`` or ``str`` or ``None``, the covered type. Usually this value is ``dns.rdatatype.NONE``, but if the rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``, then the covers value will be the rdata type the SIG/RRSIG covers. The library treats the SIG and RRSIG types as if they were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA). This makes RRSIGs much easier to work with than if RRSIGs covering different rdata types were aggregated into a single RRSIG rdataset. *create*, a ``bool``. If true, the node will be created if it does not exist. Raises ``KeyError`` if the name is not known and create was not specified, or if the name was not a subdomain of the origin. Returns a ``dns.rrset.RRset`` or ``None``. N) r#rr:r;r<rr=rÚrrsetZRRsetÚupdate)rrr>r?r@rErrr Ú find_rrset€s'  zZone.find_rrsetcCs.z| |||¡}Wnty(d}Yn0|S)a¦Look for an rdataset with the specified name and type in the zone, and return an RRset encapsulating it. This method is less efficient than the similar ``get_rdataset()`` because it creates an RRset instead of returning the matching rdataset. It may be more convenient for some uses since it returns an object which binds the owner name to the rdataset. This method may not be used to create new nodes or rdatasets; use ``get_rdataset()`` instead. *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a ``str``. If absolute, the name must be a subdomain of the zone's origin. If ``zone.relativize`` is ``True``, then the name will be relativized. *rdtype*, an ``int`` or ``str``, the rdata type desired. *covers*, an ``int`` or ``str`` or ``None``, the covered type. Usually this value is ``dns.rdatatype.NONE``, but if the rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``, then the covers value will be the rdata type the SIG/RRSIG covers. The library treats the SIG and RRSIG types as if they were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA). This makes RRSIGs much easier to work with than if RRSIGs covering different rdata types were aggregated into a single RRSIG rdataset. *create*, a ``bool``. If true, the node will be created if it does not exist. Raises ``KeyError`` if the name is not known and create was not specified, or if the name was not a subdomain of the origin. Returns a ``dns.rrset.RRset`` or ``None``. N)rGr )rrr>r?rErrr Ú get_rrset°s &  zZone.get_rrsetccsntjj |¡}|dur$tjj |¡}| ¡D]<\}}|D].}|tjjks\|j|kr8|j|kr8||fVq8q,dS)a|Return a generator which yields (name, rdataset) tuples for all rdatasets in the zone which have the specified *rdtype* and *covers*. If *rdtype* is ``dns.rdatatype.ANY``, the default, then all rdatasets will be matched. *rdtype*, an ``int`` or ``str``, the rdata type desired. *covers*, an ``int`` or ``str`` or ``None``, the covered type. Usually this value is ``dns.rdatatype.NONE``, but if the rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``, then the covers value will be the rdata type the SIG/RRSIG covers. The library treats the SIG and RRSIG types as if they were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA). This makes RRSIGs much easier to work with than if RRSIGs covering different rdata types were aggregated into a single RRSIG rdataset. N)rr:r;r<r0ÚANYr>r?)rr>r?rr6Úrdsrrr Úiterate_rdatasetsÜs ÿÿzZone.iterate_rdatasetsccs|tjj |¡}|dur$tjj |¡}| ¡D]J\}}|D]<}|tjjks\|j|kr8|j|kr8|D]}||j|fVq`q8q,dS)axReturn a generator which yields (name, ttl, rdata) tuples for all rdatas in the zone which have the specified *rdtype* and *covers*. If *rdtype* is ``dns.rdatatype.ANY``, the default, then all rdatas will be matched. *rdtype*, an ``int`` or ``str``, the rdata type desired. *covers*, an ``int`` or ``str`` or ``None``, the covered type. Usually this value is ``dns.rdatatype.NONE``, but if the rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``, then the covers value will be the rdata type the SIG/RRSIG covers. The library treats the SIG and RRSIG types as if they were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA). This makes RRSIGs much easier to work with than if RRSIGs covering different rdata types were aggregated into a single RRSIG rdataset. N) rr:r;r<r0rIr>r?Úttl)rr>r?rr6rJÚrdatarrr Úiterate_rdatasùs ÿÿzZone.iterate_rdatasNc CsDt ¡$}t|tƒr&| t|dƒ¡}t|ddƒ}|dur>d}|durXtj  |¡}d}n"t|tƒrn|  |¡}n |}|  ¡}|r”t |  ¡ƒ}|  ¡n|  ¡}|D]~} || j| |j|d} t| tƒrÐ|   |¡} n | } |   ¡} z| | ¡| |¡Wq ty| | ¡| |¡Yq 0q Wdƒn1s60YdS)a÷Write a zone to a file. *f*, a file or `str`. If *f* is a string, it is treated as the name of a file to open. *sorted*, a ``bool``. If True, the default, then the file will be written with the names sorted in DNSSEC order from least to greatest. Otherwise the names will be written in whatever order they happen to have in the zone's dictionary. *relativize*, a ``bool``. If True, the default, then domain names in the output will be relativized to the zone's origin if possible. *nl*, a ``str`` or None. The end of line string. If not ``None``, the output will use the platform's native end-of-line marker (i.e. LF on POSIX, CRLF on Windows). ÚwbÚencodingNzutf-8Ú )rr)Ú contextlibÚ ExitStackrrÚ enter_contextÚopenÚgetattrÚosÚlinesepÚencodeÚdecodeÚlistr.ÚsortÚto_textrÚwriteÚ TypeError) rÚfÚsortedrÚnlÚstackZfile_encZnl_bÚnamesÚnÚlZl_brrr Úto_files>        ÿ    z Zone.to_filecCs,t ¡}| ||||¡| ¡}| ¡|S)aÌReturn a zone's text as though it were written to a file. *sorted*, a ``bool``. If True, the default, then the file will be written with the names sorted in DNSSEC order from least to greatest. Otherwise the names will be written in whatever order they happen to have in the zone's dictionary. *relativize*, a ``bool``. If True, the default, then domain names in the output will be relativized to the zone's origin if possible. *nl*, a ``str`` or None. The end of line string. If not ``None``, the output will use the platform's native end-of-line marker (i.e. LF on POSIX, CRLF on Windows). Returns a ``str``. )ÚioÚStringIOrgÚgetvalueÚclose)rrarrbZ temp_bufferZ return_valuerrr r]Ts z Zone.to_textcCsJ|jrtjj}n|j}| |tjj¡dur.t‚| |tjj ¡durFt ‚dS)zçDo some simple checking of the zone's origin. Raises ``dns.zone.NoSOA`` if there is no SOA RRset. Raises ``dns.zone.NoNS`` if there is no NS RRset. Raises ``KeyError`` if there is no origin node. N) rrrÚemptyrrAr:ÚSOAr ZNSr r"rrr Ú check_originls  zZone.check_origin)F)F)TTN)TTN))rrrrrr6ZNoder3Ú __slots__Ú rdataclassÚINrrrr#r(r*r+r,r.r/r0r1r2r7r8r9r:ZNONEr=rArBrDrGrHrIrKrNrgr]rnrrrr r ;sL    ÿ +ÿ +&0,ÿ ÿ  = r c@sHeZdZdZeddfdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dS)Ú _MasterReadera(Read a DNS master file @ivar tok: The tokenizer @type tok: dns.tokenizer.Tokenizer object @ivar last_ttl: The last seen explicit TTL for an RR @type last_ttl: int @ivar last_ttl_known: Has last TTL been detected @type last_ttl_known: bool @ivar default_ttl: The default TTL from a $TTL directive or SOA RR @type default_ttl: int @ivar default_ttl_known: Has default TTL been detected @type default_ttl_known: bool @ivar last_name: The last name read @type last_name: dns.name.Name object @ivar current_origin: The current origin @type current_origin: dns.name.Name object @ivar relativize: should names in the zone be relativized? @type relativize: bool @ivar zone: the zone @type zone: dns.zone.Zone object @ivar saved_state: saved reader state (used when processing $INCLUDE) @type saved_state: list of (tokenizer, current_origin, last_name, file, last_ttl, last_ttl_known, default_ttl, default_ttl_known) tuples. @ivar current_file: the file object of the $INCLUDed file being parsed (None if no $INCLUDE is active). @ivar allow_include: is $INCLUDE allowed? @type allow_include: bool @ivar check_origin: should sanity checks of the origin node be done? The default is True. @type check_origin: bool FTcCstt|tƒrtj |¡}||_||_||_d|_d|_ d|_ d|_ |j|_ ||||d|_ g|_d|_||_||_dS)NrF©r)rrrrrÚtokÚcurrent_originrÚlast_ttlÚlast_ttl_knownÚ default_ttlÚdefault_ttl_knownÚ last_nameÚzoneÚ saved_stateÚ current_fileÚ allow_includern)rrtrrrÚ zone_factoryr~rnrrr r¡s  z_MasterReader.__init__cCs|j ¡}| ¡rqqdSr$)rtr1Ú is_eol_or_eof)rÚtokenrrr Ú _eat_line³s z_MasterReader._eat_linec Csö|jdurt‚|jjdd}| ¡s8|j ||j¡|_n"|j ¡}| ¡rNdS|j |¡|j}|  |j j ¡sz|  ¡dS|j rŽ|  |j j ¡}|j ¡}| ¡s¨tjj‚d}z8tj |j¡}||_d|_|j ¡}| ¡sâtjj‚Wn6tjjy|jr|j}n|jr|j}Yn0z.tj |j¡}|j ¡}| ¡sHtjj‚Wn4tjjyd‚Ynty~|j j}Yn0||j jkrštj d¡‚ztj |j¡}Wn&tyÒtj d|j¡‚Yn0|j j |¡}|dur|j  ¡}||j j|<z$tj  |||j|j|j |j j ¡}Wn\tjjy@‚YnDty‚t! "¡dd…\}} tj d #t$|ƒt$| ƒ¡¡‚Yn0|js¸|tjj%kr¸|j&|_d|_|dur¸|j&}|durÎtj d¡‚| '¡} | (||| d¡} |  )||¡dS) z(Process one line from a DNS master file.NT)Z want_leadingúRR class is not zone's classúunknown rdatatype '%s'ézcaught exception {}: {}úMissing default TTL value)*rur rtr1Z is_whitespaceZas_namerzr€Úungetr!r{rr‚rÚ is_identifierrÚ exceptionÚ SyntaxErrorrLrr)rvrwÚBadTTLryrxrpÚ Exceptionrr:rr3rMÚsysÚexc_infoÚformatrrmZminimumr?r=Úadd) rrrrLrr>reÚrdÚtyÚvar?rJrrr Ú_rr_line¹s”           ÿ    þÿ    z_MasterReader._rr_linec Csät d¡}t d¡}t d¡}| |¡}|rJ| ¡\}}}} } |dkrJd}| |¡} | rz|  ¡\}}}|dkrrd}d} d} | |¡} | r¨|  ¡\}}}} |dkr¤d}d} |sÈ| sÈ| sÈd}d}d}d} d} | dkrÖtƒ‚|||| | fS)Nz"^.*\$({(\+|-?)(\d+),(\d+),(.)}).*$z^.*\$({(\+|-?)(\d+)}).*$z^.*\$({(\+|-?)(\d+),(\d+)}).*$Úú+rÚd)ÚreÚcompileÚmatchÚgroupsÚNotImplementedError) rZsideZ is_generate1Z is_generate2Z is_generate3Zg1ÚmodZsignÚoffsetÚwidthÚbaseZg2Zg3rrr Ú _parse_modifys<       z_MasterReader._parse_modifyc! Cs|jdurt‚|j ¡}z2tj |j¡\}}}|j ¡}| ¡sHtj j ‚Wnt ydtj j ‚Yn0z$|j}|j ¡}| ¡sˆtj j ‚Wnt y¤tj j ‚Yn0z8tj  |j¡}||_ d|_|j ¡}| ¡sÜtj j ‚WnRtj jy0|js|jstj   d¡‚|jr|j}n|jr,|j }Yn0z.tj |j¡}|j ¡}| ¡s^tj j ‚Wn:tj j y€tj j ‚Ynt yš|jj}Yn0||jjkr¶tj   d¡‚z.tj |j¡}|j ¡}| ¡sâtj j ‚Wn&t y tj   d|j¡‚Yn0|j} | |¡\} } } } }| | ¡\}}}}}t||d|ƒD]Ê}| dkrh|t| ƒ}n| dkr~|t| ƒ}|dkr–|t|ƒ}n|dkr¬|t|ƒ}t|ƒ t| ƒ¡}t|ƒ t|ƒ¡}| d | |¡}|  d ||¡}tj ||j|jj¡|_|j}| |jj ¡s,| !¡dS|j"rB| "|jj ¡}|jj# |¡}|durp|j $¡}||jj#|<z"tj% ||||j|j"|jj ¡}Wn\tj j y¬‚YnDt yît& '¡dd …\}}tj   d t|ƒt|ƒf¡‚Yn0| (¡}| )|||d¡} |  *||¡qJdS) zRProcess one line containing the GENERATE statement from a DNS master file.NTr†rƒr„ér–ú-z$%sr…zcaught exception %s: %s)+rur rtr1rZgrangerr)rˆr‰rŠrŒrLrvrwr‹ryrxrpr{rr:r¡ÚrangeÚintrÚzfillÚreplacerÚ idna_codecrzr!rr‚rrr3rMrrŽr?r=r)!rrÚstartÚstopÚstepZlhsrLrr>ZrhsZlmodZlsignZloffsetZlwidthZlbaseZrmodZrsignZroffsetZrwidthZrbaseÚiZlindexÚrindexZlzfindexZrzfindexrrMrer‘r’r“r?rJrrr Ú_generate_lineBs¾                    ÿ        ÿ    þÿ z_MasterReader._generate_linec CsÌz>|j dd¡}| ¡rr|jdur.|j ¡t|jƒdkrj|j d¡\|_|_|_ |_|_ |_ |_ |_ qq>n¶| ¡r€qn¨| ¡r˜|j ¡qn|jddkr(|j ¡}|dkrú|j ¡}| ¡sØtj d¡‚tj |j¡|_ d|_ |j ¡q|dkr4|j ¡|_|j ¡|jjdur&|j|j_q|d krþ|jrþ|j ¡}|j}|j ¡}| ¡rŽtj |j|j|jj¡}|j ¡n| ¡s¦tj d ¡‚n|j}|j  |j|j|j |j|j |j |j |j f¡t!|d ƒ|_tj" #|j|¡|_||_q|d kr| $¡qtj d |d¡‚q|j %|¡| &¡qWnttjjy´}zV|j '¡\}}|durrd}tj d|||f¡}t( )¡d}| *|¡d‚WYd}~n d}~00|j+rÈ|j +¡dS)zÈRead a DNS master file and build a zone object. @raises dns.zone.NoSOA: No SOA RR was found at the zone origin @raises dns.zone.NoNS: No NS RRset was found at the zone origin TNréÿÿÿÿú$z$TTLzbad $TTLz$ORIGINz$INCLUDEzbad origin in $INCLUDEÚrz $GENERATEzUnknown master file directive 'ú'z syntax errorz %s:%d: %sr…),rtr1Zis_eofr}rkrCr|ÚpoprurzrvrwrxryZis_eolZ is_commentZget_eolr)Úupperrˆrr‰rŠrLrZget_namer{rr~rr¨r€ÚappendrUÚ tokenizerÚ Tokenizerr®r‡r”ÚwhererrŽÚwith_tracebackrn) rrÚcÚfilenameZ new_originZdetailZ line_numberÚexÚtbrrr Úread»sª   ù             þÿ  ÿ ù  ÿ   ÿ   ÿ "z_MasterReader.readN) rrrrr rr‚r”r¡r®r¾rrrr rrs ÿ a(yrrTFc CsB|dur d}tjj|||d} t| ||||||d} |  ¡| jS)a6Build a zone object from a master file format string. *text*, a ``str``, the master file format input. *origin*, a ``dns.name.Name``, a ``str``, or ``None``. The origin of the zone; if not specified, the first ``$ORIGIN`` statement in the masterfile will determine the origin of the zone. *rdclass*, an ``int``, the zone's rdata class; the default is class IN. *relativize*, a ``bool``, determine's whether domain names are relativized to the zone's origin. The default is ``True``. *zone_factory*, the zone factory to use or ``None``. If ``None``, then ``dns.zone.Zone`` will be used. The value may be any class or callable that returns a subclass of ``dns.zone.Zone``. *filename*, a ``str`` or ``None``, the filename to emit when describing where an error occurred; the default is ``''``. *allow_include*, a ``bool``. If ``True``, the default, then ``$INCLUDE`` directives are permitted. If ``False``, then encoutering a ``$INCLUDE`` will raise a ``SyntaxError`` exception. *check_origin*, a ``bool``. If ``True``, the default, then sanity checks of the origin node will be made by calling the zone's ``check_origin()`` method. *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA encoder/decoder. If ``None``, the default IDNA 2003 encoder/decoder is used. Raises ``dns.zone.NoSOA`` if there is no SOA RRset. Raises ``dns.zone.NoNS`` if there is no NS RRset. Raises ``KeyError`` if there is no origin node. Returns a subclass of ``dns.zone.Zone``. Nz)r¨)r~rn)rr¶r·rrr¾r{) Útextrrrrr»r~rnr¨rtÚreaderrrr rs0 þrc Csft ¡J}t|tƒr.|dur |}| t|ƒ¡}t||||||||ƒWdƒS1sX0YdS)aYRead a master file and build a zone object. *f*, a file or ``str``. If *f* is a string, it is treated as the name of a file to open. *origin*, a ``dns.name.Name``, a ``str``, or ``None``. The origin of the zone; if not specified, the first ``$ORIGIN`` statement in the masterfile will determine the origin of the zone. *rdclass*, an ``int``, the zone's rdata class; the default is class IN. *relativize*, a ``bool``, determine's whether domain names are relativized to the zone's origin. The default is ``True``. *zone_factory*, the zone factory to use or ``None``. If ``None``, then ``dns.zone.Zone`` will be used. The value may be any class or callable that returns a subclass of ``dns.zone.Zone``. *filename*, a ``str`` or ``None``, the filename to emit when describing where an error occurred; the default is ``''``. *allow_include*, a ``bool``. If ``True``, the default, then ``$INCLUDE`` directives are permitted. If ``False``, then encoutering a ``$INCLUDE`` will raise a ``SyntaxError`` exception. *check_origin*, a ``bool``. If ``True``, the default, then sanity checks of the origin node will be made by calling the zone's ``check_origin()`` method. *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA encoder/decoder. If ``None``, the default IDNA 2003 encoder/decoder is used. Raises ``dns.zone.NoSOA`` if there is no SOA RRset. Raises ``dns.zone.NoNS`` if there is no NS RRset. Raises ``KeyError`` if there is no origin node. Returns a subclass of ``dns.zone.Zone``. N)rRrSrrrTrUr) r`rrrrr»r~rnrcrrr Ú from_fileQs-   ÿrÁc CsÀd}|D]¦}|durF|r |j}n |jdj}|jdj}||||d}|jD]`}|j |j¡} | sv| ¡} | |j|j<|  |j|j|j d¡} |   |j ¡|D]} |   | ¡qœqLq|r¼|  ¡|S)aConvert the output of a zone transfer generator into a zone object. *xfr*, a generator of ``dns.message.Message`` objects, typically ``dns.query.xfr()``. *relativize*, a ``bool``, determine's whether domain names are relativized to the zone's origin. The default is ``True``. It is essential that the relativize setting matches the one specified to the generator. *check_origin*, a ``bool``. If ``True``, the default, then sanity checks of the origin node will be made by calling the zone's ``check_origin()`` method. Raises ``dns.zone.NoSOA`` if there is no SOA RRset. Raises ``dns.zone.NoNS`` if there is no NS RRset. Raises ``KeyError`` if there is no origin node. Returns a subclass of ``dns.zone.Zone``. NrrsT)rZanswerrrrr1r3r=r>r?Z update_ttlrLrrn) ZxfrrrrnÚzr±rrrEZznodeZzrdsr‘rrr Úfrom_xfr‡s,     ÿ rÃ)rrRrhrWr˜rZ dns.exceptionrZdns.nameZdns.nodeZdns.rdataclassZ dns.rdatatypeZ dns.rdataZdns.rdtypes.ANY.SOAZ dns.rrsetZ dns.tokenizerZdns.ttlZ dns.granger‰Z DNSExceptionrr r r r rrrprqrrÁrÃrrrr ÚsLHþ :þ 6