| 1 | # Copyright (C) 2001-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 Messages"""
|
|---|
| 17 |
|
|---|
| 18 | import cStringIO
|
|---|
| 19 | import random
|
|---|
| 20 | import struct
|
|---|
| 21 | import sys
|
|---|
| 22 | import time
|
|---|
| 23 |
|
|---|
| 24 | import dns.edns
|
|---|
| 25 | import dns.exception
|
|---|
| 26 | import dns.flags
|
|---|
| 27 | import dns.name
|
|---|
| 28 | import dns.opcode
|
|---|
| 29 | import dns.entropy
|
|---|
| 30 | import dns.rcode
|
|---|
| 31 | import dns.rdata
|
|---|
| 32 | import dns.rdataclass
|
|---|
| 33 | import dns.rdatatype
|
|---|
| 34 | import dns.rrset
|
|---|
| 35 | import dns.renderer
|
|---|
| 36 | import dns.tsig
|
|---|
| 37 |
|
|---|
| 38 | class ShortHeader(dns.exception.FormError):
|
|---|
| 39 | """Raised if the DNS packet passed to from_wire() is too short."""
|
|---|
| 40 | pass
|
|---|
| 41 |
|
|---|
| 42 | class TrailingJunk(dns.exception.FormError):
|
|---|
| 43 | """Raised if the DNS packet passed to from_wire() has extra junk
|
|---|
| 44 | at the end of it."""
|
|---|
| 45 | pass
|
|---|
| 46 |
|
|---|
| 47 | class UnknownHeaderField(dns.exception.DNSException):
|
|---|
| 48 | """Raised if a header field name is not recognized when converting from
|
|---|
| 49 | text into a message."""
|
|---|
| 50 | pass
|
|---|
| 51 |
|
|---|
| 52 | class BadEDNS(dns.exception.FormError):
|
|---|
| 53 | """Raised if an OPT record occurs somewhere other than the start of
|
|---|
| 54 | the additional data section."""
|
|---|
| 55 | pass
|
|---|
| 56 |
|
|---|
| 57 | class BadTSIG(dns.exception.FormError):
|
|---|
| 58 | """Raised if a TSIG record occurs somewhere other than the end of
|
|---|
| 59 | the additional data section."""
|
|---|
| 60 | pass
|
|---|
| 61 |
|
|---|
| 62 | class UnknownTSIGKey(dns.exception.DNSException):
|
|---|
| 63 | """Raised if we got a TSIG but don't know the key."""
|
|---|
| 64 | pass
|
|---|
| 65 |
|
|---|
| 66 | class Message(object):
|
|---|
| 67 | """A DNS message.
|
|---|
| 68 |
|
|---|
| 69 | @ivar id: The query id; the default is a randomly chosen id.
|
|---|
| 70 | @type id: int
|
|---|
| 71 | @ivar flags: The DNS flags of the message. @see: RFC 1035 for an
|
|---|
| 72 | explanation of these flags.
|
|---|
| 73 | @type flags: int
|
|---|
| 74 | @ivar question: The question section.
|
|---|
| 75 | @type question: list of dns.rrset.RRset objects
|
|---|
| 76 | @ivar answer: The answer section.
|
|---|
| 77 | @type answer: list of dns.rrset.RRset objects
|
|---|
| 78 | @ivar authority: The authority section.
|
|---|
| 79 | @type authority: list of dns.rrset.RRset objects
|
|---|
| 80 | @ivar additional: The additional data section.
|
|---|
| 81 | @type additional: list of dns.rrset.RRset objects
|
|---|
| 82 | @ivar edns: The EDNS level to use. The default is -1, no Edns.
|
|---|
| 83 | @type edns: int
|
|---|
| 84 | @ivar ednsflags: The EDNS flags
|
|---|
| 85 | @type ednsflags: long
|
|---|
| 86 | @ivar payload: The EDNS payload size. The default is 0.
|
|---|
| 87 | @type payload: int
|
|---|
| 88 | @ivar options: The EDNS options
|
|---|
| 89 | @type options: list of dns.edns.Option objects
|
|---|
| 90 | @ivar request_payload: The associated request's EDNS payload size.
|
|---|
| 91 | @type request_payload: int
|
|---|
| 92 | @ivar keyring: The TSIG keyring to use. The default is None.
|
|---|
| 93 | @type keyring: dict
|
|---|
| 94 | @ivar keyname: The TSIG keyname to use. The default is None.
|
|---|
| 95 | @type keyname: dns.name.Name object
|
|---|
| 96 | @ivar keyalgorithm: The TSIG algorithm to use; defaults to
|
|---|
| 97 | dns.tsig.default_algorithm. Constants for TSIG algorithms are defined
|
|---|
| 98 | in dns.tsig, and the currently implemented algorithms are
|
|---|
| 99 | HMAC_MD5, HMAC_SHA1, HMAC_SHA224, HMAC_SHA256, HMAC_SHA384, and
|
|---|
| 100 | HMAC_SHA512.
|
|---|
| 101 | @type keyalgorithm: string
|
|---|
| 102 | @ivar request_mac: The TSIG MAC of the request message associated with
|
|---|
| 103 | this message; used when validating TSIG signatures. @see: RFC 2845 for
|
|---|
| 104 | more information on TSIG fields.
|
|---|
| 105 | @type request_mac: string
|
|---|
| 106 | @ivar fudge: TSIG time fudge; default is 300 seconds.
|
|---|
| 107 | @type fudge: int
|
|---|
| 108 | @ivar original_id: TSIG original id; defaults to the message's id
|
|---|
| 109 | @type original_id: int
|
|---|
| 110 | @ivar tsig_error: TSIG error code; default is 0.
|
|---|
| 111 | @type tsig_error: int
|
|---|
| 112 | @ivar other_data: TSIG other data.
|
|---|
| 113 | @type other_data: string
|
|---|
| 114 | @ivar mac: The TSIG MAC for this message.
|
|---|
| 115 | @type mac: string
|
|---|
| 116 | @ivar xfr: Is the message being used to contain the results of a DNS
|
|---|
| 117 | zone transfer? The default is False.
|
|---|
| 118 | @type xfr: bool
|
|---|
| 119 | @ivar origin: The origin of the zone in messages which are used for
|
|---|
| 120 | zone transfers or for DNS dynamic updates. The default is None.
|
|---|
| 121 | @type origin: dns.name.Name object
|
|---|
| 122 | @ivar tsig_ctx: The TSIG signature context associated with this
|
|---|
| 123 | message. The default is None.
|
|---|
| 124 | @type tsig_ctx: hmac.HMAC object
|
|---|
| 125 | @ivar had_tsig: Did the message decoded from wire format have a TSIG
|
|---|
| 126 | signature?
|
|---|
| 127 | @type had_tsig: bool
|
|---|
| 128 | @ivar multi: Is this message part of a multi-message sequence? The
|
|---|
| 129 | default is false. This variable is used when validating TSIG signatures
|
|---|
| 130 | on messages which are part of a zone transfer.
|
|---|
| 131 | @type multi: bool
|
|---|
| 132 | @ivar first: Is this message standalone, or the first of a multi
|
|---|
| 133 | message sequence? This variable is used when validating TSIG signatures
|
|---|
| 134 | on messages which are part of a zone transfer.
|
|---|
| 135 | @type first: bool
|
|---|
| 136 | @ivar index: An index of rrsets in the message. The index key is
|
|---|
| 137 | (section, name, rdclass, rdtype, covers, deleting). Indexing can be
|
|---|
| 138 | disabled by setting the index to None.
|
|---|
| 139 | @type index: dict
|
|---|
| 140 | """
|
|---|
| 141 |
|
|---|
| 142 | def __init__(self, id=None):
|
|---|
| 143 | if id is None:
|
|---|
| 144 | self.id = dns.entropy.random_16()
|
|---|
| 145 | else:
|
|---|
| 146 | self.id = id
|
|---|
| 147 | self.flags = 0
|
|---|
| 148 | self.question = []
|
|---|
| 149 | self.answer = []
|
|---|
| 150 | self.authority = []
|
|---|
| 151 | self.additional = []
|
|---|
| 152 | self.edns = -1
|
|---|
| 153 | self.ednsflags = 0
|
|---|
| 154 | self.payload = 0
|
|---|
| 155 | self.options = []
|
|---|
| 156 | self.request_payload = 0
|
|---|
| 157 | self.keyring = None
|
|---|
| 158 | self.keyname = None
|
|---|
| 159 | self.keyalgorithm = dns.tsig.default_algorithm
|
|---|
| 160 | self.request_mac = ''
|
|---|
| 161 | self.other_data = ''
|
|---|
| 162 | self.tsig_error = 0
|
|---|
| 163 | self.fudge = 300
|
|---|
| 164 | self.original_id = self.id
|
|---|
| 165 | self.mac = ''
|
|---|
| 166 | self.xfr = False
|
|---|
| 167 | self.origin = None
|
|---|
| 168 | self.tsig_ctx = None
|
|---|
| 169 | self.had_tsig = False
|
|---|
| 170 | self.multi = False
|
|---|
| 171 | self.first = True
|
|---|
| 172 | self.index = {}
|
|---|
| 173 |
|
|---|
| 174 | def __repr__(self):
|
|---|
| 175 | return '<DNS message, ID ' + `self.id` + '>'
|
|---|
| 176 |
|
|---|
| 177 | def __str__(self):
|
|---|
| 178 | return self.to_text()
|
|---|
| 179 |
|
|---|
| 180 | def to_text(self, origin=None, relativize=True, **kw):
|
|---|
| 181 | """Convert the message to text.
|
|---|
| 182 |
|
|---|
| 183 | The I{origin}, I{relativize}, and any other keyword
|
|---|
| 184 | arguments are passed to the rrset to_wire() method.
|
|---|
| 185 |
|
|---|
| 186 | @rtype: string
|
|---|
| 187 | """
|
|---|
| 188 |
|
|---|
| 189 | s = cStringIO.StringIO()
|
|---|
| 190 | print >> s, 'id %d' % self.id
|
|---|
| 191 | print >> s, 'opcode %s' % \
|
|---|
| 192 | dns.opcode.to_text(dns.opcode.from_flags(self.flags))
|
|---|
| 193 | rc = dns.rcode.from_flags(self.flags, self.ednsflags)
|
|---|
| 194 | print >> s, 'rcode %s' % dns.rcode.to_text(rc)
|
|---|
| 195 | print >> s, 'flags %s' % dns.flags.to_text(self.flags)
|
|---|
| 196 | if self.edns >= 0:
|
|---|
| 197 | print >> s, 'edns %s' % self.edns
|
|---|
| 198 | if self.ednsflags != 0:
|
|---|
| 199 | print >> s, 'eflags %s' % \
|
|---|
| 200 | dns.flags.edns_to_text(self.ednsflags)
|
|---|
| 201 | print >> s, 'payload', self.payload
|
|---|
| 202 | is_update = dns.opcode.is_update(self.flags)
|
|---|
| 203 | if is_update:
|
|---|
| 204 | print >> s, ';ZONE'
|
|---|
| 205 | else:
|
|---|
| 206 | print >> s, ';QUESTION'
|
|---|
| 207 | for rrset in self.question:
|
|---|
| 208 | print >> s, rrset.to_text(origin, relativize, **kw)
|
|---|
| 209 | if is_update:
|
|---|
| 210 | print >> s, ';PREREQ'
|
|---|
| 211 | else:
|
|---|
| 212 | print >> s, ';ANSWER'
|
|---|
| 213 | for rrset in self.answer:
|
|---|
| 214 | print >> s, rrset.to_text(origin, relativize, **kw)
|
|---|
| 215 | if is_update:
|
|---|
| 216 | print >> s, ';UPDATE'
|
|---|
| 217 | else:
|
|---|
| 218 | print >> s, ';AUTHORITY'
|
|---|
| 219 | for rrset in self.authority:
|
|---|
| 220 | print >> s, rrset.to_text(origin, relativize, **kw)
|
|---|
| 221 | print >> s, ';ADDITIONAL'
|
|---|
| 222 | for rrset in self.additional:
|
|---|
| 223 | print >> s, rrset.to_text(origin, relativize, **kw)
|
|---|
| 224 | #
|
|---|
| 225 | # We strip off the final \n so the caller can print the result without
|
|---|
| 226 | # doing weird things to get around eccentricities in Python print
|
|---|
| 227 | # formatting
|
|---|
| 228 | #
|
|---|
| 229 | return s.getvalue()[:-1]
|
|---|
| 230 |
|
|---|
| 231 | def __eq__(self, other):
|
|---|
| 232 | """Two messages are equal if they have the same content in the
|
|---|
| 233 | header, question, answer, and authority sections.
|
|---|
| 234 | @rtype: bool"""
|
|---|
| 235 | if not isinstance(other, Message):
|
|---|
| 236 | return False
|
|---|
| 237 | if self.id != other.id:
|
|---|
| 238 | return False
|
|---|
| 239 | if self.flags != other.flags:
|
|---|
| 240 | return False
|
|---|
| 241 | for n in self.question:
|
|---|
| 242 | if n not in other.question:
|
|---|
| 243 | return False
|
|---|
| 244 | for n in other.question:
|
|---|
| 245 | if n not in self.question:
|
|---|
| 246 | return False
|
|---|
| 247 | for n in self.answer:
|
|---|
| 248 | if n not in other.answer:
|
|---|
| 249 | return False
|
|---|
| 250 | for n in other.answer:
|
|---|
| 251 | if n not in self.answer:
|
|---|
| 252 | return False
|
|---|
| 253 | for n in self.authority:
|
|---|
| 254 | if n not in other.authority:
|
|---|
| 255 | return False
|
|---|
| 256 | for n in other.authority:
|
|---|
| 257 | if n not in self.authority:
|
|---|
| 258 | return False
|
|---|
| 259 | return True
|
|---|
| 260 |
|
|---|
| 261 | def __ne__(self, other):
|
|---|
| 262 | """Are two messages not equal?
|
|---|
| 263 | @rtype: bool"""
|
|---|
| 264 | return not self.__eq__(other)
|
|---|
| 265 |
|
|---|
| 266 | def is_response(self, other):
|
|---|
| 267 | """Is other a response to self?
|
|---|
| 268 | @rtype: bool"""
|
|---|
| 269 | if other.flags & dns.flags.QR == 0 or \
|
|---|
| 270 | self.id != other.id or \
|
|---|
| 271 | dns.opcode.from_flags(self.flags) != \
|
|---|
| 272 | dns.opcode.from_flags(other.flags):
|
|---|
| 273 | return False
|
|---|
| 274 | if dns.rcode.from_flags(other.flags, other.ednsflags) != \
|
|---|
| 275 | dns.rcode.NOERROR:
|
|---|
| 276 | return True
|
|---|
| 277 | if dns.opcode.is_update(self.flags):
|
|---|
| 278 | return True
|
|---|
| 279 | for n in self.question:
|
|---|
| 280 | if n not in other.question:
|
|---|
| 281 | return False
|
|---|
| 282 | for n in other.question:
|
|---|
| 283 | if n not in self.question:
|
|---|
| 284 | return False
|
|---|
| 285 | return True
|
|---|
| 286 |
|
|---|
| 287 | def section_number(self, section):
|
|---|
| 288 | if section is self.question:
|
|---|
| 289 | return 0
|
|---|
| 290 | elif section is self.answer:
|
|---|
| 291 | return 1
|
|---|
| 292 | elif section is self.authority:
|
|---|
| 293 | return 2
|
|---|
| 294 | elif section is self.additional:
|
|---|
| 295 | return 3
|
|---|
| 296 | else:
|
|---|
| 297 | raise ValueError('unknown section')
|
|---|
| 298 |
|
|---|
| 299 | def find_rrset(self, section, name, rdclass, rdtype,
|
|---|
| 300 | covers=dns.rdatatype.NONE, deleting=None, create=False,
|
|---|
| 301 | force_unique=False):
|
|---|
| 302 | """Find the RRset with the given attributes in the specified section.
|
|---|
| 303 |
|
|---|
| 304 | @param section: the section of the message to look in, e.g.
|
|---|
| 305 | self.answer.
|
|---|
| 306 | @type section: list of dns.rrset.RRset objects
|
|---|
| 307 | @param name: the name of the RRset
|
|---|
| 308 | @type name: dns.name.Name object
|
|---|
| 309 | @param rdclass: the class of the RRset
|
|---|
| 310 | @type rdclass: int
|
|---|
| 311 | @param rdtype: the type of the RRset
|
|---|
| 312 | @type rdtype: int
|
|---|
| 313 | @param covers: the covers value of the RRset
|
|---|
| 314 | @type covers: int
|
|---|
| 315 | @param deleting: the deleting value of the RRset
|
|---|
| 316 | @type deleting: int
|
|---|
| 317 | @param create: If True, create the RRset if it is not found.
|
|---|
| 318 | The created RRset is appended to I{section}.
|
|---|
| 319 | @type create: bool
|
|---|
| 320 | @param force_unique: If True and create is also True, create a
|
|---|
| 321 | new RRset regardless of whether a matching RRset exists already.
|
|---|
| 322 | @type force_unique: bool
|
|---|
| 323 | @raises KeyError: the RRset was not found and create was False
|
|---|
| 324 | @rtype: dns.rrset.RRset object"""
|
|---|
| 325 |
|
|---|
| 326 | key = (self.section_number(section),
|
|---|
| 327 | name, rdclass, rdtype, covers, deleting)
|
|---|
| 328 | if not force_unique:
|
|---|
| 329 | if not self.index is None:
|
|---|
| 330 | rrset = self.index.get(key)
|
|---|
| 331 | if not rrset is None:
|
|---|
| 332 | return rrset
|
|---|
| 333 | else:
|
|---|
| 334 | for rrset in section:
|
|---|
| 335 | if rrset.match(name, rdclass, rdtype, covers, deleting):
|
|---|
| 336 | return rrset
|
|---|
| 337 | if not create:
|
|---|
| 338 | raise KeyError
|
|---|
| 339 | rrset = dns.rrset.RRset(name, rdclass, rdtype, covers, deleting)
|
|---|
| 340 | section.append(rrset)
|
|---|
| 341 | if not self.index is None:
|
|---|
| 342 | self.index[key] = rrset
|
|---|
| 343 | return rrset
|
|---|
| 344 |
|
|---|
| 345 | def get_rrset(self, section, name, rdclass, rdtype,
|
|---|
| 346 | covers=dns.rdatatype.NONE, deleting=None, create=False,
|
|---|
| 347 | force_unique=False):
|
|---|
| 348 | """Get the RRset with the given attributes in the specified section.
|
|---|
| 349 |
|
|---|
| 350 | If the RRset is not found, None is returned.
|
|---|
| 351 |
|
|---|
| 352 | @param section: the section of the message to look in, e.g.
|
|---|
| 353 | self.answer.
|
|---|
| 354 | @type section: list of dns.rrset.RRset objects
|
|---|
| 355 | @param name: the name of the RRset
|
|---|
| 356 | @type name: dns.name.Name object
|
|---|
| 357 | @param rdclass: the class of the RRset
|
|---|
| 358 | @type rdclass: int
|
|---|
| 359 | @param rdtype: the type of the RRset
|
|---|
| 360 | @type rdtype: int
|
|---|
| 361 | @param covers: the covers value of the RRset
|
|---|
| 362 | @type covers: int
|
|---|
| 363 | @param deleting: the deleting value of the RRset
|
|---|
| 364 | @type deleting: int
|
|---|
| 365 | @param create: If True, create the RRset if it is not found.
|
|---|
| 366 | The created RRset is appended to I{section}.
|
|---|
| 367 | @type create: bool
|
|---|
| 368 | @param force_unique: If True and create is also True, create a
|
|---|
| 369 | new RRset regardless of whether a matching RRset exists already.
|
|---|
| 370 | @type force_unique: bool
|
|---|
| 371 | @rtype: dns.rrset.RRset object or None"""
|
|---|
| 372 |
|
|---|
| 373 | try:
|
|---|
| 374 | rrset = self.find_rrset(section, name, rdclass, rdtype, covers,
|
|---|
| 375 | deleting, create, force_unique)
|
|---|
| 376 | except KeyError:
|
|---|
| 377 | rrset = None
|
|---|
| 378 | return rrset
|
|---|
| 379 |
|
|---|
| 380 | def to_wire(self, origin=None, max_size=0, **kw):
|
|---|
| 381 | """Return a string containing the message in DNS compressed wire
|
|---|
| 382 | format.
|
|---|
| 383 |
|
|---|
| 384 | Additional keyword arguments are passed to the rrset to_wire()
|
|---|
| 385 | method.
|
|---|
| 386 |
|
|---|
| 387 | @param origin: The origin to be appended to any relative names.
|
|---|
| 388 | @type origin: dns.name.Name object
|
|---|
| 389 | @param max_size: The maximum size of the wire format output; default
|
|---|
| 390 | is 0, which means 'the message's request payload, if nonzero, or
|
|---|
| 391 | 65536'.
|
|---|
| 392 | @type max_size: int
|
|---|
| 393 | @raises dns.exception.TooBig: max_size was exceeded
|
|---|
| 394 | @rtype: string
|
|---|
| 395 | """
|
|---|
| 396 |
|
|---|
| 397 | if max_size == 0:
|
|---|
| 398 | if self.request_payload != 0:
|
|---|
| 399 | max_size = self.request_payload
|
|---|
| 400 | else:
|
|---|
| 401 | max_size = 65535
|
|---|
| 402 | if max_size < 512:
|
|---|
| 403 | max_size = 512
|
|---|
| 404 | elif max_size > 65535:
|
|---|
| 405 | max_size = 65535
|
|---|
| 406 | r = dns.renderer.Renderer(self.id, self.flags, max_size, origin)
|
|---|
| 407 | for rrset in self.question:
|
|---|
| 408 | r.add_question(rrset.name, rrset.rdtype, rrset.rdclass)
|
|---|
| 409 | for rrset in self.answer:
|
|---|
| 410 | r.add_rrset(dns.renderer.ANSWER, rrset, **kw)
|
|---|
| 411 | for rrset in self.authority:
|
|---|
| 412 | r.add_rrset(dns.renderer.AUTHORITY, rrset, **kw)
|
|---|
| 413 | if self.edns >= 0:
|
|---|
| 414 | r.add_edns(self.edns, self.ednsflags, self.payload, self.options)
|
|---|
| 415 | for rrset in self.additional:
|
|---|
| 416 | r.add_rrset(dns.renderer.ADDITIONAL, rrset, **kw)
|
|---|
| 417 | r.write_header()
|
|---|
| 418 | if not self.keyname is None:
|
|---|
| 419 | r.add_tsig(self.keyname, self.keyring[self.keyname],
|
|---|
| 420 | self.fudge, self.original_id, self.tsig_error,
|
|---|
| 421 | self.other_data, self.request_mac,
|
|---|
| 422 | self.keyalgorithm)
|
|---|
| 423 | self.mac = r.mac
|
|---|
| 424 | return r.get_wire()
|
|---|
| 425 |
|
|---|
| 426 | def use_tsig(self, keyring, keyname=None, fudge=300,
|
|---|
| 427 | original_id=None, tsig_error=0, other_data='',
|
|---|
| 428 | algorithm=dns.tsig.default_algorithm):
|
|---|
| 429 | """When sending, a TSIG signature using the specified keyring
|
|---|
| 430 | and keyname should be added.
|
|---|
| 431 |
|
|---|
| 432 | @param keyring: The TSIG keyring to use; defaults to None.
|
|---|
| 433 | @type keyring: dict
|
|---|
| 434 | @param keyname: The name of the TSIG key to use; defaults to None.
|
|---|
| 435 | The key must be defined in the keyring. If a keyring is specified
|
|---|
| 436 | but a keyname is not, then the key used will be the first key in the
|
|---|
| 437 | keyring. Note that the order of keys in a dictionary is not defined,
|
|---|
| 438 | so applications should supply a keyname when a keyring is used, unless
|
|---|
| 439 | they know the keyring contains only one key.
|
|---|
| 440 | @type keyname: dns.name.Name or string
|
|---|
| 441 | @param fudge: TSIG time fudge; default is 300 seconds.
|
|---|
| 442 | @type fudge: int
|
|---|
| 443 | @param original_id: TSIG original id; defaults to the message's id
|
|---|
| 444 | @type original_id: int
|
|---|
| 445 | @param tsig_error: TSIG error code; default is 0.
|
|---|
| 446 | @type tsig_error: int
|
|---|
| 447 | @param other_data: TSIG other data.
|
|---|
| 448 | @type other_data: string
|
|---|
| 449 | @param algorithm: The TSIG algorithm to use; defaults to
|
|---|
| 450 | dns.tsig.default_algorithm
|
|---|
| 451 | """
|
|---|
| 452 |
|
|---|
| 453 | self.keyring = keyring
|
|---|
| 454 | if keyname is None:
|
|---|
| 455 | self.keyname = self.keyring.keys()[0]
|
|---|
| 456 | else:
|
|---|
| 457 | if isinstance(keyname, (str, unicode)):
|
|---|
| 458 | keyname = dns.name.from_text(keyname)
|
|---|
| 459 | self.keyname = keyname
|
|---|
| 460 | self.keyalgorithm = algorithm
|
|---|
| 461 | self.fudge = fudge
|
|---|
| 462 | if original_id is None:
|
|---|
| 463 | self.original_id = self.id
|
|---|
| 464 | else:
|
|---|
| 465 | self.original_id = original_id
|
|---|
| 466 | self.tsig_error = tsig_error
|
|---|
| 467 | self.other_data = other_data
|
|---|
| 468 |
|
|---|
| 469 | def use_edns(self, edns=0, ednsflags=0, payload=1280, request_payload=None, options=None):
|
|---|
| 470 | """Configure EDNS behavior.
|
|---|
| 471 | @param edns: The EDNS level to use. Specifying None, False, or -1
|
|---|
| 472 | means 'do not use EDNS', and in this case the other parameters are
|
|---|
| 473 | ignored. Specifying True is equivalent to specifying 0, i.e. 'use
|
|---|
| 474 | EDNS0'.
|
|---|
| 475 | @type edns: int or bool or None
|
|---|
| 476 | @param ednsflags: EDNS flag values.
|
|---|
| 477 | @type ednsflags: int
|
|---|
| 478 | @param payload: The EDNS sender's payload field, which is the maximum
|
|---|
| 479 | size of UDP datagram the sender can handle.
|
|---|
| 480 | @type payload: int
|
|---|
| 481 | @param request_payload: The EDNS payload size to use when sending
|
|---|
| 482 | this message. If not specified, defaults to the value of payload.
|
|---|
| 483 | @type request_payload: int or None
|
|---|
| 484 | @param options: The EDNS options
|
|---|
| 485 | @type options: None or list of dns.edns.Option objects
|
|---|
| 486 | @see: RFC 2671
|
|---|
| 487 | """
|
|---|
| 488 | if edns is None or edns is False:
|
|---|
| 489 | edns = -1
|
|---|
| 490 | if edns is True:
|
|---|
| 491 | edns = 0
|
|---|
| 492 | if request_payload is None:
|
|---|
| 493 | request_payload = payload
|
|---|
| 494 | if edns < 0:
|
|---|
| 495 | ednsflags = 0
|
|---|
| 496 | payload = 0
|
|---|
| 497 | request_payload = 0
|
|---|
| 498 | options = []
|
|---|
| 499 | else:
|
|---|
| 500 | # make sure the EDNS version in ednsflags agrees with edns
|
|---|
| 501 | ednsflags &= 0xFF00FFFFL
|
|---|
| 502 | ednsflags |= (edns << 16)
|
|---|
| 503 | if options is None:
|
|---|
| 504 | options = []
|
|---|
| 505 | self.edns = edns
|
|---|
| 506 | self.ednsflags = ednsflags
|
|---|
| 507 | self.payload = payload
|
|---|
| 508 | self.options = options
|
|---|
| 509 | self.request_payload = request_payload
|
|---|
| 510 |
|
|---|
| 511 | def want_dnssec(self, wanted=True):
|
|---|
| 512 | """Enable or disable 'DNSSEC desired' flag in requests.
|
|---|
| 513 | @param wanted: Is DNSSEC desired? If True, EDNS is enabled if
|
|---|
| 514 | required, and then the DO bit is set. If False, the DO bit is
|
|---|
| 515 | cleared if EDNS is enabled.
|
|---|
| 516 | @type wanted: bool
|
|---|
| 517 | """
|
|---|
| 518 | if wanted:
|
|---|
| 519 | if self.edns < 0:
|
|---|
| 520 | self.use_edns()
|
|---|
| 521 | self.ednsflags |= dns.flags.DO
|
|---|
| 522 | elif self.edns >= 0:
|
|---|
| 523 | self.ednsflags &= ~dns.flags.DO
|
|---|
| 524 |
|
|---|
| 525 | def rcode(self):
|
|---|
| 526 | """Return the rcode.
|
|---|
| 527 | @rtype: int
|
|---|
| 528 | """
|
|---|
| 529 | return dns.rcode.from_flags(self.flags, self.ednsflags)
|
|---|
| 530 |
|
|---|
| 531 | def set_rcode(self, rcode):
|
|---|
| 532 | """Set the rcode.
|
|---|
| 533 | @param rcode: the rcode
|
|---|
| 534 | @type rcode: int
|
|---|
| 535 | """
|
|---|
| 536 | (value, evalue) = dns.rcode.to_flags(rcode)
|
|---|
| 537 | self.flags &= 0xFFF0
|
|---|
| 538 | self.flags |= value
|
|---|
| 539 | self.ednsflags &= 0x00FFFFFFL
|
|---|
| 540 | self.ednsflags |= evalue
|
|---|
| 541 | if self.ednsflags != 0 and self.edns < 0:
|
|---|
| 542 | self.edns = 0
|
|---|
| 543 |
|
|---|
| 544 | def opcode(self):
|
|---|
| 545 | """Return the opcode.
|
|---|
| 546 | @rtype: int
|
|---|
| 547 | """
|
|---|
| 548 | return dns.opcode.from_flags(self.flags)
|
|---|
| 549 |
|
|---|
| 550 | def set_opcode(self, opcode):
|
|---|
| 551 | """Set the opcode.
|
|---|
| 552 | @param opcode: the opcode
|
|---|
| 553 | @type opcode: int
|
|---|
| 554 | """
|
|---|
| 555 | self.flags &= 0x87FF
|
|---|
| 556 | self.flags |= dns.opcode.to_flags(opcode)
|
|---|
| 557 |
|
|---|
| 558 | class _WireReader(object):
|
|---|
| 559 | """Wire format reader.
|
|---|
| 560 |
|
|---|
| 561 | @ivar wire: the wire-format message.
|
|---|
| 562 | @type wire: string
|
|---|
| 563 | @ivar message: The message object being built
|
|---|
| 564 | @type message: dns.message.Message object
|
|---|
| 565 | @ivar current: When building a message object from wire format, this
|
|---|
| 566 | variable contains the offset from the beginning of wire of the next octet
|
|---|
| 567 | to be read.
|
|---|
| 568 | @type current: int
|
|---|
| 569 | @ivar updating: Is the message a dynamic update?
|
|---|
| 570 | @type updating: bool
|
|---|
| 571 | @ivar one_rr_per_rrset: Put each RR into its own RRset?
|
|---|
| 572 | @type one_rr_per_rrset: bool
|
|---|
| 573 | @ivar zone_rdclass: The class of the zone in messages which are
|
|---|
| 574 | DNS dynamic updates.
|
|---|
| 575 | @type zone_rdclass: int
|
|---|
| 576 | """
|
|---|
| 577 |
|
|---|
| 578 | def __init__(self, wire, message, question_only=False,
|
|---|
| 579 | one_rr_per_rrset=False):
|
|---|
| 580 | self.wire = wire
|
|---|
| 581 | self.message = message
|
|---|
| 582 | self.current = 0
|
|---|
| 583 | self.updating = False
|
|---|
| 584 | self.zone_rdclass = dns.rdataclass.IN
|
|---|
| 585 | self.question_only = question_only
|
|---|
| 586 | self.one_rr_per_rrset = one_rr_per_rrset
|
|---|
| 587 |
|
|---|
| 588 | def _get_question(self, qcount):
|
|---|
| 589 | """Read the next I{qcount} records from the wire data and add them to
|
|---|
| 590 | the question section.
|
|---|
| 591 | @param qcount: the number of questions in the message
|
|---|
| 592 | @type qcount: int"""
|
|---|
| 593 |
|
|---|
| 594 | if self.updating and qcount > 1:
|
|---|
| 595 | raise dns.exception.FormError
|
|---|
| 596 |
|
|---|
| 597 | for i in xrange(0, qcount):
|
|---|
| 598 | (qname, used) = dns.name.from_wire(self.wire, self.current)
|
|---|
| 599 | if not self.message.origin is None:
|
|---|
| 600 | qname = qname.relativize(self.message.origin)
|
|---|
| 601 | self.current = self.current + used
|
|---|
| 602 | (rdtype, rdclass) = \
|
|---|
| 603 | struct.unpack('!HH',
|
|---|
| 604 | self.wire[self.current:self.current + 4])
|
|---|
| 605 | self.current = self.current + 4
|
|---|
| 606 | self.message.find_rrset(self.message.question, qname,
|
|---|
| 607 | rdclass, rdtype, create=True,
|
|---|
| 608 | force_unique=True)
|
|---|
| 609 | if self.updating:
|
|---|
| 610 | self.zone_rdclass = rdclass
|
|---|
| 611 |
|
|---|
| 612 | def _get_section(self, section, count):
|
|---|
| 613 | """Read the next I{count} records from the wire data and add them to
|
|---|
| 614 | the specified section.
|
|---|
| 615 | @param section: the section of the message to which to add records
|
|---|
| 616 | @type section: list of dns.rrset.RRset objects
|
|---|
| 617 | @param count: the number of records to read
|
|---|
| 618 | @type count: int"""
|
|---|
| 619 |
|
|---|
| 620 | if self.updating or self.one_rr_per_rrset:
|
|---|
| 621 | force_unique = True
|
|---|
| 622 | else:
|
|---|
| 623 | force_unique = False
|
|---|
| 624 | seen_opt = False
|
|---|
| 625 | for i in xrange(0, count):
|
|---|
| 626 | rr_start = self.current
|
|---|
| 627 | (name, used) = dns.name.from_wire(self.wire, self.current)
|
|---|
| 628 | absolute_name = name
|
|---|
| 629 | if not self.message.origin is None:
|
|---|
| 630 | name = name.relativize(self.message.origin)
|
|---|
| 631 | self.current = self.current + used
|
|---|
| 632 | (rdtype, rdclass, ttl, rdlen) = \
|
|---|
| 633 | struct.unpack('!HHIH',
|
|---|
| 634 | self.wire[self.current:self.current + 10])
|
|---|
| 635 | self.current = self.current + 10
|
|---|
| 636 | if rdtype == dns.rdatatype.OPT:
|
|---|
| 637 | if not section is self.message.additional or seen_opt:
|
|---|
| 638 | raise BadEDNS
|
|---|
| 639 | self.message.payload = rdclass
|
|---|
| 640 | self.message.ednsflags = ttl
|
|---|
| 641 | self.message.edns = (ttl & 0xff0000) >> 16
|
|---|
| 642 | self.message.options = []
|
|---|
| 643 | current = self.current
|
|---|
| 644 | optslen = rdlen
|
|---|
| 645 | while optslen > 0:
|
|---|
| 646 | (otype, olen) = \
|
|---|
| 647 | struct.unpack('!HH',
|
|---|
| 648 | self.wire[current:current + 4])
|
|---|
| 649 | current = current + 4
|
|---|
| 650 | opt = dns.edns.option_from_wire(otype, self.wire, current, olen)
|
|---|
| 651 | self.message.options.append(opt)
|
|---|
| 652 | current = current + olen
|
|---|
| 653 | optslen = optslen - 4 - olen
|
|---|
| 654 | seen_opt = True
|
|---|
| 655 | elif rdtype == dns.rdatatype.TSIG:
|
|---|
| 656 | if not (section is self.message.additional and
|
|---|
| 657 | i == (count - 1)):
|
|---|
| 658 | raise BadTSIG
|
|---|
| 659 | if self.message.keyring is None:
|
|---|
| 660 | raise UnknownTSIGKey('got signed message without keyring')
|
|---|
| 661 | secret = self.message.keyring.get(absolute_name)
|
|---|
| 662 | if secret is None:
|
|---|
| 663 | raise UnknownTSIGKey("key '%s' unknown" % name)
|
|---|
| 664 | self.message.tsig_ctx = \
|
|---|
| 665 | dns.tsig.validate(self.wire,
|
|---|
| 666 | absolute_name,
|
|---|
| 667 | secret,
|
|---|
| 668 | int(time.time()),
|
|---|
| 669 | self.message.request_mac,
|
|---|
| 670 | rr_start,
|
|---|
| 671 | self.current,
|
|---|
| 672 | rdlen,
|
|---|
| 673 | self.message.tsig_ctx,
|
|---|
| 674 | self.message.multi,
|
|---|
| 675 | self.message.first)
|
|---|
| 676 | self.message.had_tsig = True
|
|---|
| 677 | else:
|
|---|
| 678 | if ttl < 0:
|
|---|
| 679 | ttl = 0
|
|---|
| 680 | if self.updating and \
|
|---|
| 681 | (rdclass == dns.rdataclass.ANY or
|
|---|
| 682 | rdclass == dns.rdataclass.NONE):
|
|---|
| 683 | deleting = rdclass
|
|---|
| 684 | rdclass = self.zone_rdclass
|
|---|
| 685 | else:
|
|---|
| 686 | deleting = None
|
|---|
| 687 | if deleting == dns.rdataclass.ANY or \
|
|---|
| 688 | (deleting == dns.rdataclass.NONE and \
|
|---|
| 689 | section is self.message.answer):
|
|---|
| 690 | covers = dns.rdatatype.NONE
|
|---|
| 691 | rd = None
|
|---|
| 692 | else:
|
|---|
| 693 | rd = dns.rdata.from_wire(rdclass, rdtype, self.wire,
|
|---|
| 694 | self.current, rdlen,
|
|---|
| 695 | self.message.origin)
|
|---|
| 696 | covers = rd.covers()
|
|---|
| 697 | if self.message.xfr and rdtype == dns.rdatatype.SOA:
|
|---|
| 698 | force_unique = True
|
|---|
| 699 | rrset = self.message.find_rrset(section, name,
|
|---|
| 700 | rdclass, rdtype, covers,
|
|---|
| 701 | deleting, True, force_unique)
|
|---|
| 702 | if not rd is None:
|
|---|
| 703 | rrset.add(rd, ttl)
|
|---|
| 704 | self.current = self.current + rdlen
|
|---|
| 705 |
|
|---|
| 706 | def read(self):
|
|---|
| 707 | """Read a wire format DNS message and build a dns.message.Message
|
|---|
| 708 | object."""
|
|---|
| 709 |
|
|---|
| 710 | l = len(self.wire)
|
|---|
| 711 | if l < 12:
|
|---|
| 712 | raise ShortHeader
|
|---|
| 713 | (self.message.id, self.message.flags, qcount, ancount,
|
|---|
| 714 | aucount, adcount) = struct.unpack('!HHHHHH', self.wire[:12])
|
|---|
| 715 | self.current = 12
|
|---|
| 716 | if dns.opcode.is_update(self.message.flags):
|
|---|
| 717 | self.updating = True
|
|---|
| 718 | self._get_question(qcount)
|
|---|
| 719 | if self.question_only:
|
|---|
| 720 | return
|
|---|
| 721 | self._get_section(self.message.answer, ancount)
|
|---|
| 722 | self._get_section(self.message.authority, aucount)
|
|---|
| 723 | self._get_section(self.message.additional, adcount)
|
|---|
| 724 | if self.current != l:
|
|---|
| 725 | raise TrailingJunk
|
|---|
| 726 | if self.message.multi and self.message.tsig_ctx and \
|
|---|
| 727 | not self.message.had_tsig:
|
|---|
| 728 | self.message.tsig_ctx.update(self.wire)
|
|---|
| 729 |
|
|---|
| 730 |
|
|---|
| 731 | def from_wire(wire, keyring=None, request_mac='', xfr=False, origin=None,
|
|---|
| 732 | tsig_ctx = None, multi = False, first = True,
|
|---|
| 733 | question_only = False, one_rr_per_rrset = False):
|
|---|
| 734 | """Convert a DNS wire format message into a message
|
|---|
| 735 | object.
|
|---|
| 736 |
|
|---|
| 737 | @param keyring: The keyring to use if the message is signed.
|
|---|
| 738 | @type keyring: dict
|
|---|
| 739 | @param request_mac: If the message is a response to a TSIG-signed request,
|
|---|
| 740 | I{request_mac} should be set to the MAC of that request.
|
|---|
| 741 | @type request_mac: string
|
|---|
| 742 | @param xfr: Is this message part of a zone transfer?
|
|---|
| 743 | @type xfr: bool
|
|---|
| 744 | @param origin: If the message is part of a zone transfer, I{origin}
|
|---|
| 745 | should be the origin name of the zone.
|
|---|
| 746 | @type origin: dns.name.Name object
|
|---|
| 747 | @param tsig_ctx: The ongoing TSIG context, used when validating zone
|
|---|
| 748 | transfers.
|
|---|
| 749 | @type tsig_ctx: hmac.HMAC object
|
|---|
| 750 | @param multi: Is this message part of a multiple message sequence?
|
|---|
| 751 | @type multi: bool
|
|---|
| 752 | @param first: Is this message standalone, or the first of a multi
|
|---|
| 753 | message sequence?
|
|---|
| 754 | @type first: bool
|
|---|
| 755 | @param question_only: Read only up to the end of the question section?
|
|---|
| 756 | @type question_only: bool
|
|---|
| 757 | @param one_rr_per_rrset: Put each RR into its own RRset
|
|---|
| 758 | @type one_rr_per_rrset: bool
|
|---|
| 759 | @raises ShortHeader: The message is less than 12 octets long.
|
|---|
| 760 | @raises TrailingJunk: There were octets in the message past the end
|
|---|
| 761 | of the proper DNS message.
|
|---|
| 762 | @raises BadEDNS: An OPT record was in the wrong section, or occurred more
|
|---|
| 763 | than once.
|
|---|
| 764 | @raises BadTSIG: A TSIG record was not the last record of the additional
|
|---|
| 765 | data section.
|
|---|
| 766 | @rtype: dns.message.Message object"""
|
|---|
| 767 |
|
|---|
| 768 | m = Message(id=0)
|
|---|
| 769 | m.keyring = keyring
|
|---|
| 770 | m.request_mac = request_mac
|
|---|
| 771 | m.xfr = xfr
|
|---|
| 772 | m.origin = origin
|
|---|
| 773 | m.tsig_ctx = tsig_ctx
|
|---|
| 774 | m.multi = multi
|
|---|
| 775 | m.first = first
|
|---|
| 776 |
|
|---|
| 777 | reader = _WireReader(wire, m, question_only, one_rr_per_rrset)
|
|---|
| 778 | reader.read()
|
|---|
| 779 |
|
|---|
| 780 | return m
|
|---|
| 781 |
|
|---|
| 782 |
|
|---|
| 783 | class _TextReader(object):
|
|---|
| 784 | """Text format reader.
|
|---|
| 785 |
|
|---|
| 786 | @ivar tok: the tokenizer
|
|---|
| 787 | @type tok: dns.tokenizer.Tokenizer object
|
|---|
| 788 | @ivar message: The message object being built
|
|---|
| 789 | @type message: dns.message.Message object
|
|---|
| 790 | @ivar updating: Is the message a dynamic update?
|
|---|
| 791 | @type updating: bool
|
|---|
| 792 | @ivar zone_rdclass: The class of the zone in messages which are
|
|---|
| 793 | DNS dynamic updates.
|
|---|
| 794 | @type zone_rdclass: int
|
|---|
| 795 | @ivar last_name: The most recently read name when building a message object
|
|---|
| 796 | from text format.
|
|---|
| 797 | @type last_name: dns.name.Name object
|
|---|
| 798 | """
|
|---|
| 799 |
|
|---|
| 800 | def __init__(self, text, message):
|
|---|
| 801 | self.message = message
|
|---|
| 802 | self.tok = dns.tokenizer.Tokenizer(text)
|
|---|
| 803 | self.last_name = None
|
|---|
| 804 | self.zone_rdclass = dns.rdataclass.IN
|
|---|
| 805 | self.updating = False
|
|---|
| 806 |
|
|---|
| 807 | def _header_line(self, section):
|
|---|
| 808 | """Process one line from the text format header section."""
|
|---|
| 809 |
|
|---|
| 810 | token = self.tok.get()
|
|---|
| 811 | what = token.value
|
|---|
| 812 | if what == 'id':
|
|---|
| 813 | self.message.id = self.tok.get_int()
|
|---|
| 814 | elif what == 'flags':
|
|---|
| 815 | while True:
|
|---|
| 816 | token = self.tok.get()
|
|---|
| 817 | if not token.is_identifier():
|
|---|
| 818 | self.tok.unget(token)
|
|---|
| 819 | break
|
|---|
| 820 | self.message.flags = self.message.flags | \
|
|---|
| 821 | dns.flags.from_text(token.value)
|
|---|
| 822 | if dns.opcode.is_update(self.message.flags):
|
|---|
| 823 | self.updating = True
|
|---|
| 824 | elif what == 'edns':
|
|---|
| 825 | self.message.edns = self.tok.get_int()
|
|---|
| 826 | self.message.ednsflags = self.message.ednsflags | \
|
|---|
| 827 | (self.message.edns << 16)
|
|---|
| 828 | elif what == 'eflags':
|
|---|
| 829 | if self.message.edns < 0:
|
|---|
| 830 | self.message.edns = 0
|
|---|
| 831 | while True:
|
|---|
| 832 | token = self.tok.get()
|
|---|
| 833 | if not token.is_identifier():
|
|---|
| 834 | self.tok.unget(token)
|
|---|
| 835 | break
|
|---|
| 836 | self.message.ednsflags = self.message.ednsflags | \
|
|---|
| 837 | dns.flags.edns_from_text(token.value)
|
|---|
| 838 | elif what == 'payload':
|
|---|
| 839 | self.message.payload = self.tok.get_int()
|
|---|
| 840 | if self.message.edns < 0:
|
|---|
| 841 | self.message.edns = 0
|
|---|
| 842 | elif what == 'opcode':
|
|---|
| 843 | text = self.tok.get_string()
|
|---|
| 844 | self.message.flags = self.message.flags | \
|
|---|
| 845 | dns.opcode.to_flags(dns.opcode.from_text(text))
|
|---|
| 846 | elif what == 'rcode':
|
|---|
| 847 | text = self.tok.get_string()
|
|---|
| 848 | self.message.set_rcode(dns.rcode.from_text(text))
|
|---|
| 849 | else:
|
|---|
| 850 | raise UnknownHeaderField
|
|---|
| 851 | self.tok.get_eol()
|
|---|
| 852 |
|
|---|
| 853 | def _question_line(self, section):
|
|---|
| 854 | """Process one line from the text format question section."""
|
|---|
| 855 |
|
|---|
| 856 | token = self.tok.get(want_leading = True)
|
|---|
| 857 | if not token.is_whitespace():
|
|---|
| 858 | self.last_name = dns.name.from_text(token.value, None)
|
|---|
| 859 | name = self.last_name
|
|---|
| 860 | token = self.tok.get()
|
|---|
| 861 | if not token.is_identifier():
|
|---|
| 862 | raise dns.exception.SyntaxError
|
|---|
| 863 | # Class
|
|---|
| 864 | try:
|
|---|
| 865 | rdclass = dns.rdataclass.from_text(token.value)
|
|---|
| 866 | token = self.tok.get()
|
|---|
| 867 | if not token.is_identifier():
|
|---|
| 868 | raise dns.exception.SyntaxError
|
|---|
| 869 | except dns.exception.SyntaxError:
|
|---|
| 870 | raise dns.exception.SyntaxError
|
|---|
| 871 | except:
|
|---|
| 872 | rdclass = dns.rdataclass.IN
|
|---|
| 873 | # Type
|
|---|
| 874 | rdtype = dns.rdatatype.from_text(token.value)
|
|---|
| 875 | self.message.find_rrset(self.message.question, name,
|
|---|
| 876 | rdclass, rdtype, create=True,
|
|---|
| 877 | force_unique=True)
|
|---|
| 878 | if self.updating:
|
|---|
| 879 | self.zone_rdclass = rdclass
|
|---|
| 880 | self.tok.get_eol()
|
|---|
| 881 |
|
|---|
| 882 | def _rr_line(self, section):
|
|---|
| 883 | """Process one line from the text format answer, authority, or
|
|---|
| 884 | additional data sections.
|
|---|
| 885 | """
|
|---|
| 886 |
|
|---|
| 887 | deleting = None
|
|---|
| 888 | # Name
|
|---|
| 889 | token = self.tok.get(want_leading = True)
|
|---|
| 890 | if not token.is_whitespace():
|
|---|
| 891 | self.last_name = dns.name.from_text(token.value, None)
|
|---|
| 892 | name = self.last_name
|
|---|
| 893 | token = self.tok.get()
|
|---|
| 894 | if not token.is_identifier():
|
|---|
| 895 | raise dns.exception.SyntaxError
|
|---|
| 896 | # TTL
|
|---|
| 897 | try:
|
|---|
| 898 | ttl = int(token.value, 0)
|
|---|
| 899 | token = self.tok.get()
|
|---|
| 900 | if not token.is_identifier():
|
|---|
| 901 | raise dns.exception.SyntaxError
|
|---|
| 902 | except dns.exception.SyntaxError:
|
|---|
| 903 | raise dns.exception.SyntaxError
|
|---|
| 904 | except:
|
|---|
| 905 | ttl = 0
|
|---|
| 906 | # Class
|
|---|
| 907 | try:
|
|---|
| 908 | rdclass = dns.rdataclass.from_text(token.value)
|
|---|
| 909 | token = self.tok.get()
|
|---|
| 910 | if not token.is_identifier():
|
|---|
| 911 | raise dns.exception.SyntaxError
|
|---|
| 912 | if rdclass == dns.rdataclass.ANY or rdclass == dns.rdataclass.NONE:
|
|---|
| 913 | deleting = rdclass
|
|---|
| 914 | rdclass = self.zone_rdclass
|
|---|
| 915 | except dns.exception.SyntaxError:
|
|---|
| 916 | raise dns.exception.SyntaxError
|
|---|
| 917 | except:
|
|---|
| 918 | rdclass = dns.rdataclass.IN
|
|---|
| 919 | # Type
|
|---|
| 920 | rdtype = dns.rdatatype.from_text(token.value)
|
|---|
| 921 | token = self.tok.get()
|
|---|
| 922 | if not token.is_eol_or_eof():
|
|---|
| 923 | self.tok.unget(token)
|
|---|
| 924 | rd = dns.rdata.from_text(rdclass, rdtype, self.tok, None)
|
|---|
| 925 | covers = rd.covers()
|
|---|
| 926 | else:
|
|---|
| 927 | rd = None
|
|---|
| 928 | covers = dns.rdatatype.NONE
|
|---|
| 929 | rrset = self.message.find_rrset(section, name,
|
|---|
| 930 | rdclass, rdtype, covers,
|
|---|
| 931 | deleting, True, self.updating)
|
|---|
| 932 | if not rd is None:
|
|---|
| 933 | rrset.add(rd, ttl)
|
|---|
| 934 |
|
|---|
| 935 | def read(self):
|
|---|
| 936 | """Read a text format DNS message and build a dns.message.Message
|
|---|
| 937 | object."""
|
|---|
| 938 |
|
|---|
| 939 | line_method = self._header_line
|
|---|
| 940 | section = None
|
|---|
| 941 | while 1:
|
|---|
| 942 | token = self.tok.get(True, True)
|
|---|
| 943 | if token.is_eol_or_eof():
|
|---|
| 944 | break
|
|---|
| 945 | if token.is_comment():
|
|---|
| 946 | u = token.value.upper()
|
|---|
| 947 | if u == 'HEADER':
|
|---|
| 948 | line_method = self._header_line
|
|---|
| 949 | elif u == 'QUESTION' or u == 'ZONE':
|
|---|
| 950 | line_method = self._question_line
|
|---|
| 951 | section = self.message.question
|
|---|
| 952 | elif u == 'ANSWER' or u == 'PREREQ':
|
|---|
| 953 | line_method = self._rr_line
|
|---|
| 954 | section = self.message.answer
|
|---|
| 955 | elif u == 'AUTHORITY' or u == 'UPDATE':
|
|---|
| 956 | line_method = self._rr_line
|
|---|
| 957 | section = self.message.authority
|
|---|
| 958 | elif u == 'ADDITIONAL':
|
|---|
| 959 | line_method = self._rr_line
|
|---|
| 960 | section = self.message.additional
|
|---|
| 961 | self.tok.get_eol()
|
|---|
| 962 | continue
|
|---|
| 963 | self.tok.unget(token)
|
|---|
| 964 | line_method(section)
|
|---|
| 965 |
|
|---|
| 966 |
|
|---|
| 967 | def from_text(text):
|
|---|
| 968 | """Convert the text format message into a message object.
|
|---|
| 969 |
|
|---|
| 970 | @param text: The text format message.
|
|---|
| 971 | @type text: string
|
|---|
| 972 | @raises UnknownHeaderField:
|
|---|
| 973 | @raises dns.exception.SyntaxError:
|
|---|
| 974 | @rtype: dns.message.Message object"""
|
|---|
| 975 |
|
|---|
| 976 | # 'text' can also be a file, but we don't publish that fact
|
|---|
| 977 | # since it's an implementation detail. The official file
|
|---|
| 978 | # interface is from_file().
|
|---|
| 979 |
|
|---|
| 980 | m = Message()
|
|---|
| 981 |
|
|---|
| 982 | reader = _TextReader(text, m)
|
|---|
| 983 | reader.read()
|
|---|
| 984 |
|
|---|
| 985 | return m
|
|---|
| 986 |
|
|---|
| 987 | def from_file(f):
|
|---|
| 988 | """Read the next text format message from the specified file.
|
|---|
| 989 |
|
|---|
| 990 | @param f: file or string. If I{f} is a string, it is treated
|
|---|
| 991 | as the name of a file to open.
|
|---|
| 992 | @raises UnknownHeaderField:
|
|---|
| 993 | @raises dns.exception.SyntaxError:
|
|---|
| 994 | @rtype: dns.message.Message object"""
|
|---|
| 995 |
|
|---|
| 996 | if sys.hexversion >= 0x02030000:
|
|---|
| 997 | # allow Unicode filenames; turn on universal newline support
|
|---|
| 998 | str_type = basestring
|
|---|
| 999 | opts = 'rU'
|
|---|
| 1000 | else:
|
|---|
| 1001 | str_type = str
|
|---|
| 1002 | opts = 'r'
|
|---|
| 1003 | if isinstance(f, str_type):
|
|---|
| 1004 | f = file(f, opts)
|
|---|
| 1005 | want_close = True
|
|---|
| 1006 | else:
|
|---|
| 1007 | want_close = False
|
|---|
| 1008 |
|
|---|
| 1009 | try:
|
|---|
| 1010 | m = from_text(f)
|
|---|
| 1011 | finally:
|
|---|
| 1012 | if want_close:
|
|---|
| 1013 | f.close()
|
|---|
| 1014 | return m
|
|---|
| 1015 |
|
|---|
| 1016 | def make_query(qname, rdtype, rdclass = dns.rdataclass.IN, use_edns=None,
|
|---|
| 1017 | want_dnssec=False):
|
|---|
| 1018 | """Make a query message.
|
|---|
| 1019 |
|
|---|
| 1020 | The query name, type, and class may all be specified either
|
|---|
| 1021 | as objects of the appropriate type, or as strings.
|
|---|
| 1022 |
|
|---|
| 1023 | The query will have a randomly choosen query id, and its DNS flags
|
|---|
| 1024 | will be set to dns.flags.RD.
|
|---|
| 1025 |
|
|---|
| 1026 | @param qname: The query name.
|
|---|
| 1027 | @type qname: dns.name.Name object or string
|
|---|
| 1028 | @param rdtype: The desired rdata type.
|
|---|
| 1029 | @type rdtype: int
|
|---|
| 1030 | @param rdclass: The desired rdata class; the default is class IN.
|
|---|
| 1031 | @type rdclass: int
|
|---|
| 1032 | @param use_edns: The EDNS level to use; the default is None (no EDNS).
|
|---|
| 1033 | See the description of dns.message.Message.use_edns() for the possible
|
|---|
| 1034 | values for use_edns and their meanings.
|
|---|
| 1035 | @type use_edns: int or bool or None
|
|---|
| 1036 | @param want_dnssec: Should the query indicate that DNSSEC is desired?
|
|---|
| 1037 | @type want_dnssec: bool
|
|---|
| 1038 | @rtype: dns.message.Message object"""
|
|---|
| 1039 |
|
|---|
| 1040 | if isinstance(qname, (str, unicode)):
|
|---|
| 1041 | qname = dns.name.from_text(qname)
|
|---|
| 1042 | if isinstance(rdtype, (str, unicode)):
|
|---|
| 1043 | rdtype = dns.rdatatype.from_text(rdtype)
|
|---|
| 1044 | if isinstance(rdclass, (str, unicode)):
|
|---|
| 1045 | rdclass = dns.rdataclass.from_text(rdclass)
|
|---|
| 1046 | m = Message()
|
|---|
| 1047 | m.flags |= dns.flags.RD
|
|---|
| 1048 | m.find_rrset(m.question, qname, rdclass, rdtype, create=True,
|
|---|
| 1049 | force_unique=True)
|
|---|
| 1050 | m.use_edns(use_edns)
|
|---|
| 1051 | m.want_dnssec(want_dnssec)
|
|---|
| 1052 | return m
|
|---|
| 1053 |
|
|---|
| 1054 | def make_response(query, recursion_available=False, our_payload=8192):
|
|---|
| 1055 | """Make a message which is a response for the specified query.
|
|---|
| 1056 | The message returned is really a response skeleton; it has all
|
|---|
| 1057 | of the infrastructure required of a response, but none of the
|
|---|
| 1058 | content.
|
|---|
| 1059 |
|
|---|
| 1060 | The response's question section is a shallow copy of the query's
|
|---|
| 1061 | question section, so the query's question RRsets should not be
|
|---|
| 1062 | changed.
|
|---|
| 1063 |
|
|---|
| 1064 | @param query: the query to respond to
|
|---|
| 1065 | @type query: dns.message.Message object
|
|---|
| 1066 | @param recursion_available: should RA be set in the response?
|
|---|
| 1067 | @type recursion_available: bool
|
|---|
| 1068 | @param our_payload: payload size to advertise in EDNS responses; default
|
|---|
| 1069 | is 8192.
|
|---|
| 1070 | @type our_payload: int
|
|---|
| 1071 | @rtype: dns.message.Message object"""
|
|---|
| 1072 |
|
|---|
| 1073 | if query.flags & dns.flags.QR:
|
|---|
| 1074 | raise dns.exception.FormError('specified query message is not a query')
|
|---|
| 1075 | response = dns.message.Message(query.id)
|
|---|
| 1076 | response.flags = dns.flags.QR | (query.flags & dns.flags.RD)
|
|---|
| 1077 | if recursion_available:
|
|---|
| 1078 | response.flags |= dns.flags.RA
|
|---|
| 1079 | response.set_opcode(query.opcode())
|
|---|
| 1080 | response.question = list(query.question)
|
|---|
| 1081 | if query.edns >= 0:
|
|---|
| 1082 | response.use_edns(0, 0, our_payload, query.payload)
|
|---|
| 1083 | if not query.keyname is None:
|
|---|
| 1084 | response.keyname = query.keyname
|
|---|
| 1085 | response.keyring = query.keyring
|
|---|
| 1086 | response.request_mac = query.mac
|
|---|
| 1087 | return response
|
|---|
