ldnsx.py

#  Copyright (c) 2011, Xelerance
#  Author: Christopher Olah <chris@xelerance.com>
#
#  All rights reserved.
#
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions are met:
#
#      * Redistributions of source code must retain the above copyright notice,
#       this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above copyright
#       notice, this list of conditions and the following disclaimer in the
#       documentation and/or other materials provided with the distribution.
#     * Neither the name of Xelerance nor the names of its
#       contributors may be used to endorse or promote products derived from this
#       software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.

""" Easy DNS (including DNSSEC) via ldns.

ldns is a great library. It is a powerfull tool for
working with DNS. python-ldns it is a straight up clone of the C
interface, howver that is not a very good interface for python. Its
documentation is incomplete and some functions don't work as
described. And some objects don't have a full python API.

ldnsx aims to fix this. It wraps around the ldns python bindings,
working around its limitations and providing a well-documented, more
pythonistic interface.

**WARNING:** 

**API subject to change.** No backwards compatibility guarantee. Write software using this version at your own risk!

Examples
--------

Query the default resolver for google.com's A records. Print the response
packet.

>>> import ldnsx
>>> resolver = ldnsx.resolver()
>>> print resolver.query("google.com","A")


Print the root NS records from f.root-servers.net; if we get a
response, else an error message.

>>> import ldnsx
>>> pkt = ldnsx.resolver("f.root-servers.net").query(".", "NS")
>>> if pkt:
>>>    for rr in pkt.answer():
>>>       print rr
>>> else:
>>>    print "response not received" 

"""

import time, sys, calendar, warnings, socket
try:
  import ldns
except ImportError:
  print >> sys.stderr, "ldnsx requires the ldns-python sub-package from http://www.nlnetlabs.nl/projects/ldns/"
  print >> sys.stderr, "Fedora/CentOS: yum install ldns-python"
  print >> sys.stderr, "Debian/Ubuntu: apt-get install python-ldns"
  print >> sys.stderr, "openSUSE: zypper in python-ldns"
  sys.exit(1)

__version__ = "0.1"

def isValidIP(ipaddr):
  try:
    v4 = socket.inet_pton(socket.AF_INET,ipaddr)
    return 4
  except:
    try:
      v6 = socket.inet_pton(socket.AF_INET6,ipaddr)
      return 6
    except:
      return 0

def query(name, rr_type, rr_class="IN", flags=["RD"], tries = 3, res=None):
  """Convenience function. Creates a resolver and then queries it. Refer to resolver.query() 
     * name -- domain to query for 
     * rr_type -- rr_type to query for
     * flags -- flags for query (list of strings)
     * tries -- number of times to retry the query on failure
     * res -- configurations for the resolver as a dict -- see resolver()
     """
  if isinstance(res, list) or isinstance(res, tuple):
    res = resolver(*res)
  elif isinstance(res, dict):
    res = resolver(**res)
  else:
    res = resolver(res)
  return res.query(name, rr_type, rr_class, flags, tries)

def get_rrs(name, rr_type, rr_class="IN", tries = 3, strict = False, res=None, **kwds):
  """Convenience function. Gets RRs for name of type rr_type trying tries times. 
     If strict, it raises and exception on failure, otherwise it returns []. 
     * name -- domain to query for 
     * rr_type -- rr_type to query for
     * flags -- flags for query (list of strings)
     * tries -- number of times to retry the query on failure
     * strict -- if the query fails, do we return [] or raise an exception?
     * res -- configurations for the resolver as a dict -- see resolver()
     * kwds -- query filters, refer to packet.answer()
       """
  if isinstance(res, list) or isinstance(res, tuple):
    res = resolver(*res)
  elif isinstance(res, dict):
    res = resolver(**res)
  else:
    res = resolver(res)
  if "|" in rr_type:
    pkt = res.query(name, "ANY", rr_class=rr_class, tries=tries)
  else:
    pkt = res.query(name, rr_type, rr_class=rr_class, tries=tries)
  if pkt:
    if rr_type in ["", "ANY", "*"]:
      return pkt.answer( **kwds)
    else:
      return pkt.answer(rr_type=rr_type, **kwds)
  else:
    if strict:
      raise Exception("LDNS couldn't complete query")
    else:
      return []

def secure_query(name, rr_type, rr_class="IN", flags=["RD"], tries = 1, flex=False, res=None):
  """Convenience function. Creates a resolver and then does a DNSSEC query. Refer to resolver.query() 
     * name -- domain to query for 
     * rr_type -- rr_type to query for
     * flags -- flags for query (list of strings)
     * tries -- number of times to retry the query on failure
     * flex -- if we can't verify data, exception or warning?
     * res -- configurations for the resolver as a dict -- see resolver()"""
  if isinstance(res, list) or isinstance(res, tuple):
    res = resolver(*res)
  elif isinstance(res, dict):
    res = resolver(**res)
  else:
    res = resolver(res)
  pkt = res.query(name, rr_type, rr_class, flags, tries)
  if pkt.rcode() == "SERVFAIL":
    raise Exception("%s lookup failed (server error or dnssec validation failed)" % name)
  if pkt.rcode() == "NXDOMAIN":
    if "AD" in pkt.flags():
      raise Exception("%s lookup failed (non-existence proven by DNSSEC)" % hostname )
    else:
      raise Exception("%s lookup failed" % hostname )
  if pkt.rcode() == "NOERROR":
    if "AD" not in pkt.flags():
      if not flex:
        raise Exception("DNS lookup was insecure")
      else:
        warnings.warn("DNS lookup was insecure")
    return pkt
  else:
    raise Exception("unknown ldns error, %s" % pkt.rcode())



class resolver:
  """ A wrapper around ldns.ldns_resolver. 

      **Examples**

      Making resolvers is easy!

      >>> from ldnsx import resolver
      >>> resolver() # from /etc/resolv.conf
      <resolver: 192.168.111.9>
      >>> resolver("") # resolver with no nameservers
      <resolver: >
      >>> resolver("193.110.157.135") #resolver pointing to ip addr
      <resolver: 193.110.157.135>
      >>> resolver("f.root-servers.net") # resolver pointing ip address(es) resolved from name
      <resolver: 2001:500:2f::f, 192.5.5.241>
      >>> resolver("193.110.157.135, 193.110.157.136") 
      >>> # resolver pointing to multiple ip addr, first takes precedence.
      <resolver: 193.110.157.136, 193.110.157.135>

      So is playing around with their nameservers!

      >>> import ldnsx
      >>> res = ldnsx.resolver("192.168.1.1")
      >>> res.add_nameserver("192.168.1.2")
      >>> res.add_nameserver("192.168.1.3")
      >>> res.nameservers_ip()
      ["192.168.1.1","192.168.1.2","192.168.1.3"]

      And querying!

      >>> from ldnsx import resolver
      >>> res= resolver()
      >>> res.query("cow.com","A")
      ;; ->>HEADER<<- opcode: QUERY, rcode: NOERROR, id: 7663
      ;; flags: qr rd ra ; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0 
      ;; QUESTION SECTION:
      ;; cow.com.     IN      A
      ;; ANSWER SECTION:
      cow.com.        300     IN      A       208.87.34.18
      ;; AUTHORITY SECTION:
      ;; ADDITIONAL SECTION:
      ;; Query time: 313 msec
      ;; SERVER: 192.168.111.9
      ;; WHEN: Fri Jun  3 11:01:02 2011
      ;; MSG SIZE  rcvd: 41

  
      """
  
  def __init__(self, ns = None, dnssec = False, tcp = False, port = 53):
    """resolver constructor
      
      * ns    --  the nameserver/comma delimited nameserver list
                  defaults to settings from /etc/resolv.conf
      * dnssec -- should the resolver try and use dnssec or not?
        * tcp -- should the resolver use TCP
                 'auto' is a depricated work around for old ldns problems
        * port -- the port to use, must be the same for all nameservers

      """
    # We construct based on a file and dump the nameservers rather than using
    # ldns_resolver_new() to avoid environment/configuration/magic specific 
    # bugs.
    self._ldns_resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
    if ns != None:
      self.drop_nameservers()
      nm_list = ns.split(',')
      nm_list = map(lambda s: s.strip(), nm_list)
      nm_list = filter(lambda s: s != "", nm_list)
      nm_list.reverse()
      for nm in nm_list:
        self.add_nameserver(nm)
    # Configure DNSSEC, tcp and port
    self.set_dnssec(dnssec)
    if tcp == 'auto':
      self.autotcp = True
      self._ldns_resolver.set_usevc(False)
    else:
      self.autotcp = False
      self._ldns_resolver.set_usevc(tcp)
    self._ldns_resolver.set_port(port)

  def query(self, name, rr_type, rr_class="IN", flags=["RD"], tries = 3):
    """Run a query on the resolver.
        
      * name -- name to query for
      * rr_type -- the record type to query for
      * rr_class -- the class to query for, defaults to IN (Internet)
      * flags -- the flags to send the query with 
      * tries -- the number of times to attempt to acheive query in case of packet loss, etc
      
      **Examples**
      
      Let's get some A records!

      >>> google_a_records = resolver.query("google.com","A").answer()
      
      Using DNSSEC is easy :)

      >>> dnssec_pkt = ldnsx.resolver(dnssec=True).query("xelerance.com")
      
      We let you use strings to make things easy, but if you prefer stay close to DNS...

      >>> AAAA = 28
      >>> resolver.query("ipv6.google.com", AAAA)
      
      **More about rr_type**
      
      rr_type must be a supported resource record type. There are a large number of RR types:

      ===========  ===================================  ==================
      TYPE         Value and meaning                    Reference
      ===========  ===================================  ==================
      A            1 a host address                     [RFC1035]
      NS           2 an authoritative name server       [RFC1035]
      ...
      AAAA         28 IP6 Address                       [RFC3596]
      ...
      DS           43 Delegation Signer                 [RFC4034][RFC3658]
      ...
      DNSKEY       48 DNSKEY                            [RFC4034][RFC3755]
      ...
      Unassigned   32770-65279  
      Private use  65280-65534
      Reserved     65535 
      ===========  ===================================  ==================
      
      (From http://www.iana.org/assignments/dns-parameters)

      RR types are given as a string (eg. "A"). In the case of Unassigned/Private use/Reserved ones,
      they are given as "TYPEXXXXX" where XXXXX is the number. ie. RR type 65280 is "TYPE65280". You 
      may also pass the integer, but you always be given the string.

      If the version of ldnsx you are using is old, it is possible that there could be new rr_types that
      we don't recognise mnemonic for. You can still use the number XXX or the string "TYPEXXX". To
      determine what rr_type menmonics we support, please refer to resolver.supported_rr_types()

    """
    # Determine rr_type int
    if rr_type in _rr_types.keys():
      _rr_type = _rr_types[rr_type]
    elif isinstance(rr_type,int):
      _rr_type = rr_type
    elif isinstance(rr_type,str) and rr_type[0:4] == "TYPE":
      try:
        _rr_type = int(rr_type[4:])
      except:
        raise Exception("%s is a bad RR type. TYPEXXXX: XXXX must be a number")
    else:
      raise Exception("ldnsx (version %s) does not support the RR type %s."  % (__version__, str(rr_type)) ) 
    # Determine rr_class int
    if   rr_class == "IN": _rr_class = ldns.LDNS_RR_CLASS_IN 
    elif rr_class == "CH": _rr_class = ldns.LDNS_RR_CLASS_CH
    elif rr_class == "HS": _rr_class = ldns.LDNS_RR_CLASS_HS
    else:
      raise Exception("ldnsx (version %s) does not support the RR class %s." % (__version__, str(rr_class)) ) 
    # Determine flags int
    _flags = 0
    if "QR" in flags:  _flags |= ldns.LDNS_QR
    if "AA" in flags:  _flags |= ldns.LDNS_AA
    if "TC" in flags:  _flags |= ldns.LDNS_TC
    if "RD" in flags:  _flags |= ldns.LDNS_RD
    if "CD" in flags:  _flags |= ldns.LDNS_CD
    if "RA" in flags:  _flags |= ldns.LDNS_RA
    if "AD" in flags:  _flags |= ldns.LDNS_AD
    # Query
    if tries == 0: return None
    try:
      pkt = self._ldns_resolver.query(name, _rr_type, _rr_class, _flags)
    except KeyboardInterrupt: #Since so much time is spent waiting on ldns, this is very common place for Ctr-C to fall
      raise
    except: #Since the ldns exceptiion is not very descriptive...
      raise Exception("ldns backend ran into problems. Likely, the name you were querying for, %s, was invalid." % name)
    #Deal with failed queries
    if not pkt:
      if tries <= 1:
        return None
      else:
        # One of the major causes of none-packets is truncation of packets
        # When autotcp is set, we are in a flexible enough position to try and use tcp
        # to get around this.
        # Either way, we want to replace the resolver, since resolvers will sometimes
        # just freeze up.
        if self.autotcp:
          self = resolver( ",".join(self.nameservers_ip()),tcp=True, dnssec = self._ldns_resolver.dnssec())
          self.autotcp = True
          pkt = self.query(name, rr_type, rr_class=rr_class, flags=flags, tries = tries-1) 
          self._ldns_resolver.set_usevc(False)
          return pkt
        else:
          self = resolver( ",".join(self.nameservers_ip()), tcp = self._ldns_resolver.usevc(), dnssec = self._ldns_resolver.dnssec() )
          time.sleep(1) # It could be that things are failing because of a brief outage
          return self.query(name, rr_type, rr_class=rr_class, flags=flags, tries = tries-1) 
    elif self.autotcp:
      pkt = packet(pkt)
      if "TC" in pkt.flags():
        self._ldns_resolver.set_usevc(True)
        pkt2 = self.query(name, rr_type, rr_class=rr_class, flags=flags, tries = tries-1) 
        self._ldns_resolver.set_usevc(False)
        if pkt2: return packet(pkt2)
      return pkt
    return packet(pkt)
    #ret = []
    #for rr in pkt.answer().rrs():
    #  ret.append([str(rr.owner()),rr.ttl(),rr.get_class_str(),rr.get_type_str()]+[str(rdf) for rdf in rr.rdfs()])
    #return ret

  def suported_rr_types(self):
    """ Returns the supported DNS resource record types.

      Refer to resolver.query() for thorough documentation of resource 
      record types or refer to:

      http://www.iana.org/assignments/dns-parameters

    """
    return _rr_types.keys()
  
  def AXFR(self,name):
    """AXFR for name

      * name -- name to AXFR for
      
      This function is a generator. As it AXFRs it will yield you the records.

      **Example**

      Let's get a list of the tlds (gotta catch em all!):

      >>> tlds = []
      >>> for rr in resolver("f.root-servers.net").AXFR("."):
      >>>    if rr.rr_type() == "NS":
      >>>       tlds.append(rr.owner())

    """
    #Dname seems to be unecessary on some computers, but it is on others. Avoid bugs.
    if self._ldns_resolver.axfr_start(ldns.ldns_dname(name), ldns.LDNS_RR_CLASS_IN) != ldns.LDNS_STATUS_OK:
      raise Exception("Starting AXFR failed. Error: %s" % ldns.ldns_get_errorstr_by_id(status))
    pres = self._ldns_resolver.axfr_next()
    while pres:
      yield resource_record(pres)
      pres = self._ldns_resolver.axfr_next()

  def nameservers_ip(self):
    """ returns a list of the resolvers nameservers (as IP addr)
    
    """
    nm_stack2 =[]
    nm_str_stack2=[]
    nm = self._ldns_resolver.pop_nameserver()
    while nm:
      nm_stack2.append(nm)
      nm_str_stack2.append(str(nm))
      nm = self._ldns_resolver.pop_nameserver()
    for nm in nm_stack2:
      self._ldns_resolver.push_nameserver(nm)
    nm_str_stack2.reverse()
    return nm_str_stack2


  def add_nameserver(self,ns):
    """ Add a nameserver, IPv4/IPv6/name.

    """
    if isValidIP(ns) == 4:
      address = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A,ns)
      self._ldns_resolver.push_nameserver(address)
    elif isValidIP(ns) == 6:
      address = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_AAAA,ns)
      self._ldns_resolver.push_nameserver(address)
    else:
      resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
      #address = resolver.get_addr_by_name(ns)
      address = resolver.get_addr_by_name(ldns.ldns_dname(ns))
      if not address:
        address = resolver.get_addr_by_name(ldns.ldns_dname(ns))
        if not address:
          raise Exception("Failed to resolve address for %s" % ns)
      for rr in address.rrs():
        self._ldns_resolver.push_nameserver_rr(rr)

  def drop_nameservers(self):
    """Drops all nameservers.
      This function causes the resolver to forget all nameservers.

    """
    while self._ldns_resolver.pop_nameserver():
      pass

  def set_nameservers(self, nm_list):
    """Takes a list of nameservers and sets the resolver to use them
    
    """
    self.drop_nameservers()
    for nm in nm_list:
      self.add_nameserver(nm)

  def __repr__(self):
    return "<resolver: %s>" % ", ".join(self.nameservers_ip())
  __str__ = __repr__

  def set_dnssec(self,new_dnssec_status):
    """Set whether the resolver uses DNSSEC.
    
    """
    self._ldns_resolver.set_dnssec(new_dnssec_status)

class packet:
  
  def _construct_rr_filter(self, **kwds):
    def match(pattern, target):
      if pattern[0] in ["<",">","!"]:
        rel = pattern[0]
        pattern=pattern[1:]
      elif pattern[0:2] in ["<=","=>"]:
        rel = pattern[0:2]
        pattern=pattern[2:]
      else:
        rel = "="
      for val in pattern.split("|"):
        if {"<" : target <  val,
            ">" : target >  val,
            "!" : target != val,
            "=" : target == val,
            ">=": target >= val,
            "<=": target <= val}[rel]:
          return True
      return False
    def f(rr):
      for key in kwds.keys():
        if ( ( isinstance(kwds[key], list) and str(rr[key]) not in map(str,kwds[key]) )
          or ( not isinstance(kwds[key], list) and not match(str(kwds[key]), str(rr[key])))):
          return False
      return True
    return f
  
  def __init__(self, pkt):
    self._ldns_pkt = pkt
  
  def __repr__(self):
    return str(self._ldns_pkt)
  __str__ = __repr__
  
  def rcode(self):
    """Returns the rcode.

    Example returned value: "NOERROR"

    possilbe rcodes (via ldns): "FORMERR", "MASK", "NOERROR",
    "NOTAUTH", "NOTIMPL", "NOTZONE", "NXDOMAIN",
    "NXRSET", "REFUSED", "SERVFAIL", "SHIFT", 
    "YXDOMAIN", "YXRRSET"

    Refer to http://www.iana.org/assignments/dns-parameters
    section: DNS RCODEs
    """
    return self._ldns_pkt.rcode2str()

  def opcode(self):
    """Returns the rcode.

    Example returned value: "QUERY"

    """
    return self._ldns_pkt.opcode2str()

  def query_time(self):
    """Returns query time (in ms)."""
    return self._ldns_pkt.querytime()
  
  def answer_from(self):
    """Returns the server that answered."""
    return str(self._ldns_pkt.answerfrom())
  
  def flags(self):
    """Return packet flags (as list of strings).
    
    Example returned value: ['QR', 'RA', 'RD']

    **What are the flags?**
    
    ========  ====  =====================  =========
    Bit       Flag  Description            Reference
    ========  ====  =====================  =========
    bit 5     AA    Authoritative Answer   [RFC1035]
    bit 6     TC    Truncated Response     [RFC1035]
    bit 7     RD    Recursion Desired      [RFC1035]
    bit 8     RA    Recursion Allowed      [RFC1035]
    bit 9           Reserved
    bit 10    AD    Authentic Data         [RFC4035]
    bit 11    CD    Checking Disabled      [RFC4035]
    ========  ====  =====================  =========

    (from http://www.iana.org/assignments/dns-parameters)

    There is also QR. It is mentioned in other sources,
    though not the above page. It being false means that
    the packet is a query, it being true means that it is
    a response.

    """
    ret = []
    if self._ldns_pkt.aa(): ret += ["AA"]
    if self._ldns_pkt.ad(): ret += ["AD"]
    if self._ldns_pkt.cd(): ret += ["CD"]
    if self._ldns_pkt.qr(): ret += ["QR"]
    if self._ldns_pkt.ra(): ret += ["RA"]
    if self._ldns_pkt.rd(): ret += ["RD"]
    if self._ldns_pkt.tc(): ret += ["TC"]
    return ret

  def answer(self, **filters):
    """Returns the answer section.
    
    * filters -- a filtering mechanism
    
    Since a very common desire is to filter the resource records in a packet
    section, we provide a special tool for doing this: filters. They are a
    lot like regular python filters, but more convenient. If you set a 
    field equal to some value, you will only receive resource records for which
    it holds true.

    **Examples**

    >>> res = ldnsx.resolver()
    >>> pkt = res.query("google.ca","A")
    >>> pkt.answer()
    [google.ca.     28      IN      A       74.125.91.99
    , google.ca.    28      IN      A       74.125.91.105
    , google.ca.    28      IN      A       74.125.91.147
    , google.ca.    28      IN      A       74.125.91.103
    , google.ca.    28      IN      A       74.125.91.104
    , google.ca.    28      IN      A       74.125.91.106
    ]

    To understand filters, consider the following:

    >>> pkt = ldnsx.query("cow.com","ANY")
    >>> pkt.answer()
    [cow.com.       276     IN      A       208.87.32.75
    , cow.com.      3576    IN      NS      sell.internettraffic.com.
    , cow.com.      3576    IN      NS      buy.internettraffic.com.
    , cow.com.      3576    IN      SOA     buy.internettraffic.com. hostmaster.hostingnet.com. 1308785320 10800 3600 604800 3600
    ]
    >>> pkt.answer(rr_type="A")
    [cow.com.       276     IN      A       208.87.32.75
    ]
    >>> pkt.answer(rr_type="A|NS")
    [cow.com.       276     IN      A       208.87.32.75
    , cow.com.      3576    IN      NS      sell.internettraffic.com.
    , cow.com.      3576    IN      NS      buy.internettraffic.com.
    ]
    >>> pkt.answer(rr_type="!NS")
    [cow.com.       276     IN      A       208.87.32.75
    , cow.com.      3576    IN      SOA     buy.internettraffic.com. hostmaster.hostingnet.com. 1308785320 10800 3600 604800 3600
    ]
    
    fields are the same as when indexing a resource record.
    note: ordering is alphabetical.
    """
    ret =  [resource_record(rr) for rr in self._ldns_pkt.answer().rrs()]
    return filter(self._construct_rr_filter(**filters), ret)

  def authority(self, **filters):
    """Returns the authority section.

    * filters -- a filtering mechanism
    
    Since a very common desire is to filter the resource records in a packet
    section, we provide a special tool for doing this: filters. They are a
    lot like regular python filters, but more convenient. If you set a 
    field equal to some value, you will only receive resource records for which
    it holds true. See answer() for details.

    **Examples**

    >>> res = ldnsx.resolver()
    >>> pkt = res.query("google.ca","A")
    >>> pkt.authority()
    [google.ca.     251090  IN      NS      ns3.google.com.
    , google.ca.    251090  IN      NS      ns1.google.com.
    , google.ca.    251090  IN      NS      ns2.google.com.
    , google.ca.    251090  IN      NS      ns4.google.com.
    ]

    """
    ret = [resource_record(rr) for rr in self._ldns_pkt.authority().rrs()]
    return filter(self._construct_rr_filter(**filters), ret)

  def additional(self, **filters):
    """Returns the additional section.

    * filters -- a filtering mechanism
    
    Since a very common desire is to filter the resource records in a packet
    section, we provide a special tool for doing this: filters. They are a
    lot like regular python filters, but more convenient. If you set a 
    field equal to some value, you will only receive resource records for which
    it holds true. See answer() for details.

    **Examples**

    >>> res = ldnsx.resolver()
    >>> pkt = res.query("google.ca","A")
    >>> pkt.additional()
    [ns3.google.com.        268778  IN      A       216.239.36.10
    , ns1.google.com.       262925  IN      A       216.239.32.10
    , ns2.google.com.       255659  IN      A       216.239.34.10
    , ns4.google.com.       264489  IN      A       216.239.38.10
    ]

    """
    ret = [resource_record(rr) for rr in self._ldns_pkt.additional().rrs()]
    return filter(self._construct_rr_filter(**filters), ret)

  def question(self, **filters):
    """Returns the question section.

    * filters -- a filtering mechanism
    
    Since a very common desire is to filter the resource records in a packet
    section, we provide a special tool for doing this: filters. They are a
    lot like regular python filters, but more convenient. If you set a 
    field equal to some value, you will only receive resource records for which
    it holds true. See answer() for details.

    """
    ret = [resource_record(rr) for rr in self._ldns_pkt.question().rrs()]
    return filter(self._construct_rr_filter(**filters), ret)

class resource_record:
  
  _rdfs = None
  _iter_pos = None
  
  def __init__(self, rr):
    self._ldns_rr = rr
    self._rdfs = [str(rr.owner()),rr.ttl(),rr.get_class_str(),rr.get_type_str()]+[str(rdf) for rdf in rr.rdfs()]
  
  def __repr__(self):
    return str(self._ldns_rr)
  
  __str__ = __repr__

  def __iter__(self):
    self._iter_pos = 0
    return self

  def next(self):
    if self._iter_pos < len(self._rdfs):
      self._iter_pos += 1
      return self._rdfs[self._iter_pos-1]
    else:
      raise StopIteration

  def __len__(self):
    try:
      return len(_rdfs)
    except:
      return 0

  def __getitem__(self, n):
    if isinstance(n, int):
      return self._rdfs[n]
    elif isinstance(n, str):
      n = n.lower()
      if n in ["owner"]:
        return self.owner()
      elif n in ["rr_type", "rr type", "type"]:
        return self.rr_type()
      elif n in ["rr_class", "rr class", "class"]:
        return self.rr_class()
      elif n in ["covered_type", "covered type", "type2"]:
        return self.covered_type()
      elif n in ["ttl"]:
        return self.ttl()
      elif n in ["ip"]:
        return self.ip()      
      elif n in ["alg", "algorithm"]:
        return self.alg()
      elif n in ["protocol"]:
        return self.protocol()
      elif n in ["flags"]:
        return self.flags()
      else:
        raise Exception("ldnsx (version %s) does not recognize the rr field %s" % (__version__,n) ) 
    else:
      raise TypeError("bad type %s for index resource record" % type(n) ) 
      

  #def rdfs(self):
  #  return self._rdfs.clone()
  
  def owner(self):
    """Get the RR's owner"""
    return str(self._ldns_rr.owner())
  
  def rr_type(self):
    """Get a RR's type """
    return self._ldns_rr.get_type_str()

  def covered_type(self):
    """Get an RRSIG RR's covered type"""
    if self.rr_type() == "RRSIG":
      return self[4]
    else:
      return ""
  
  def rr_class(self):
    """Get the RR's collapse"""
    return self._ldns_rr.get_class_str()
  
  def ttl(self):
    """Get the RR's TTL"""
    return self._ldns_rr.ttl()

  def inception(self, out_format="UTC"):
    """returns the inception time in format out_format, defaulting to a UTC string. 
    options for out_format are:

       UTC -- a UTC string eg. 20110712192610 (2011/07/12 19:26:10) 
       unix -- number of seconds since the epoch, Jan 1, 1970
       struct_time -- the format used by python's time library
    """
    # Something very strange is going on with inception/expiration dates in DNS.
    # According to RFC 4034 section 3.1.5 (http://tools.ietf.org/html/rfc4034#page-9)
    # the inception/expiration fields should be in seconds since Jan 1, 1970, the Unix
    # epoch (as is standard in unix). Yet all the packets I've seen provide UTC encoded
    # as a string instead, eg. "20110712192610" which is 2011/07/12 19:26:10. 
    #
    # It turns out that this is a standard thing that ldns is doing before the data gets 
    # to us.
    if self.rr_type() == "RRSIG":
      if out_format.lower() in ["utc", "utc str", "utc_str"]:
        return self[9]
      elif out_format.lower() in ["unix", "posix", "ctime"]:
        return calendar.timegm(time.strptime(self[9], "%Y%m%d%H%M%S"))
      elif out_format.lower() in ["relative"]:
        return calendar.timegm(time.strptime(self[9], "%Y%m%d%H%M%S")) - time.time()
      elif out_format.lower() in ["struct_time", "time.struct_time"]:
        return time.strptime(self[9], "%Y%m%d%H%M%S")
      else:
        raise Exception("unrecognized time format")
    else:
      return ""

  def expiration(self, out_format="UTC"):
    """get expiration time. see inception() for more information"""
    if self.rr_type() == "RRSIG":
      if out_format.lower() in ["utc", "utc str", "utc_str"]:
        return self[8]
      elif out_format.lower() in ["unix", "posix", "ctime"]:
        return calendar.timegm(time.strptime(self[8], "%Y%m%d%H%M%S"))
      elif out_format.lower() in ["relative"]:
        return calendar.timegm(time.strptime(self[8], "%Y%m%d%H%M%S")) - time.time()
      elif out_format.lower() in ["struct_time", "time.struct_time"]:
        return time.strptime(self[8], "%Y%m%d%H%M%S")
      else:
        raise Exception("unrecognized time format")
    else:
      return ""

  def ip(self):
    """ IP address from A/AAAA record"""
    if self.rr_type() in ["A", "AAAA"]:
      return self[4]
    else:
      raise Exception("ldnsx does not support ip for records other than A/AAAA")

  def name_server(self):
    """ Name Server from NS record"""
    if self.rr_type() in ["NS"]:
      return self[4]
    else:
      raise Exception("ldnsx does not support name server for records other than NS")

  def mx_exchange(self):
    """ Exchange from MX record"""
    if self.rr_type() in ["MX"]:
      return self[5]
    else:
      raise Exception("ldnsx does not support exchange for records other than MX")

  def mx_priority(self):
    """ Exchange Priority from MX record"""
    if self.rr_type() in ["MX"]:
      return self[4]
    else:
      raise Exception("ldnsx does not support exchange for records other than MX")

  def txt_value(self):
    """ TXT field from TXT record"""
    if self.rr_type() in ["TXT"]:
      return self[4]
    else:
      raise Exception("ldnsx does not support text value for records other than TXT")

  def soa_maintainer(self):
    """ Maintainer Name from SOA record"""
    if self.rr_type() in ["SOA"]:
      return self[5]
    else:
      raise Exception("ldnsx does not support maintainer name for records other than SOA")

  def soa_master(self):
    """ Master Server Name from SOA record"""
    if self.rr_type() in ["SOA"]:
      return self[4]
    else:
      raise Exception("ldnsx does not support master server name for records other than SOA")

  def soa_serial(self):
    """ Serial Number from SOA record"""
    if self.rr_type() in ["SOA"]:
      return self[6]
    else:
      raise Exception("ldnsx does not support serial number for records other than SOA")

  def soa_refresh(self):
    """ Refresh Interval from SOA record"""
    if self.rr_type() in ["SOA"]:
      return self[7]
    else:
      raise Exception("ldnsx does not support refresh interval for records other than SOA")

  def soa_retry(self):
    """ Retry Interval from SOA record"""
    if self.rr_type() in ["SOA"]:
      return self[8]
    else:
      raise Exception("ldnsx does not support retry interval for records other than SOA")

  def soa_expire(self):
    """ Expire Interval from SOA record"""
    if self.rr_type() in ["SOA"]:
      return self[9]
    else:
      raise Exception("ldnsx does not support expire interval for records other than SOA")

  def soa_negative_ttl(self):
    """ Negative TTL from SOA record"""
    if self.rr_type() in ["SOA"]:
      return self[10]
    else:
      raise Exception("ldnsx does not support negative TTL for records other than SOA")

  def cname(self):
    """ Canonical Name field from CNAME record"""
    if self.rr_type() in ["CNAME"]:
      return self[4]
    else:
      raise Exception("ldnsx does not support canonical name for records other than CNAME")

  def alg(self):
    """Returns algorithm of RRSIG/DNSKEY/DS"""
    t = self.rr_type() 
    if t == "RRSIG":
      return int(self[5])
    elif t == "DNSKEY":
      return int(self[6])
    elif t == "DS":
      return int(self[5])
    else:
      return -1

  def protocol(self):
    """ Returns proticol of the DNSKEY"""
    t = self.rr_type() 
    if t == "DNSKEY":
      return int(self[5])
    else:
      return -1

  def flags(self, number = False):
    """Return RR flags for DNSKEY """
    t = self.rr_type() 
    if t == "DNSKEY":
      ret = []
      n = int(self[4])
      if number:
        return n
      else:
        for m in range(16):
          if 2**(15-m) & n:
            if   m == 7: ret.append("ZONE")
            elif m == 8: ret.append("REVOKE")
            elif m ==15: ret.append("SEP")
            else:        ret.append(m)
    else:
      return []

_rr_types={
  "A"    : ldns.LDNS_RR_TYPE_A,
  "A6"   : ldns.LDNS_RR_TYPE_A6,
  "AAAA" : ldns.LDNS_RR_TYPE_AAAA,
  "AFSDB": ldns.LDNS_RR_TYPE_AFSDB,
  "ANY"  : ldns.LDNS_RR_TYPE_ANY,
  "APL"  : ldns.LDNS_RR_TYPE_APL,
  "ATMA" : ldns.LDNS_RR_TYPE_ATMA,
  "AXFR" : ldns.LDNS_RR_TYPE_AXFR,
  "CERT" : ldns.LDNS_RR_TYPE_CERT,
  "CNAME": ldns.LDNS_RR_TYPE_CNAME,
  "COUNT": ldns.LDNS_RR_TYPE_COUNT,
  "DHCID": ldns.LDNS_RR_TYPE_DHCID,
  "DLV"  : ldns.LDNS_RR_TYPE_DLV,
  "DNAME": ldns.LDNS_RR_TYPE_DNAME,
  "DNSKEY": ldns.LDNS_RR_TYPE_DNSKEY,
  "DS"   : ldns.LDNS_RR_TYPE_DS,
  "EID"  : ldns.LDNS_RR_TYPE_EID,
  "FIRST": ldns.LDNS_RR_TYPE_FIRST,
  "GID"  : ldns.LDNS_RR_TYPE_GID,
  "GPOS" : ldns.LDNS_RR_TYPE_GPOS,
  "HINFO": ldns.LDNS_RR_TYPE_HINFO,
  "IPSECKEY": ldns.LDNS_RR_TYPE_IPSECKEY,
  "ISDN" : ldns.LDNS_RR_TYPE_ISDN,
  "IXFR" : ldns.LDNS_RR_TYPE_IXFR,
  "KEY"  : ldns.LDNS_RR_TYPE_KEY,
  "KX"   : ldns.LDNS_RR_TYPE_KX,
  "LAST" : ldns.LDNS_RR_TYPE_LAST,
  "LOC"  : ldns.LDNS_RR_TYPE_LOC,
  "MAILA": ldns.LDNS_RR_TYPE_MAILA,
  "MAILB": ldns.LDNS_RR_TYPE_MAILB,
  "MB"   : ldns.LDNS_RR_TYPE_MB,
  "MD"   : ldns.LDNS_RR_TYPE_MD,
  "MF"   : ldns.LDNS_RR_TYPE_MF,
  "MG"   : ldns.LDNS_RR_TYPE_MG,
  "MINFO": ldns.LDNS_RR_TYPE_MINFO,
  "MR"   : ldns.LDNS_RR_TYPE_MR,
  "MX"   : ldns.LDNS_RR_TYPE_MX,
  "NAPTR": ldns.LDNS_RR_TYPE_NAPTR,
  "NIMLOC": ldns.LDNS_RR_TYPE_NIMLOC,
  "NS"   : ldns.LDNS_RR_TYPE_NS,
  "NSAP" : ldns.LDNS_RR_TYPE_NSAP,
  "NSAP_PTR" : ldns.LDNS_RR_TYPE_NSAP_PTR,
  "NSEC" : ldns.LDNS_RR_TYPE_NSEC,
  "NSEC3": ldns.LDNS_RR_TYPE_NSEC3,
  "NSEC3PARAMS" : ldns.LDNS_RR_TYPE_NSEC3PARAMS,
  "NULL" : ldns.LDNS_RR_TYPE_NULL,
  "NXT"  : ldns.LDNS_RR_TYPE_NXT,
  "OPT"  : ldns.LDNS_RR_TYPE_OPT,
  "PTR"  : ldns.LDNS_RR_TYPE_PTR,
  "PX"   : ldns.LDNS_RR_TYPE_PX,
  "RP"   : ldns.LDNS_RR_TYPE_RP,
  "RRSIG": ldns.LDNS_RR_TYPE_RRSIG,
  "RT"   : ldns.LDNS_RR_TYPE_RT,
  "SIG"  : ldns.LDNS_RR_TYPE_SIG,
  "SINK" : ldns.LDNS_RR_TYPE_SINK,
  "SOA"  : ldns.LDNS_RR_TYPE_SOA,
  "SRV"  : ldns.LDNS_RR_TYPE_SRV,
  "SSHFP": ldns.LDNS_RR_TYPE_SSHFP,
  "TSIG" : ldns.LDNS_RR_TYPE_TSIG,
  "TXT"  : ldns.LDNS_RR_TYPE_TXT,
  "UID"  : ldns.LDNS_RR_TYPE_UID,
  "UINFO": ldns.LDNS_RR_TYPE_UINFO,
  "UNSPEC": ldns.LDNS_RR_TYPE_UNSPEC,
  "WKS"  : ldns.LDNS_RR_TYPE_WKS,
  "X25"  : ldns.LDNS_RR_TYPE_X25
}