lib/dnspython/dns/zone.py

   1 # Copyright (C) 2003-2007, 2009, 2010 Nominum, Inc.
   2 #
   3 # Permission to use, copy, modify, and distribute this software and its
   4 # documentation for any purpose with or without fee is hereby granted,
   5 # provided that the above copyright notice and this permission notice
   6 # appear in all copies.
   7 #
   8 # THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
   9 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
  11 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  14 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15
  16 """DNS Zones."""
  17
  18 from __future__ import generators
  19
  20 import sys
  21
  22 import dns.exception
  23 import dns.name
  24 import dns.node
  25 import dns.rdataclass
  26 import dns.rdatatype
  27 import dns.rdata
  28 import dns.rrset
  29 import dns.tokenizer
  30 import dns.ttl
  31
  32 class BadZone(dns.exception.DNSException):
  33     """The zone is malformed."""
  34     pass
  35
  36 class NoSOA(BadZone):
  37     """The zone has no SOA RR at its origin."""
  38     pass
  39
  40 class NoNS(BadZone):
  41     """The zone has no NS RRset at its origin."""
  42     pass
  43
  44 class UnknownOrigin(BadZone):
  45     """The zone's origin is unknown."""
  46     pass
  47
  48 class Zone(object):
  49     """A DNS zone.
  50
  51     A Zone is a mapping from names to nodes.  The zone object may be
  52     treated like a Python dictionary, e.g. zone[name] will retrieve
  53     the node associated with that name.  The I{name} may be a
  54     dns.name.Name object, or it may be a string.  In the either case,
  55     if the name is relative it is treated as relative to the origin of
  56     the zone.
  57
  58     @ivar rdclass: The zone's rdata class; the default is class IN.
  59     @type rdclass: int
  60     @ivar origin: The origin of the zone.
  61     @type origin: dns.name.Name object
  62     @ivar nodes: A dictionary mapping the names of nodes in the zone to the
  63     nodes themselves.
  64     @type nodes: dict
  65     @ivar relativize: should names in the zone be relativized?
  66     @type relativize: bool
  67     @cvar node_factory: the factory used to create a new node
  68     @type node_factory: class or callable
  69     """
  70
  71     node_factory = dns.node.Node
  72
  73     __slots__ = ['rdclass', 'origin', 'nodes', 'relativize']
  74
  75     def __init__(self, origin, rdclass=dns.rdataclass.IN, relativize=True):
  76         """Initialize a zone object.
  77
  78         @param origin: The origin of the zone.
  79         @type origin: dns.name.Name object
  80         @param rdclass: The zone's rdata class; the default is class IN.
  81         @type rdclass: int"""
  82
  83         self.rdclass = rdclass
  84         self.origin = origin
  85         self.nodes = {}
  86         self.relativize = relativize
  87
  88     def __eq__(self, other):
  89         """Two zones are equal if they have the same origin, class, and
  90         nodes.
  91         @rtype: bool
  92         """
  93
  94         if not isinstance(other, Zone):
  95             return False
  96         if self.rdclass != other.rdclass or \
  97            self.origin != other.origin or \
  98            self.nodes != other.nodes:
  99             return False
 100         return True
 101
 102     def __ne__(self, other):
 103         """Are two zones not equal?
 104         @rtype: bool
 105         """
 106
 107         return not self.__eq__(other)
 108
 109     def _validate_name(self, name):
 110         if isinstance(name, (str, unicode)):
 111             name = dns.name.from_text(name, None)
 112         elif not isinstance(name, dns.name.Name):
 113             raise KeyError("name parameter must be convertable to a DNS name")
 114         if name.is_absolute():
 115             if not name.is_subdomain(self.origin):
 116                 raise KeyError("name parameter must be a subdomain of the zone origin")
 117             if self.relativize:
 118                 name = name.relativize(self.origin)
 119         return name
 120
 121     def __getitem__(self, key):
 122         key = self._validate_name(key)
 123         return self.nodes[key]
 124
 125     def __setitem__(self, key, value):
 126         key = self._validate_name(key)
 127         self.nodes[key] = value
 128
 129     def __delitem__(self, key):
 130         key = self._validate_name(key)
 131         del self.nodes[key]
 132
 133     def __iter__(self):
 134         return self.nodes.iterkeys()
 135
 136     def iterkeys(self):
 137         return self.nodes.iterkeys()
 138
 139     def keys(self):
 140         return self.nodes.keys()
 141
 142     def itervalues(self):
 143         return self.nodes.itervalues()
 144
 145     def values(self):
 146         return self.nodes.values()
 147
 148     def iteritems(self):
 149         return self.nodes.iteritems()
 150
 151     def items(self):
 152         return self.nodes.items()
 153
 154     def get(self, key):
 155         key = self._validate_name(key)
 156         return self.nodes.get(key)
 157
 158     def __contains__(self, other):
 159         return other in self.nodes
 160
 161     def find_node(self, name, create=False):
 162         """Find a node in the zone, possibly creating it.
 163
 164         @param name: the name of the node to find
 165         @type name: dns.name.Name object or string
 166         @param create: should the node be created if it doesn't exist?
 167         @type create: bool
 168         @raises KeyError: the name is not known and create was not specified.
 169         @rtype: dns.node.Node object
 170         """
 171
 172         name = self._validate_name(name)
 173         node = self.nodes.get(name)
 174         if node is None:
 175             if not create:
 176                 raise KeyError
 177             node = self.node_factory()
 178             self.nodes[name] = node
 179         return node
 180
 181     def get_node(self, name, create=False):
 182         """Get a node in the zone, possibly creating it.
 183
 184         This method is like L{find_node}, except it returns None instead
 185         of raising an exception if the node does not exist and creation
 186         has not been requested.
 187
 188         @param name: the name of the node to find
 189         @type name: dns.name.Name object or string
 190         @param create: should the node be created if it doesn't exist?
 191         @type create: bool
 192         @rtype: dns.node.Node object or None
 193         """
 194
 195         try:
 196             node = self.find_node(name, create)
 197         except KeyError:
 198             node = None
 199         return node
 200
 201     def delete_node(self, name):
 202         """Delete the specified node if it exists.
 203
 204         It is not an error if the node does not exist.
 205         """
 206
 207         name = self._validate_name(name)
 208         if self.nodes.has_key(name):
 209             del self.nodes[name]
 210
 211     def find_rdataset(self, name, rdtype, covers=dns.rdatatype.NONE,
 212                       create=False):
 213         """Look for rdata with the specified name and type in the zone,
 214         and return an rdataset encapsulating it.
 215
 216         The I{name}, I{rdtype}, and I{covers} parameters may be
 217         strings, in which case they will be converted to their proper
 218         type.
 219
 220         The rdataset returned is not a copy; changes to it will change
 221         the zone.
 222
 223         KeyError is raised if the name or type are not found.
 224         Use L{get_rdataset} if you want to have None returned instead.
 225
 226         @param name: the owner name to look for
 227         @type name: DNS.name.Name object or string
 228         @param rdtype: the rdata type desired
 229         @type rdtype: int or string
 230         @param covers: the covered type (defaults to None)
 231         @type covers: int or string
 232         @param create: should the node and rdataset be created if they do not
 233         exist?
 234         @type create: bool
 235         @raises KeyError: the node or rdata could not be found
 236         @rtype: dns.rrset.RRset object
 237         """
 238
 239         name = self._validate_name(name)
 240         if isinstance(rdtype, (str, unicode)):
 241             rdtype = dns.rdatatype.from_text(rdtype)
 242         if isinstance(covers, (str, unicode)):
 243             covers = dns.rdatatype.from_text(covers)
 244         node = self.find_node(name, create)
 245         return node.find_rdataset(self.rdclass, rdtype, covers, create)
 246
 247     def get_rdataset(self, name, rdtype, covers=dns.rdatatype.NONE,
 248                      create=False):
 249         """Look for rdata with the specified name and type in the zone,
 250         and return an rdataset encapsulating it.
 251
 252         The I{name}, I{rdtype}, and I{covers} parameters may be
 253         strings, in which case they will be converted to their proper
 254         type.
 255
 256         The rdataset returned is not a copy; changes to it will change
 257         the zone.
 258
 259         None is returned if the name or type are not found.
 260         Use L{find_rdataset} if you want to have KeyError raised instead.
 261
 262         @param name: the owner name to look for
 263         @type name: DNS.name.Name object or string
 264         @param rdtype: the rdata type desired
 265         @type rdtype: int or string
 266         @param covers: the covered type (defaults to None)
 267         @type covers: int or string
 268         @param create: should the node and rdataset be created if they do not
 269         exist?
 270         @type create: bool
 271         @rtype: dns.rrset.RRset object
 272         """
 273
 274         try:
 275             rdataset = self.find_rdataset(name, rdtype, covers, create)
 276         except KeyError:
 277             rdataset = None
 278         return rdataset
 279
 280     def delete_rdataset(self, name, rdtype, covers=dns.rdatatype.NONE):
 281         """Delete the rdataset matching I{rdtype} and I{covers}, if it
 282         exists at the node specified by I{name}.
 283
 284         The I{name}, I{rdtype}, and I{covers} parameters may be
 285         strings, in which case they will be converted to their proper
 286         type.
 287
 288         It is not an error if the node does not exist, or if there is no
 289         matching rdataset at the node.
 290
 291         If the node has no rdatasets after the deletion, it will itself
 292         be deleted.
 293
 294         @param name: the owner name to look for
 295         @type name: DNS.name.Name object or string
 296         @param rdtype: the rdata type desired
 297         @type rdtype: int or string
 298         @param covers: the covered type (defaults to None)
 299         @type covers: int or string
 300         """
 301
 302         name = self._validate_name(name)
 303         if isinstance(rdtype, (str, unicode)):
 304             rdtype = dns.rdatatype.from_text(rdtype)
 305         if isinstance(covers, (str, unicode)):
 306             covers = dns.rdatatype.from_text(covers)
 307         node = self.get_node(name)
 308         if not node is None:
 309             node.delete_rdataset(self.rdclass, rdtype, covers)
 310             if len(node) == 0:
 311                 self.delete_node(name)
 312
 313     def replace_rdataset(self, name, replacement):
 314         """Replace an rdataset at name.
 315
 316         It is not an error if there is no rdataset matching I{replacement}.
 317
 318         Ownership of the I{replacement} object is transferred to the zone;
 319         in other words, this method does not store a copy of I{replacement}
 320         at the node, it stores I{replacement} itself.
 321
 322         If the I{name} node does not exist, it is created.
 323
 324         @param name: the owner name
 325         @type name: DNS.name.Name object or string
 326         @param replacement: the replacement rdataset
 327         @type replacement: dns.rdataset.Rdataset
 328         """
 329
 330         if replacement.rdclass != self.rdclass:
 331             raise ValueError('replacement.rdclass != zone.rdclass')
 332         node = self.find_node(name, True)
 333         node.replace_rdataset(replacement)
 334
 335     def find_rrset(self, name, rdtype, covers=dns.rdatatype.NONE):
 336         """Look for rdata with the specified name and type in the zone,
 337         and return an RRset encapsulating it.
 338
 339         The I{name}, I{rdtype}, and I{covers} parameters may be
 340         strings, in which case they will be converted to their proper
 341         type.
 342
 343         This method is less efficient than the similar
 344         L{find_rdataset} because it creates an RRset instead of
 345         returning the matching rdataset.  It may be more convenient
 346         for some uses since it returns an object which binds the owner
 347         name to the rdata.
 348
 349         This method may not be used to create new nodes or rdatasets;
 350         use L{find_rdataset} instead.
 351
 352         KeyError is raised if the name or type are not found.
 353         Use L{get_rrset} if you want to have None returned instead.
 354
 355         @param name: the owner name to look for
 356         @type name: DNS.name.Name object or string
 357         @param rdtype: the rdata type desired
 358         @type rdtype: int or string
 359         @param covers: the covered type (defaults to None)
 360         @type covers: int or string
 361         @raises KeyError: the node or rdata could not be found
 362         @rtype: dns.rrset.RRset object
 363         """
 364
 365         name = self._validate_name(name)
 366         if isinstance(rdtype, (str, unicode)):
 367             rdtype = dns.rdatatype.from_text(rdtype)
 368         if isinstance(covers, (str, unicode)):
 369             covers = dns.rdatatype.from_text(covers)
 370         rdataset = self.nodes[name].find_rdataset(self.rdclass, rdtype, covers)
 371         rrset = dns.rrset.RRset(name, self.rdclass, rdtype, covers)
 372         rrset.update(rdataset)
 373         return rrset
 374
 375     def get_rrset(self, name, rdtype, covers=dns.rdatatype.NONE):
 376         """Look for rdata with the specified name and type in the zone,
 377         and return an RRset encapsulating it.
 378
 379         The I{name}, I{rdtype}, and I{covers} parameters may be
 380         strings, in which case they will be converted to their proper
 381         type.
 382
 383         This method is less efficient than the similar L{get_rdataset}
 384         because it creates an RRset instead of returning the matching
 385         rdataset.  It may be more convenient for some uses since it
 386         returns an object which binds the owner name to the rdata.
 387
 388         This method may not be used to create new nodes or rdatasets;
 389         use L{find_rdataset} instead.
 390
 391         None is returned if the name or type are not found.
 392         Use L{find_rrset} if you want to have KeyError raised instead.
 393
 394         @param name: the owner name to look for
 395         @type name: DNS.name.Name object or string
 396         @param rdtype: the rdata type desired
 397         @type rdtype: int or string
 398         @param covers: the covered type (defaults to None)
 399         @type covers: int or string
 400         @rtype: dns.rrset.RRset object
 401         """
 402
 403         try:
 404             rrset = self.find_rrset(name, rdtype, covers)
 405         except KeyError:
 406             rrset = None
 407         return rrset
 408
 409     def iterate_rdatasets(self, rdtype=dns.rdatatype.ANY,
 410                           covers=dns.rdatatype.NONE):
 411         """Return a generator which yields (name, rdataset) tuples for
 412         all rdatasets in the zone which have the specified I{rdtype}
 413         and I{covers}.  If I{rdtype} is dns.rdatatype.ANY, the default,
 414         then all rdatasets will be matched.
 415
 416         @param rdtype: int or string
 417         @type rdtype: int or string
 418         @param covers: the covered type (defaults to None)
 419         @type covers: int or string
 420         """
 421
 422         if isinstance(rdtype, (str, unicode)):
 423             rdtype = dns.rdatatype.from_text(rdtype)
 424         if isinstance(covers, (str, unicode)):
 425             covers = dns.rdatatype.from_text(covers)
 426         for (name, node) in self.iteritems():
 427             for rds in node:
 428                 if rdtype == dns.rdatatype.ANY or \
 429                    (rds.rdtype == rdtype and rds.covers == covers):
 430                     yield (name, rds)
 431
 432     def iterate_rdatas(self, rdtype=dns.rdatatype.ANY,
 433                        covers=dns.rdatatype.NONE):
 434         """Return a generator which yields (name, ttl, rdata) tuples for
 435         all rdatas in the zone which have the specified I{rdtype}
 436         and I{covers}.  If I{rdtype} is dns.rdatatype.ANY, the default,
 437         then all rdatas will be matched.
 438
 439         @param rdtype: int or string
 440         @type rdtype: int or string
 441         @param covers: the covered type (defaults to None)
 442         @type covers: int or string
 443         """
 444
 445         if isinstance(rdtype, (str, unicode)):
 446             rdtype = dns.rdatatype.from_text(rdtype)
 447         if isinstance(covers, (str, unicode)):
 448             covers = dns.rdatatype.from_text(covers)
 449         for (name, node) in self.iteritems():
 450             for rds in node:
 451                 if rdtype == dns.rdatatype.ANY or \
 452                    (rds.rdtype == rdtype and rds.covers == covers):
 453                     for rdata in rds:
 454                         yield (name, rds.ttl, rdata)
 455
 456     def to_file(self, f, sorted=True, relativize=True, nl=None):
 457         """Write a zone to a file.
 458
 459         @param f: file or string.  If I{f} is a string, it is treated
 460         as the name of a file to open.
 461         @param sorted: if True, the file will be written with the
 462         names sorted in DNSSEC order from least to greatest.  Otherwise
 463         the names will be written in whatever order they happen to have
 464         in the zone's dictionary.
 465         @param relativize: if True, domain names in the output will be
 466         relativized to the zone's origin (if possible).
 467         @type relativize: bool
 468         @param nl: The end of line string.  If not specified, the
 469         output will use the platform's native end-of-line marker (i.e.
 470         LF on POSIX, CRLF on Windows, CR on Macintosh).
 471         @type nl: string or None
 472         """
 473
 474         if sys.hexversion >= 0x02030000:
 475             # allow Unicode filenames
 476             str_type = basestring
 477         else:
 478             str_type = str
 479         if nl is None:
 480             opts = 'w'
 481         else:
 482             opts = 'wb'
 483         if isinstance(f, str_type):
 484             f = file(f, opts)
 485             want_close = True
 486         else:
 487             want_close = False
 488         try:
 489             if sorted:
 490                 names = self.keys()
 491                 names.sort()
 492             else:
 493                 names = self.iterkeys()
 494             for n in names:
 495                 l = self[n].to_text(n, origin=self.origin,
 496                                     relativize=relativize)
 497                 if nl is None:
 498                     print >> f, l
 499                 else:
 500                     f.write(l)
 501                     f.write(nl)
 502         finally:
 503             if want_close:
 504                 f.close()
 505
 506     def check_origin(self):
 507         """Do some simple checking of the zone's origin.
 508
 509         @raises dns.zone.NoSOA: there is no SOA RR
 510         @raises dns.zone.NoNS: there is no NS RRset
 511         @raises KeyError: there is no origin node
 512         """
 513         if self.relativize:
 514             name = dns.name.empty
 515         else:
 516             name = self.origin
 517         if self.get_rdataset(name, dns.rdatatype.SOA) is None:
 518             raise NoSOA
 519         if self.get_rdataset(name, dns.rdatatype.NS) is None:
 520             raise NoNS
 521
 522
 523 class _MasterReader(object):
 524     """Read a DNS master file
 525
 526     @ivar tok: The tokenizer
 527     @type tok: dns.tokenizer.Tokenizer object
 528     @ivar ttl: The default TTL
 529     @type ttl: int
 530     @ivar last_name: The last name read
 531     @type last_name: dns.name.Name object
 532     @ivar current_origin: The current origin
 533     @type current_origin: dns.name.Name object
 534     @ivar relativize: should names in the zone be relativized?
 535     @type relativize: bool
 536     @ivar zone: the zone
 537     @type zone: dns.zone.Zone object
 538     @ivar saved_state: saved reader state (used when processing $INCLUDE)
 539     @type saved_state: list of (tokenizer, current_origin, last_name, file)
 540     tuples.
 541     @ivar current_file: the file object of the $INCLUDed file being parsed
 542     (None if no $INCLUDE is active).
 543     @ivar allow_include: is $INCLUDE allowed?
 544     @type allow_include: bool
 545     @ivar check_origin: should sanity checks of the origin node be done?
 546     The default is True.
 547     @type check_origin: bool
 548     """
 549
 550     def __init__(self, tok, origin, rdclass, relativize, zone_factory=Zone,
 551                  allow_include=False, check_origin=True):
 552         if isinstance(origin, (str, unicode)):
 553             origin = dns.name.from_text(origin)
 554         self.tok = tok
 555         self.current_origin = origin
 556         self.relativize = relativize
 557         self.ttl = 0
 558         self.last_name = None
 559         self.zone = zone_factory(origin, rdclass, relativize=relativize)
 560         self.saved_state = []
 561         self.current_file = None
 562         self.allow_include = allow_include
 563         self.check_origin = check_origin
 564
 565     def _eat_line(self):
 566         while 1:
 567             token = self.tok.get()
 568             if token.is_eol_or_eof():
 569                 break
 570
 571     def _rr_line(self):
 572         """Process one line from a DNS master file."""
 573         # Name
 574         if self.current_origin is None:
 575             raise UnknownOrigin
 576         token = self.tok.get(want_leading = True)
 577         if not token.is_whitespace():
 578             self.last_name = dns.name.from_text(token.value, self.current_origin)
 579         else:
 580             token = self.tok.get()
 581             if token.is_eol_or_eof():
 582                 # treat leading WS followed by EOL/EOF as if they were EOL/EOF.
 583                 return
 584             self.tok.unget(token)
 585         name = self.last_name
 586         if not name.is_subdomain(self.zone.origin):
 587             self._eat_line()
 588             return
 589         if self.relativize:
 590             name = name.relativize(self.zone.origin)
 591         token = self.tok.get()
 592         if not token.is_identifier():
 593             raise dns.exception.SyntaxError
 594         # TTL
 595         try:
 596             ttl = dns.ttl.from_text(token.value)
 597             token = self.tok.get()
 598             if not token.is_identifier():
 599                 raise dns.exception.SyntaxError
 600         except dns.ttl.BadTTL:
 601             ttl = self.ttl
 602         # Class
 603         try:
 604             rdclass = dns.rdataclass.from_text(token.value)
 605             token = self.tok.get()
 606             if not token.is_identifier():
 607                 raise dns.exception.SyntaxError
 608         except dns.exception.SyntaxError:
 609             raise dns.exception.SyntaxError
 610         except:
 611             rdclass = self.zone.rdclass
 612         if rdclass != self.zone.rdclass:
 613             raise dns.exception.SyntaxError("RR class is not zone's class")
 614         # Type
 615         try:
 616             rdtype = dns.rdatatype.from_text(token.value)
 617         except:
 618             raise dns.exception.SyntaxError("unknown rdatatype '%s'" % token.value)
 619         n = self.zone.nodes.get(name)
 620         if n is None:
 621             n = self.zone.node_factory()
 622             self.zone.nodes[name] = n
 623         try:
 624             rd = dns.rdata.from_text(rdclass, rdtype, self.tok,
 625                                      self.current_origin, False)
 626         except dns.exception.SyntaxError:
 627             # Catch and reraise.
 628             (ty, va) = sys.exc_info()[:2]
 629             raise va
 630         except:
 631             # All exceptions that occur in the processing of rdata
 632             # are treated as syntax errors.  This is not strictly
 633             # correct, but it is correct almost all of the time.
 634             # We convert them to syntax errors so that we can emit
 635             # helpful filename:line info.
 636             (ty, va) = sys.exc_info()[:2]
 637             raise dns.exception.SyntaxError("caught exception %s: %s" % (str(ty), str(va)))
 638
 639         rd.choose_relativity(self.zone.origin, self.relativize)
 640         covers = rd.covers()
 641         rds = n.find_rdataset(rdclass, rdtype, covers, True)
 642         rds.add(rd, ttl)
 643
 644     def read(self):
 645         """Read a DNS master file and build a zone object.
 646
 647         @raises dns.zone.NoSOA: No SOA RR was found at the zone origin
 648         @raises dns.zone.NoNS: No NS RRset was found at the zone origin
 649         """
 650
 651         try:
 652             while 1:
 653                 token = self.tok.get(True, True).unescape()
 654                 if token.is_eof():
 655                     if not self.current_file is None:
 656                         self.current_file.close()
 657                     if len(self.saved_state) > 0:
 658                         (self.tok,
 659                          self.current_origin,
 660                          self.last_name,
 661                          self.current_file,
 662                          self.ttl) = self.saved_state.pop(-1)
 663                         continue
 664                     break
 665                 elif token.is_eol():
 666                     continue
 667                 elif token.is_comment():
 668                     self.tok.get_eol()
 669                     continue
 670                 elif token.value[0] == '$':
 671                     u = token.value.upper()
 672                     if u == '$TTL':
 673                         token = self.tok.get()
 674                         if not token.is_identifier():
 675                             raise dns.exception.SyntaxError("bad $TTL")
 676                         self.ttl = dns.ttl.from_text(token.value)
 677                         self.tok.get_eol()
 678                     elif u == '$ORIGIN':
 679                         self.current_origin = self.tok.get_name()
 680                         self.tok.get_eol()
 681                         if self.zone.origin is None:
 682                             self.zone.origin = self.current_origin
 683                     elif u == '$INCLUDE' and self.allow_include:
 684                         token = self.tok.get()
 685                         if not token.is_quoted_string():
 686                             raise dns.exception.SyntaxError("bad filename in $INCLUDE")
 687                         filename = token.value
 688                         token = self.tok.get()
 689                         if token.is_identifier():
 690                             new_origin = dns.name.from_text(token.value, \
 691                                                             self.current_origin)
 692                             self.tok.get_eol()
 693                         elif not token.is_eol_or_eof():
 694                             raise dns.exception.SyntaxError("bad origin in $INCLUDE")
 695                         else:
 696                             new_origin = self.current_origin
 697                         self.saved_state.append((self.tok,
 698                                                  self.current_origin,
 699                                                  self.last_name,
 700                                                  self.current_file,
 701                                                  self.ttl))
 702                         self.current_file = file(filename, 'r')
 703                         self.tok = dns.tokenizer.Tokenizer(self.current_file,
 704                                                            filename)
 705                         self.current_origin = new_origin
 706                     else:
 707                         raise dns.exception.SyntaxError("Unknown master file directive '" + u + "'")
 708                     continue
 709                 self.tok.unget(token)
 710                 self._rr_line()
 711         except dns.exception.SyntaxError, detail:
 712             (filename, line_number) = self.tok.where()
 713             if detail is None:
 714                 detail = "syntax error"
 715             raise dns.exception.SyntaxError("%s:%d: %s" % (filename, line_number, detail))
 716
 717         # Now that we're done reading, do some basic checking of the zone.
 718         if self.check_origin:
 719             self.zone.check_origin()
 720
 721 def from_text(text, origin = None, rdclass = dns.rdataclass.IN,
 722               relativize = True, zone_factory=Zone, filename=None,
 723               allow_include=False, check_origin=True):
 724     """Build a zone object from a master file format string.
 725
 726     @param text: the master file format input
 727     @type text: string.
 728     @param origin: The origin of the zone; if not specified, the first
 729     $ORIGIN statement in the master file will determine the origin of the
 730     zone.
 731     @type origin: dns.name.Name object or string
 732     @param rdclass: The zone's rdata class; the default is class IN.
 733     @type rdclass: int
 734     @param relativize: should names be relativized?  The default is True
 735     @type relativize: bool
 736     @param zone_factory: The zone factory to use
 737     @type zone_factory: function returning a Zone
 738     @param filename: The filename to emit when describing where an error
 739     occurred; the default is '<string>'.
 740     @type filename: string
 741     @param allow_include: is $INCLUDE allowed?
 742     @type allow_include: bool
 743     @param check_origin: should sanity checks of the origin node be done?
 744     The default is True.
 745     @type check_origin: bool
 746     @raises dns.zone.NoSOA: No SOA RR was found at the zone origin
 747     @raises dns.zone.NoNS: No NS RRset was found at the zone origin
 748     @rtype: dns.zone.Zone object
 749     """
 750
 751     # 'text' can also be a file, but we don't publish that fact
 752     # since it's an implementation detail.  The official file
 753     # interface is from_file().
 754
 755     if filename is None:
 756         filename = '<string>'
 757     tok = dns.tokenizer.Tokenizer(text, filename)
 758     reader = _MasterReader(tok, origin, rdclass, relativize, zone_factory,
 759                            allow_include=allow_include,
 760                            check_origin=check_origin)
 761     reader.read()
 762     return reader.zone
 763
 764 def from_file(f, origin = None, rdclass = dns.rdataclass.IN,
 765               relativize = True, zone_factory=Zone, filename=None,
 766               allow_include=True, check_origin=True):
 767     """Read a master file and build a zone object.
 768
 769     @param f: file or string.  If I{f} is a string, it is treated
 770     as the name of a file to open.
 771     @param origin: The origin of the zone; if not specified, the first
 772     $ORIGIN statement in the master file will determine the origin of the
 773     zone.
 774     @type origin: dns.name.Name object or string
 775     @param rdclass: The zone's rdata class; the default is class IN.
 776     @type rdclass: int
 777     @param relativize: should names be relativized?  The default is True
 778     @type relativize: bool
 779     @param zone_factory: The zone factory to use
 780     @type zone_factory: function returning a Zone
 781     @param filename: The filename to emit when describing where an error
 782     occurred; the default is '<file>', or the value of I{f} if I{f} is a
 783     string.
 784     @type filename: string
 785     @param allow_include: is $INCLUDE allowed?
 786     @type allow_include: bool
 787     @param check_origin: should sanity checks of the origin node be done?
 788     The default is True.
 789     @type check_origin: bool
 790     @raises dns.zone.NoSOA: No SOA RR was found at the zone origin
 791     @raises dns.zone.NoNS: No NS RRset was found at the zone origin
 792     @rtype: dns.zone.Zone object
 793     """
 794
 795     if sys.hexversion >= 0x02030000:
 796         # allow Unicode filenames; turn on universal newline support
 797         str_type = basestring
 798         opts = 'rU'
 799     else:
 800         str_type = str
 801         opts = 'r'
 802     if isinstance(f, str_type):
 803         if filename is None:
 804             filename = f
 805         f = file(f, opts)
 806         want_close = True
 807     else:
 808         if filename is None:
 809             filename = '<file>'
 810         want_close = False
 811
 812     try:
 813         z = from_text(f, origin, rdclass, relativize, zone_factory,
 814                       filename, allow_include, check_origin)
 815     finally:
 816         if want_close:
 817             f.close()
 818     return z
 819
 820 def from_xfr(xfr, zone_factory=Zone, relativize=True):
 821     """Convert the output of a zone transfer generator into a zone object.
 822
 823     @param xfr: The xfr generator
 824     @type xfr: generator of dns.message.Message objects
 825     @param relativize: should names be relativized?  The default is True.
 826     It is essential that the relativize setting matches the one specified
 827     to dns.query.xfr().
 828     @type relativize: bool
 829     @raises dns.zone.NoSOA: No SOA RR was found at the zone origin
 830     @raises dns.zone.NoNS: No NS RRset was found at the zone origin
 831     @rtype: dns.zone.Zone object
 832     """
 833
 834     z = None
 835     for r in xfr:
 836         if z is None:
 837             if relativize:
 838                 origin = r.origin
 839             else:
 840                 origin = r.answer[0].name
 841             rdclass = r.answer[0].rdclass
 842             z = zone_factory(origin, rdclass, relativize=relativize)
 843         for rrset in r.answer:
 844             znode = z.nodes.get(rrset.name)
 845             if not znode:
 846                 znode = z.node_factory()
 847                 z.nodes[rrset.name] = znode
 848             zrds = znode.find_rdataset(rrset.rdclass, rrset.rdtype,
 849                                        rrset.covers, True)
 850             zrds.update_ttl(rrset.ttl)
 851             for rd in rrset:
 852                 rd.choose_relativity(z.origin, relativize)
 853                 zrds.add(rd)
 854     z.check_origin()
 855     return z