| # Copyright (C) 2001-2007, 2009, 2010 Nominum, Inc. |
| # |
| # Permission to use, copy, modify, and distribute this software and its |
| # documentation for any purpose with or without fee is hereby granted, |
| # provided that the above copyright notice and this permission notice |
| # appear in all copies. |
| # |
| # THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES |
| # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR |
| # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT |
| # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| |
| """DNS Messages""" |
| |
| import cStringIO |
| import random |
| import struct |
| import sys |
| import time |
| |
| import dns.exception |
| import dns.flags |
| import dns.name |
| import dns.opcode |
| import dns.entropy |
| import dns.rcode |
| import dns.rdata |
| import dns.rdataclass |
| import dns.rdatatype |
| import dns.rrset |
| import dns.renderer |
| import dns.tsig |
| |
| class ShortHeader(dns.exception.FormError): |
| """Raised if the DNS packet passed to from_wire() is too short.""" |
| pass |
| |
| class TrailingJunk(dns.exception.FormError): |
| """Raised if the DNS packet passed to from_wire() has extra junk |
| at the end of it.""" |
| pass |
| |
| class UnknownHeaderField(dns.exception.DNSException): |
| """Raised if a header field name is not recognized when converting from |
| text into a message.""" |
| pass |
| |
| class BadEDNS(dns.exception.FormError): |
| """Raised if an OPT record occurs somewhere other than the start of |
| the additional data section.""" |
| pass |
| |
| class BadTSIG(dns.exception.FormError): |
| """Raised if a TSIG record occurs somewhere other than the end of |
| the additional data section.""" |
| pass |
| |
| class UnknownTSIGKey(dns.exception.DNSException): |
| """Raised if we got a TSIG but don't know the key.""" |
| pass |
| |
| class Message(object): |
| """A DNS message. |
| |
| @ivar id: The query id; the default is a randomly chosen id. |
| @type id: int |
| @ivar flags: The DNS flags of the message. @see: RFC 1035 for an |
| explanation of these flags. |
| @type flags: int |
| @ivar question: The question section. |
| @type question: list of dns.rrset.RRset objects |
| @ivar answer: The answer section. |
| @type answer: list of dns.rrset.RRset objects |
| @ivar authority: The authority section. |
| @type authority: list of dns.rrset.RRset objects |
| @ivar additional: The additional data section. |
| @type additional: list of dns.rrset.RRset objects |
| @ivar edns: The EDNS level to use. The default is -1, no Edns. |
| @type edns: int |
| @ivar ednsflags: The EDNS flags |
| @type ednsflags: long |
| @ivar payload: The EDNS payload size. The default is 0. |
| @type payload: int |
| @ivar options: The EDNS options |
| @type options: list of dns.edns.Option objects |
| @ivar request_payload: The associated request's EDNS payload size. |
| @type request_payload: int |
| @ivar keyring: The TSIG keyring to use. The default is None. |
| @type keyring: dict |
| @ivar keyname: The TSIG keyname to use. The default is None. |
| @type keyname: dns.name.Name object |
| @ivar keyalgorithm: The TSIG key algorithm to use. The default is |
| dns.tsig.default_algorithm. |
| @type keyalgorithm: string |
| @ivar request_mac: The TSIG MAC of the request message associated with |
| this message; used when validating TSIG signatures. @see: RFC 2845 for |
| more information on TSIG fields. |
| @type request_mac: string |
| @ivar fudge: TSIG time fudge; default is 300 seconds. |
| @type fudge: int |
| @ivar original_id: TSIG original id; defaults to the message's id |
| @type original_id: int |
| @ivar tsig_error: TSIG error code; default is 0. |
| @type tsig_error: int |
| @ivar other_data: TSIG other data. |
| @type other_data: string |
| @ivar mac: The TSIG MAC for this message. |
| @type mac: string |
| @ivar xfr: Is the message being used to contain the results of a DNS |
| zone transfer? The default is False. |
| @type xfr: bool |
| @ivar origin: The origin of the zone in messages which are used for |
| zone transfers or for DNS dynamic updates. The default is None. |
| @type origin: dns.name.Name object |
| @ivar tsig_ctx: The TSIG signature context associated with this |
| message. The default is None. |
| @type tsig_ctx: hmac.HMAC object |
| @ivar had_tsig: Did the message decoded from wire format have a TSIG |
| signature? |
| @type had_tsig: bool |
| @ivar multi: Is this message part of a multi-message sequence? The |
| default is false. This variable is used when validating TSIG signatures |
| on messages which are part of a zone transfer. |
| @type multi: bool |
| @ivar first: Is this message standalone, or the first of a multi |
| message sequence? This variable is used when validating TSIG signatures |
| on messages which are part of a zone transfer. |
| @type first: bool |
| @ivar index: An index of rrsets in the message. The index key is |
| (section, name, rdclass, rdtype, covers, deleting). Indexing can be |
| disabled by setting the index to None. |
| @type index: dict |
| """ |
| |
| def __init__(self, id=None): |
| if id is None: |
| self.id = dns.entropy.random_16() |
| else: |
| self.id = id |
| self.flags = 0 |
| self.question = [] |
| self.answer = [] |
| self.authority = [] |
| self.additional = [] |
| self.edns = -1 |
| self.ednsflags = 0 |
| self.payload = 0 |
| self.options = [] |
| self.request_payload = 0 |
| self.keyring = None |
| self.keyname = None |
| self.keyalgorithm = dns.tsig.default_algorithm |
| self.request_mac = '' |
| self.other_data = '' |
| self.tsig_error = 0 |
| self.fudge = 300 |
| self.original_id = self.id |
| self.mac = '' |
| self.xfr = False |
| self.origin = None |
| self.tsig_ctx = None |
| self.had_tsig = False |
| self.multi = False |
| self.first = True |
| self.index = {} |
| |
| def __repr__(self): |
| return '<DNS message, ID ' + `self.id` + '>' |
| |
| def __str__(self): |
| return self.to_text() |
| |
| def to_text(self, origin=None, relativize=True, **kw): |
| """Convert the message to text. |
| |
| The I{origin}, I{relativize}, and any other keyword |
| arguments are passed to the rrset to_wire() method. |
| |
| @rtype: string |
| """ |
| |
| s = cStringIO.StringIO() |
| print >> s, 'id %d' % self.id |
| print >> s, 'opcode %s' % \ |
| dns.opcode.to_text(dns.opcode.from_flags(self.flags)) |
| rc = dns.rcode.from_flags(self.flags, self.ednsflags) |
| print >> s, 'rcode %s' % dns.rcode.to_text(rc) |
| print >> s, 'flags %s' % dns.flags.to_text(self.flags) |
| if self.edns >= 0: |
| print >> s, 'edns %s' % self.edns |
| if self.ednsflags != 0: |
| print >> s, 'eflags %s' % \ |
| dns.flags.edns_to_text(self.ednsflags) |
| print >> s, 'payload', self.payload |
| is_update = dns.opcode.is_update(self.flags) |
| if is_update: |
| print >> s, ';ZONE' |
| else: |
| print >> s, ';QUESTION' |
| for rrset in self.question: |
| print >> s, rrset.to_text(origin, relativize, **kw) |
| if is_update: |
| print >> s, ';PREREQ' |
| else: |
| print >> s, ';ANSWER' |
| for rrset in self.answer: |
| print >> s, rrset.to_text(origin, relativize, **kw) |
| if is_update: |
| print >> s, ';UPDATE' |
| else: |
| print >> s, ';AUTHORITY' |
| for rrset in self.authority: |
| print >> s, rrset.to_text(origin, relativize, **kw) |
| print >> s, ';ADDITIONAL' |
| for rrset in self.additional: |
| print >> s, rrset.to_text(origin, relativize, **kw) |
| # |
| # We strip off the final \n so the caller can print the result without |
| # doing weird things to get around eccentricities in Python print |
| # formatting |
| # |
| return s.getvalue()[:-1] |
| |
| def __eq__(self, other): |
| """Two messages are equal if they have the same content in the |
| header, question, answer, and authority sections. |
| @rtype: bool""" |
| if not isinstance(other, Message): |
| return False |
| if self.id != other.id: |
| return False |
| if self.flags != other.flags: |
| return False |
| for n in self.question: |
| if n not in other.question: |
| return False |
| for n in other.question: |
| if n not in self.question: |
| return False |
| for n in self.answer: |
| if n not in other.answer: |
| return False |
| for n in other.answer: |
| if n not in self.answer: |
| return False |
| for n in self.authority: |
| if n not in other.authority: |
| return False |
| for n in other.authority: |
| if n not in self.authority: |
| return False |
| return True |
| |
| def __ne__(self, other): |
| """Are two messages not equal? |
| @rtype: bool""" |
| return not self.__eq__(other) |
| |
| def is_response(self, other): |
| """Is other a response to self? |
| @rtype: bool""" |
| if other.flags & dns.flags.QR == 0 or \ |
| self.id != other.id or \ |
| dns.opcode.from_flags(self.flags) != \ |
| dns.opcode.from_flags(other.flags): |
| return False |
| if dns.rcode.from_flags(other.flags, other.ednsflags) != \ |
| dns.rcode.NOERROR: |
| return True |
| if dns.opcode.is_update(self.flags): |
| return True |
| for n in self.question: |
| if n not in other.question: |
| return False |
| for n in other.question: |
| if n not in self.question: |
| return False |
| return True |
| |
| def section_number(self, section): |
| if section is self.question: |
| return 0 |
| elif section is self.answer: |
| return 1 |
| elif section is self.authority: |
| return 2 |
| elif section is self.additional: |
| return 3 |
| else: |
| raise ValueError('unknown section') |
| |
| def find_rrset(self, section, name, rdclass, rdtype, |
| covers=dns.rdatatype.NONE, deleting=None, create=False, |
| force_unique=False): |
| """Find the RRset with the given attributes in the specified section. |
| |
| @param section: the section of the message to look in, e.g. |
| self.answer. |
| @type section: list of dns.rrset.RRset objects |
| @param name: the name of the RRset |
| @type name: dns.name.Name object |
| @param rdclass: the class of the RRset |
| @type rdclass: int |
| @param rdtype: the type of the RRset |
| @type rdtype: int |
| @param covers: the covers value of the RRset |
| @type covers: int |
| @param deleting: the deleting value of the RRset |
| @type deleting: int |
| @param create: If True, create the RRset if it is not found. |
| The created RRset is appended to I{section}. |
| @type create: bool |
| @param force_unique: If True and create is also True, create a |
| new RRset regardless of whether a matching RRset exists already. |
| @type force_unique: bool |
| @raises KeyError: the RRset was not found and create was False |
| @rtype: dns.rrset.RRset object""" |
| |
| key = (self.section_number(section), |
| name, rdclass, rdtype, covers, deleting) |
| if not force_unique: |
| if not self.index is None: |
| rrset = self.index.get(key) |
| if not rrset is None: |
| return rrset |
| else: |
| for rrset in section: |
| if rrset.match(name, rdclass, rdtype, covers, deleting): |
| return rrset |
| if not create: |
| raise KeyError |
| rrset = dns.rrset.RRset(name, rdclass, rdtype, covers, deleting) |
| section.append(rrset) |
| if not self.index is None: |
| self.index[key] = rrset |
| return rrset |
| |
| def get_rrset(self, section, name, rdclass, rdtype, |
| covers=dns.rdatatype.NONE, deleting=None, create=False, |
| force_unique=False): |
| """Get the RRset with the given attributes in the specified section. |
| |
| If the RRset is not found, None is returned. |
| |
| @param section: the section of the message to look in, e.g. |
| self.answer. |
| @type section: list of dns.rrset.RRset objects |
| @param name: the name of the RRset |
| @type name: dns.name.Name object |
| @param rdclass: the class of the RRset |
| @type rdclass: int |
| @param rdtype: the type of the RRset |
| @type rdtype: int |
| @param covers: the covers value of the RRset |
| @type covers: int |
| @param deleting: the deleting value of the RRset |
| @type deleting: int |
| @param create: If True, create the RRset if it is not found. |
| The created RRset is appended to I{section}. |
| @type create: bool |
| @param force_unique: If True and create is also True, create a |
| new RRset regardless of whether a matching RRset exists already. |
| @type force_unique: bool |
| @rtype: dns.rrset.RRset object or None""" |
| |
| try: |
| rrset = self.find_rrset(section, name, rdclass, rdtype, covers, |
| deleting, create, force_unique) |
| except KeyError: |
| rrset = None |
| return rrset |
| |
| def to_wire(self, origin=None, max_size=0, **kw): |
| """Return a string containing the message in DNS compressed wire |
| format. |
| |
| Additional keyword arguments are passed to the rrset to_wire() |
| method. |
| |
| @param origin: The origin to be appended to any relative names. |
| @type origin: dns.name.Name object |
| @param max_size: The maximum size of the wire format output; default |
| is 0, which means 'the message's request payload, if nonzero, or |
| 65536'. |
| @type max_size: int |
| @raises dns.exception.TooBig: max_size was exceeded |
| @rtype: string |
| """ |
| |
| if max_size == 0: |
| if self.request_payload != 0: |
| max_size = self.request_payload |
| else: |
| max_size = 65535 |
| if max_size < 512: |
| max_size = 512 |
| elif max_size > 65535: |
| max_size = 65535 |
| r = dns.renderer.Renderer(self.id, self.flags, max_size, origin) |
| for rrset in self.question: |
| r.add_question(rrset.name, rrset.rdtype, rrset.rdclass) |
| for rrset in self.answer: |
| r.add_rrset(dns.renderer.ANSWER, rrset, **kw) |
| for rrset in self.authority: |
| r.add_rrset(dns.renderer.AUTHORITY, rrset, **kw) |
| if self.edns >= 0: |
| r.add_edns(self.edns, self.ednsflags, self.payload, self.options) |
| for rrset in self.additional: |
| r.add_rrset(dns.renderer.ADDITIONAL, rrset, **kw) |
| r.write_header() |
| if not self.keyname is None: |
| r.add_tsig(self.keyname, self.keyring[self.keyname], |
| self.fudge, self.original_id, self.tsig_error, |
| self.other_data, self.request_mac, |
| self.keyalgorithm) |
| self.mac = r.mac |
| return r.get_wire() |
| |
| def use_tsig(self, keyring, keyname=None, fudge=300, |
| original_id=None, tsig_error=0, other_data='', |
| algorithm=dns.tsig.default_algorithm): |
| """When sending, a TSIG signature using the specified keyring |
| and keyname should be added. |
| |
| @param keyring: The TSIG keyring to use; defaults to None. |
| @type keyring: dict |
| @param keyname: The name of the TSIG key to use; defaults to None. |
| The key must be defined in the keyring. If a keyring is specified |
| but a keyname is not, then the key used will be the first key in the |
| keyring. Note that the order of keys in a dictionary is not defined, |
| so applications should supply a keyname when a keyring is used, unless |
| they know the keyring contains only one key. |
| @type keyname: dns.name.Name or string |
| @param fudge: TSIG time fudge; default is 300 seconds. |
| @type fudge: int |
| @param original_id: TSIG original id; defaults to the message's id |
| @type original_id: int |
| @param tsig_error: TSIG error code; default is 0. |
| @type tsig_error: int |
| @param other_data: TSIG other data. |
| @type other_data: string |
| @param algorithm: The TSIG algorithm to use; defaults to |
| dns.tsig.default_algorithm |
| """ |
| |
| self.keyring = keyring |
| if keyname is None: |
| self.keyname = self.keyring.keys()[0] |
| else: |
| if isinstance(keyname, (str, unicode)): |
| keyname = dns.name.from_text(keyname) |
| self.keyname = keyname |
| self.keyalgorithm = algorithm |
| self.fudge = fudge |
| if original_id is None: |
| self.original_id = self.id |
| else: |
| self.original_id = original_id |
| self.tsig_error = tsig_error |
| self.other_data = other_data |
| |
| def use_edns(self, edns=0, ednsflags=0, payload=1280, request_payload=None, options=None): |
| """Configure EDNS behavior. |
| @param edns: The EDNS level to use. Specifying None, False, or -1 |
| means 'do not use EDNS', and in this case the other parameters are |
| ignored. Specifying True is equivalent to specifying 0, i.e. 'use |
| EDNS0'. |
| @type edns: int or bool or None |
| @param ednsflags: EDNS flag values. |
| @type ednsflags: int |
| @param payload: The EDNS sender's payload field, which is the maximum |
| size of UDP datagram the sender can handle. |
| @type payload: int |
| @param request_payload: The EDNS payload size to use when sending |
| this message. If not specified, defaults to the value of payload. |
| @type request_payload: int or None |
| @param options: The EDNS options |
| @type options: None or list of dns.edns.Option objects |
| @see: RFC 2671 |
| """ |
| if edns is None or edns is False: |
| edns = -1 |
| if edns is True: |
| edns = 0 |
| if request_payload is None: |
| request_payload = payload |
| if edns < 0: |
| ednsflags = 0 |
| payload = 0 |
| request_payload = 0 |
| options = [] |
| else: |
| # make sure the EDNS version in ednsflags agrees with edns |
| ednsflags &= 0xFF00FFFFL |
| ednsflags |= (edns << 16) |
| if options is None: |
| options = [] |
| self.edns = edns |
| self.ednsflags = ednsflags |
| self.payload = payload |
| self.options = options |
| self.request_payload = request_payload |
| |
| def want_dnssec(self, wanted=True): |
| """Enable or disable 'DNSSEC desired' flag in requests. |
| @param wanted: Is DNSSEC desired? If True, EDNS is enabled if |
| required, and then the DO bit is set. If False, the DO bit is |
| cleared if EDNS is enabled. |
| @type wanted: bool |
| """ |
| if wanted: |
| if self.edns < 0: |
| self.use_edns() |
| self.ednsflags |= dns.flags.DO |
| elif self.edns >= 0: |
| self.ednsflags &= ~dns.flags.DO |
| |
| def rcode(self): |
| """Return the rcode. |
| @rtype: int |
| """ |
| return dns.rcode.from_flags(self.flags, self.ednsflags) |
| |
| def set_rcode(self, rcode): |
| """Set the rcode. |
| @param rcode: the rcode |
| @type rcode: int |
| """ |
| (value, evalue) = dns.rcode.to_flags(rcode) |
| self.flags &= 0xFFF0 |
| self.flags |= value |
| self.ednsflags &= 0x00FFFFFFL |
| self.ednsflags |= evalue |
| if self.ednsflags != 0 and self.edns < 0: |
| self.edns = 0 |
| |
| def opcode(self): |
| """Return the opcode. |
| @rtype: int |
| """ |
| return dns.opcode.from_flags(self.flags) |
| |
| def set_opcode(self, opcode): |
| """Set the opcode. |
| @param opcode: the opcode |
| @type opcode: int |
| """ |
| self.flags &= 0x87FF |
| self.flags |= dns.opcode.to_flags(opcode) |
| |
| class _WireReader(object): |
| """Wire format reader. |
| |
| @ivar wire: the wire-format message. |
| @type wire: string |
| @ivar message: The message object being built |
| @type message: dns.message.Message object |
| @ivar current: When building a message object from wire format, this |
| variable contains the offset from the beginning of wire of the next octet |
| to be read. |
| @type current: int |
| @ivar updating: Is the message a dynamic update? |
| @type updating: bool |
| @ivar one_rr_per_rrset: Put each RR into its own RRset? |
| @type one_rr_per_rrset: bool |
| @ivar zone_rdclass: The class of the zone in messages which are |
| DNS dynamic updates. |
| @type zone_rdclass: int |
| """ |
| |
| def __init__(self, wire, message, question_only=False, |
| one_rr_per_rrset=False): |
| self.wire = wire |
| self.message = message |
| self.current = 0 |
| self.updating = False |
| self.zone_rdclass = dns.rdataclass.IN |
| self.question_only = question_only |
| self.one_rr_per_rrset = one_rr_per_rrset |
| |
| def _get_question(self, qcount): |
| """Read the next I{qcount} records from the wire data and add them to |
| the question section. |
| @param qcount: the number of questions in the message |
| @type qcount: int""" |
| |
| if self.updating and qcount > 1: |
| raise dns.exception.FormError |
| |
| for i in xrange(0, qcount): |
| (qname, used) = dns.name.from_wire(self.wire, self.current) |
| if not self.message.origin is None: |
| qname = qname.relativize(self.message.origin) |
| self.current = self.current + used |
| (rdtype, rdclass) = \ |
| struct.unpack('!HH', |
| self.wire[self.current:self.current + 4]) |
| self.current = self.current + 4 |
| self.message.find_rrset(self.message.question, qname, |
| rdclass, rdtype, create=True, |
| force_unique=True) |
| if self.updating: |
| self.zone_rdclass = rdclass |
| |
| def _get_section(self, section, count): |
| """Read the next I{count} records from the wire data and add them to |
| the specified section. |
| @param section: the section of the message to which to add records |
| @type section: list of dns.rrset.RRset objects |
| @param count: the number of records to read |
| @type count: int""" |
| |
| if self.updating or self.one_rr_per_rrset: |
| force_unique = True |
| else: |
| force_unique = False |
| seen_opt = False |
| for i in xrange(0, count): |
| rr_start = self.current |
| (name, used) = dns.name.from_wire(self.wire, self.current) |
| absolute_name = name |
| if not self.message.origin is None: |
| name = name.relativize(self.message.origin) |
| self.current = self.current + used |
| (rdtype, rdclass, ttl, rdlen) = \ |
| struct.unpack('!HHIH', |
| self.wire[self.current:self.current + 10]) |
| self.current = self.current + 10 |
| if rdtype == dns.rdatatype.OPT: |
| if not section is self.message.additional or seen_opt: |
| raise BadEDNS |
| self.message.payload = rdclass |
| self.message.ednsflags = ttl |
| self.message.edns = (ttl & 0xff0000) >> 16 |
| self.message.options = [] |
| current = self.current |
| optslen = rdlen |
| while optslen > 0: |
| (otype, olen) = \ |
| struct.unpack('!HH', |
| self.wire[current:current + 4]) |
| current = current + 4 |
| opt = dns.edns.option_from_wire(otype, self.wire, current, olen) |
| self.message.options.append(opt) |
| current = current + olen |
| optslen = optslen - 4 - olen |
| seen_opt = True |
| elif rdtype == dns.rdatatype.TSIG: |
| if not (section is self.message.additional and |
| i == (count - 1)): |
| raise BadTSIG |
| if self.message.keyring is None: |
| raise UnknownTSIGKey('got signed message without keyring') |
| secret = self.message.keyring.get(absolute_name) |
| if secret is None: |
| raise UnknownTSIGKey("key '%s' unknown" % name) |
| self.message.tsig_ctx = \ |
| dns.tsig.validate(self.wire, |
| absolute_name, |
| secret, |
| int(time.time()), |
| self.message.request_mac, |
| rr_start, |
| self.current, |
| rdlen, |
| self.message.tsig_ctx, |
| self.message.multi, |
| self.message.first) |
| self.message.had_tsig = True |
| else: |
| if ttl < 0: |
| ttl = 0 |
| if self.updating and \ |
| (rdclass == dns.rdataclass.ANY or |
| rdclass == dns.rdataclass.NONE): |
| deleting = rdclass |
| rdclass = self.zone_rdclass |
| else: |
| deleting = None |
| if deleting == dns.rdataclass.ANY or \ |
| (deleting == dns.rdataclass.NONE and \ |
| section == self.message.answer): |
| covers = dns.rdatatype.NONE |
| rd = None |
| else: |
| rd = dns.rdata.from_wire(rdclass, rdtype, self.wire, |
| self.current, rdlen, |
| self.message.origin) |
| covers = rd.covers() |
| if self.message.xfr and rdtype == dns.rdatatype.SOA: |
| force_unique = True |
| rrset = self.message.find_rrset(section, name, |
| rdclass, rdtype, covers, |
| deleting, True, force_unique) |
| if not rd is None: |
| rrset.add(rd, ttl) |
| self.current = self.current + rdlen |
| |
| def read(self): |
| """Read a wire format DNS message and build a dns.message.Message |
| object.""" |
| |
| l = len(self.wire) |
| if l < 12: |
| raise ShortHeader |
| (self.message.id, self.message.flags, qcount, ancount, |
| aucount, adcount) = struct.unpack('!HHHHHH', self.wire[:12]) |
| self.current = 12 |
| if dns.opcode.is_update(self.message.flags): |
| self.updating = True |
| self._get_question(qcount) |
| if self.question_only: |
| return |
| self._get_section(self.message.answer, ancount) |
| self._get_section(self.message.authority, aucount) |
| self._get_section(self.message.additional, adcount) |
| if self.current != l: |
| raise TrailingJunk |
| if self.message.multi and self.message.tsig_ctx and \ |
| not self.message.had_tsig: |
| self.message.tsig_ctx.update(self.wire) |
| |
| |
| def from_wire(wire, keyring=None, request_mac='', xfr=False, origin=None, |
| tsig_ctx = None, multi = False, first = True, |
| question_only = False, one_rr_per_rrset = False): |
| """Convert a DNS wire format message into a message |
| object. |
| |
| @param keyring: The keyring to use if the message is signed. |
| @type keyring: dict |
| @param request_mac: If the message is a response to a TSIG-signed request, |
| I{request_mac} should be set to the MAC of that request. |
| @type request_mac: string |
| @param xfr: Is this message part of a zone transfer? |
| @type xfr: bool |
| @param origin: If the message is part of a zone transfer, I{origin} |
| should be the origin name of the zone. |
| @type origin: dns.name.Name object |
| @param tsig_ctx: The ongoing TSIG context, used when validating zone |
| transfers. |
| @type tsig_ctx: hmac.HMAC object |
| @param multi: Is this message part of a multiple message sequence? |
| @type multi: bool |
| @param first: Is this message standalone, or the first of a multi |
| message sequence? |
| @type first: bool |
| @param question_only: Read only up to the end of the question section? |
| @type question_only: bool |
| @param one_rr_per_rrset: Put each RR into its own RRset |
| @type one_rr_per_rrset: bool |
| @raises ShortHeader: The message is less than 12 octets long. |
| @raises TrailingJunk: There were octets in the message past the end |
| of the proper DNS message. |
| @raises BadEDNS: An OPT record was in the wrong section, or occurred more |
| than once. |
| @raises BadTSIG: A TSIG record was not the last record of the additional |
| data section. |
| @rtype: dns.message.Message object""" |
| |
| m = Message(id=0) |
| m.keyring = keyring |
| m.request_mac = request_mac |
| m.xfr = xfr |
| m.origin = origin |
| m.tsig_ctx = tsig_ctx |
| m.multi = multi |
| m.first = first |
| |
| reader = _WireReader(wire, m, question_only, one_rr_per_rrset) |
| reader.read() |
| |
| return m |
| |
| |
| class _TextReader(object): |
| """Text format reader. |
| |
| @ivar tok: the tokenizer |
| @type tok: dns.tokenizer.Tokenizer object |
| @ivar message: The message object being built |
| @type message: dns.message.Message object |
| @ivar updating: Is the message a dynamic update? |
| @type updating: bool |
| @ivar zone_rdclass: The class of the zone in messages which are |
| DNS dynamic updates. |
| @type zone_rdclass: int |
| @ivar last_name: The most recently read name when building a message object |
| from text format. |
| @type last_name: dns.name.Name object |
| """ |
| |
| def __init__(self, text, message): |
| self.message = message |
| self.tok = dns.tokenizer.Tokenizer(text) |
| self.last_name = None |
| self.zone_rdclass = dns.rdataclass.IN |
| self.updating = False |
| |
| def _header_line(self, section): |
| """Process one line from the text format header section.""" |
| |
| token = self.tok.get() |
| what = token.value |
| if what == 'id': |
| self.message.id = self.tok.get_int() |
| elif what == 'flags': |
| while True: |
| token = self.tok.get() |
| if not token.is_identifier(): |
| self.tok.unget(token) |
| break |
| self.message.flags = self.message.flags | \ |
| dns.flags.from_text(token.value) |
| if dns.opcode.is_update(self.message.flags): |
| self.updating = True |
| elif what == 'edns': |
| self.message.edns = self.tok.get_int() |
| self.message.ednsflags = self.message.ednsflags | \ |
| (self.message.edns << 16) |
| elif what == 'eflags': |
| if self.message.edns < 0: |
| self.message.edns = 0 |
| while True: |
| token = self.tok.get() |
| if not token.is_identifier(): |
| self.tok.unget(token) |
| break |
| self.message.ednsflags = self.message.ednsflags | \ |
| dns.flags.edns_from_text(token.value) |
| elif what == 'payload': |
| self.message.payload = self.tok.get_int() |
| if self.message.edns < 0: |
| self.message.edns = 0 |
| elif what == 'opcode': |
| text = self.tok.get_string() |
| self.message.flags = self.message.flags | \ |
| dns.opcode.to_flags(dns.opcode.from_text(text)) |
| elif what == 'rcode': |
| text = self.tok.get_string() |
| self.message.set_rcode(dns.rcode.from_text(text)) |
| else: |
| raise UnknownHeaderField |
| self.tok.get_eol() |
| |
| def _question_line(self, section): |
| """Process one line from the text format question section.""" |
| |
| token = self.tok.get(want_leading = True) |
| if not token.is_whitespace(): |
| self.last_name = dns.name.from_text(token.value, None) |
| name = self.last_name |
| token = self.tok.get() |
| if not token.is_identifier(): |
| raise dns.exception.SyntaxError |
| # Class |
| try: |
| rdclass = dns.rdataclass.from_text(token.value) |
| token = self.tok.get() |
| if not token.is_identifier(): |
| raise dns.exception.SyntaxError |
| except dns.exception.SyntaxError: |
| raise dns.exception.SyntaxError |
| except: |
| rdclass = dns.rdataclass.IN |
| # Type |
| rdtype = dns.rdatatype.from_text(token.value) |
| self.message.find_rrset(self.message.question, name, |
| rdclass, rdtype, create=True, |
| force_unique=True) |
| if self.updating: |
| self.zone_rdclass = rdclass |
| self.tok.get_eol() |
| |
| def _rr_line(self, section): |
| """Process one line from the text format answer, authority, or |
| additional data sections. |
| """ |
| |
| deleting = None |
| # Name |
| token = self.tok.get(want_leading = True) |
| if not token.is_whitespace(): |
| self.last_name = dns.name.from_text(token.value, None) |
| name = self.last_name |
| token = self.tok.get() |
| if not token.is_identifier(): |
| raise dns.exception.SyntaxError |
| # TTL |
| try: |
| ttl = int(token.value, 0) |
| token = self.tok.get() |
| if not token.is_identifier(): |
| raise dns.exception.SyntaxError |
| except dns.exception.SyntaxError: |
| raise dns.exception.SyntaxError |
| except: |
| ttl = 0 |
| # Class |
| try: |
| rdclass = dns.rdataclass.from_text(token.value) |
| token = self.tok.get() |
| if not token.is_identifier(): |
| raise dns.exception.SyntaxError |
| if rdclass == dns.rdataclass.ANY or rdclass == dns.rdataclass.NONE: |
| deleting = rdclass |
| rdclass = self.zone_rdclass |
| except dns.exception.SyntaxError: |
| raise dns.exception.SyntaxError |
| except: |
| rdclass = dns.rdataclass.IN |
| # Type |
| rdtype = dns.rdatatype.from_text(token.value) |
| token = self.tok.get() |
| if not token.is_eol_or_eof(): |
| self.tok.unget(token) |
| rd = dns.rdata.from_text(rdclass, rdtype, self.tok, None) |
| covers = rd.covers() |
| else: |
| rd = None |
| covers = dns.rdatatype.NONE |
| rrset = self.message.find_rrset(section, name, |
| rdclass, rdtype, covers, |
| deleting, True, self.updating) |
| if not rd is None: |
| rrset.add(rd, ttl) |
| |
| def read(self): |
| """Read a text format DNS message and build a dns.message.Message |
| object.""" |
| |
| line_method = self._header_line |
| section = None |
| while 1: |
| token = self.tok.get(True, True) |
| if token.is_eol_or_eof(): |
| break |
| if token.is_comment(): |
| u = token.value.upper() |
| if u == 'HEADER': |
| line_method = self._header_line |
| elif u == 'QUESTION' or u == 'ZONE': |
| line_method = self._question_line |
| section = self.message.question |
| elif u == 'ANSWER' or u == 'PREREQ': |
| line_method = self._rr_line |
| section = self.message.answer |
| elif u == 'AUTHORITY' or u == 'UPDATE': |
| line_method = self._rr_line |
| section = self.message.authority |
| elif u == 'ADDITIONAL': |
| line_method = self._rr_line |
| section = self.message.additional |
| self.tok.get_eol() |
| continue |
| self.tok.unget(token) |
| line_method(section) |
| |
| |
| def from_text(text): |
| """Convert the text format message into a message object. |
| |
| @param text: The text format message. |
| @type text: string |
| @raises UnknownHeaderField: |
| @raises dns.exception.SyntaxError: |
| @rtype: dns.message.Message object""" |
| |
| # 'text' can also be a file, but we don't publish that fact |
| # since it's an implementation detail. The official file |
| # interface is from_file(). |
| |
| m = Message() |
| |
| reader = _TextReader(text, m) |
| reader.read() |
| |
| return m |
| |
| def from_file(f): |
| """Read the next text format message from the specified file. |
| |
| @param f: file or string. If I{f} is a string, it is treated |
| as the name of a file to open. |
| @raises UnknownHeaderField: |
| @raises dns.exception.SyntaxError: |
| @rtype: dns.message.Message object""" |
| |
| if sys.hexversion >= 0x02030000: |
| # allow Unicode filenames; turn on universal newline support |
| str_type = basestring |
| opts = 'rU' |
| else: |
| str_type = str |
| opts = 'r' |
| if isinstance(f, str_type): |
| f = file(f, opts) |
| want_close = True |
| else: |
| want_close = False |
| |
| try: |
| m = from_text(f) |
| finally: |
| if want_close: |
| f.close() |
| return m |
| |
| def make_query(qname, rdtype, rdclass = dns.rdataclass.IN, use_edns=None, |
| want_dnssec=False): |
| """Make a query message. |
| |
| The query name, type, and class may all be specified either |
| as objects of the appropriate type, or as strings. |
| |
| The query will have a randomly choosen query id, and its DNS flags |
| will be set to dns.flags.RD. |
| |
| @param qname: The query name. |
| @type qname: dns.name.Name object or string |
| @param rdtype: The desired rdata type. |
| @type rdtype: int |
| @param rdclass: The desired rdata class; the default is class IN. |
| @type rdclass: int |
| @param use_edns: The EDNS level to use; the default is None (no EDNS). |
| See the description of dns.message.Message.use_edns() for the possible |
| values for use_edns and their meanings. |
| @type use_edns: int or bool or None |
| @param want_dnssec: Should the query indicate that DNSSEC is desired? |
| @type want_dnssec: bool |
| @rtype: dns.message.Message object""" |
| |
| if isinstance(qname, (str, unicode)): |
| qname = dns.name.from_text(qname) |
| if isinstance(rdtype, str): |
| rdtype = dns.rdatatype.from_text(rdtype) |
| if isinstance(rdclass, str): |
| rdclass = dns.rdataclass.from_text(rdclass) |
| m = Message() |
| m.flags |= dns.flags.RD |
| m.find_rrset(m.question, qname, rdclass, rdtype, create=True, |
| force_unique=True) |
| m.use_edns(use_edns) |
| m.want_dnssec(want_dnssec) |
| return m |
| |
| def make_response(query, recursion_available=False, our_payload=8192): |
| """Make a message which is a response for the specified query. |
| The message returned is really a response skeleton; it has all |
| of the infrastructure required of a response, but none of the |
| content. |
| |
| The response's question section is a shallow copy of the query's |
| question section, so the query's question RRsets should not be |
| changed. |
| |
| @param query: the query to respond to |
| @type query: dns.message.Message object |
| @param recursion_available: should RA be set in the response? |
| @type recursion_available: bool |
| @param our_payload: payload size to advertise in EDNS responses; default |
| is 8192. |
| @type our_payload: int |
| @rtype: dns.message.Message object""" |
| |
| if query.flags & dns.flags.QR: |
| raise dns.exception.FormError('specified query message is not a query') |
| response = dns.message.Message(query.id) |
| response.flags = dns.flags.QR | (query.flags & dns.flags.RD) |
| if recursion_available: |
| response.flags |= dns.flags.RA |
| response.set_opcode(query.opcode()) |
| response.question = list(query.question) |
| if query.edns >= 0: |
| response.use_edns(0, 0, our_payload, query.payload) |
| if not query.keyname is None: |
| response.keyname = query.keyname |
| response.keyring = query.keyring |
| response.request_mac = query.mac |
| return response |
