add: initial AI support
This commit is contained in:
diSabler
420
lib/DNS/Base.py
Normal file
420
lib/DNS/Base.py
Normal file
@@ -0,0 +1,420 @@
|
||||
"""
|
||||
$Id: Base.py,v 1.12.2.10 2008/08/01 03:58:03 customdesigned Exp $
|
||||
|
||||
This file is part of the pydns project.
|
||||
Homepage: http://pydns.sourceforge.net
|
||||
|
||||
This code is covered by the standard Python License.
|
||||
|
||||
Base functionality. Request and Response classes, that sort of thing.
|
||||
"""
|
||||
|
||||
import socket, string, types, time, select
|
||||
import Type,Class,Opcode
|
||||
import asyncore
|
||||
#
|
||||
# This random generator is used for transaction ids and port selection. This
|
||||
# is important to prevent spurious results from lost packets, and malicious
|
||||
# cache poisoning. This doesn't matter if you are behind a caching nameserver
|
||||
# or your app is a primary DNS server only. To install your own generator,
|
||||
# replace DNS.Base.random. SystemRandom uses /dev/urandom or similar source.
|
||||
#
|
||||
try:
|
||||
from random import SystemRandom
|
||||
random = SystemRandom()
|
||||
except:
|
||||
import random
|
||||
|
||||
class DNSError(Exception): pass
|
||||
|
||||
# Lib uses DNSError, so import after defining.
|
||||
import Lib
|
||||
|
||||
defaults= { 'protocol':'udp', 'port':53, 'opcode':Opcode.QUERY,
|
||||
'qtype':Type.A, 'rd':1, 'timing':1, 'timeout': 30 }
|
||||
|
||||
defaults['server']=[]
|
||||
|
||||
def ParseResolvConf(resolv_path="/etc/resolv.conf"):
|
||||
"parses the /etc/resolv.conf file and sets defaults for name servers"
|
||||
global defaults
|
||||
lines=open(resolv_path).readlines()
|
||||
for line in lines:
|
||||
line = string.strip(line)
|
||||
if not line or line[0]==';' or line[0]=='#':
|
||||
continue
|
||||
fields=string.split(line)
|
||||
if len(fields) < 2:
|
||||
continue
|
||||
if fields[0]=='domain' and len(fields) > 1:
|
||||
defaults['domain']=fields[1]
|
||||
if fields[0]=='search':
|
||||
pass
|
||||
if fields[0]=='options':
|
||||
pass
|
||||
if fields[0]=='sortlist':
|
||||
pass
|
||||
if fields[0]=='nameserver':
|
||||
if fields[1].count(':'):
|
||||
""" Ignore IPv6 nameservers as we currently do not support querying them. """
|
||||
pass
|
||||
else:
|
||||
defaults['server'].append(fields[1])
|
||||
|
||||
def DiscoverNameServers():
|
||||
import sys
|
||||
if sys.platform in ('win32', 'nt'):
|
||||
import win32dns
|
||||
defaults['server']=win32dns.RegistryResolve()
|
||||
else:
|
||||
return ParseResolvConf()
|
||||
|
||||
class DnsRequest:
|
||||
""" high level Request object """
|
||||
def __init__(self,*name,**args):
|
||||
self.donefunc=None
|
||||
self.async=None
|
||||
self.defaults = {}
|
||||
self.argparse(name,args)
|
||||
self.defaults = self.args
|
||||
self.tid = 0
|
||||
|
||||
def argparse(self,name,args):
|
||||
if not name and self.defaults.has_key('name'):
|
||||
args['name'] = self.defaults['name']
|
||||
if type(name) is types.StringType:
|
||||
args['name']=name
|
||||
else:
|
||||
if len(name) == 1:
|
||||
if name[0]:
|
||||
args['name']=name[0]
|
||||
for i in defaults.keys():
|
||||
if not args.has_key(i):
|
||||
if self.defaults.has_key(i):
|
||||
args[i]=self.defaults[i]
|
||||
else:
|
||||
args[i]=defaults[i]
|
||||
if type(args['server']) == types.StringType:
|
||||
args['server'] = [args['server']]
|
||||
self.args=args
|
||||
|
||||
def socketInit(self,a,b):
|
||||
self.s = socket.socket(a,b)
|
||||
|
||||
def processUDPReply(self):
|
||||
if self.timeout > 0:
|
||||
r,w,e = select.select([self.s],[],[],self.timeout)
|
||||
if not len(r):
|
||||
raise DNSError, 'Timeout'
|
||||
(self.reply, self.from_address) = self.s.recvfrom(65535)
|
||||
self.time_finish=time.time()
|
||||
self.args['server']=self.ns
|
||||
return self.processReply()
|
||||
|
||||
def processTCPReply(self):
|
||||
if self.timeout > 0:
|
||||
r,w,e = select.select([self.s],[],[],self.timeout)
|
||||
if not len(r):
|
||||
raise DNSError, 'Timeout'
|
||||
f = self.s.makefile('r')
|
||||
header = f.read(2)
|
||||
if len(header) < 2:
|
||||
raise DNSError,'EOF'
|
||||
count = Lib.unpack16bit(header)
|
||||
self.reply = f.read(count)
|
||||
if len(self.reply) != count:
|
||||
# FIXME: Since we are non-blocking, it could just be a large reply
|
||||
# that we need to loop and wait for.
|
||||
raise DNSError,'incomplete reply'
|
||||
self.time_finish=time.time()
|
||||
self.args['server']=self.ns
|
||||
return self.processReply()
|
||||
|
||||
def processReply(self):
|
||||
self.args['elapsed']=(self.time_finish-self.time_start)*1000
|
||||
u = Lib.Munpacker(self.reply)
|
||||
r=Lib.DnsResult(u,self.args)
|
||||
r.args=self.args
|
||||
#self.args=None # mark this DnsRequest object as used.
|
||||
return r
|
||||
#### TODO TODO TODO ####
|
||||
# if protocol == 'tcp' and qtype == Type.AXFR:
|
||||
# while 1:
|
||||
# header = f.read(2)
|
||||
# if len(header) < 2:
|
||||
# print '========== EOF =========='
|
||||
# break
|
||||
# count = Lib.unpack16bit(header)
|
||||
# if not count:
|
||||
# print '========== ZERO COUNT =========='
|
||||
# break
|
||||
# print '========== NEXT =========='
|
||||
# reply = f.read(count)
|
||||
# if len(reply) != count:
|
||||
# print '*** Incomplete reply ***'
|
||||
# break
|
||||
# u = Lib.Munpacker(reply)
|
||||
# Lib.dumpM(u)
|
||||
|
||||
def getSource(self):
|
||||
"Pick random source port to avoid DNS cache poisoning attack."
|
||||
while True:
|
||||
try:
|
||||
source_port = random.randint(1024,65535)
|
||||
self.s.bind(('', source_port))
|
||||
break
|
||||
except socket.error, msg:
|
||||
# Error 98, 'Address already in use'
|
||||
if msg[0] != 98: raise
|
||||
|
||||
def conn(self):
|
||||
self.getSource()
|
||||
self.s.connect((self.ns,self.port))
|
||||
|
||||
def req(self,*name,**args):
|
||||
" needs a refactoring "
|
||||
self.argparse(name,args)
|
||||
#if not self.args:
|
||||
# raise DNSError,'reinitialize request before reuse'
|
||||
protocol = self.args['protocol']
|
||||
self.port = self.args['port']
|
||||
self.tid = random.randint(0,65535)
|
||||
self.timeout = self.args['timeout'];
|
||||
opcode = self.args['opcode']
|
||||
rd = self.args['rd']
|
||||
server=self.args['server']
|
||||
if type(self.args['qtype']) == types.StringType:
|
||||
try:
|
||||
qtype = getattr(Type, string.upper(self.args['qtype']))
|
||||
except AttributeError:
|
||||
raise DNSError,'unknown query type'
|
||||
else:
|
||||
qtype=self.args['qtype']
|
||||
if not self.args.has_key('name'):
|
||||
print self.args
|
||||
raise DNSError,'nothing to lookup'
|
||||
qname = self.args['name']
|
||||
if qtype == Type.AXFR:
|
||||
print 'Query type AXFR, protocol forced to TCP'
|
||||
protocol = 'tcp'
|
||||
#print 'QTYPE %d(%s)' % (qtype, Type.typestr(qtype))
|
||||
m = Lib.Mpacker()
|
||||
# jesus. keywords and default args would be good. TODO.
|
||||
m.addHeader(self.tid,
|
||||
0, opcode, 0, 0, rd, 0, 0, 0,
|
||||
1, 0, 0, 0)
|
||||
m.addQuestion(qname, qtype, Class.IN)
|
||||
self.request = m.getbuf()
|
||||
try:
|
||||
if protocol == 'udp':
|
||||
self.sendUDPRequest(server)
|
||||
else:
|
||||
self.sendTCPRequest(server)
|
||||
except socket.error, reason:
|
||||
raise DNSError, reason
|
||||
if self.async:
|
||||
return None
|
||||
else:
|
||||
if not self.response:
|
||||
raise DNSError,'no working nameservers found'
|
||||
return self.response
|
||||
|
||||
def sendUDPRequest(self, server):
|
||||
"refactor me"
|
||||
self.response=None
|
||||
for self.ns in server:
|
||||
#print "trying udp",self.ns
|
||||
try:
|
||||
if self.ns.count(':'):
|
||||
if hasattr(socket,'has_ipv6') and socket.has_ipv6:
|
||||
self.socketInit(socket.AF_INET6, socket.SOCK_DGRAM)
|
||||
else: continue
|
||||
else:
|
||||
self.socketInit(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
try:
|
||||
# TODO. Handle timeouts &c correctly (RFC)
|
||||
self.time_start=time.time()
|
||||
self.conn()
|
||||
if not self.async:
|
||||
self.s.send(self.request)
|
||||
r=self.processUDPReply()
|
||||
# Since we bind to the source port and connect to the
|
||||
# destination port, we don't need to check that here,
|
||||
# but do make sure it's actually a DNS request that the
|
||||
# packet is in reply to.
|
||||
while r.header['id'] != self.tid \
|
||||
or self.from_address[1] != self.port:
|
||||
r=self.processUDPReply()
|
||||
self.response = r
|
||||
# FIXME: check waiting async queries
|
||||
finally:
|
||||
if not self.async:
|
||||
self.s.close()
|
||||
except socket.error:
|
||||
continue
|
||||
break
|
||||
|
||||
def sendTCPRequest(self, server):
|
||||
" do the work of sending a TCP request "
|
||||
self.response=None
|
||||
for self.ns in server:
|
||||
#print "trying tcp",self.ns
|
||||
try:
|
||||
if self.ns.count(':'):
|
||||
if hasattr(socket,'has_ipv6') and socket.has_ipv6:
|
||||
self.socketInit(socket.AF_INET6, socket.SOCK_STREAM)
|
||||
else: continue
|
||||
else:
|
||||
self.socketInit(socket.AF_INET, socket.SOCK_STREAM)
|
||||
try:
|
||||
# TODO. Handle timeouts &c correctly (RFC)
|
||||
self.time_start=time.time()
|
||||
self.conn()
|
||||
buf = Lib.pack16bit(len(self.request))+self.request
|
||||
# Keep server from making sendall hang
|
||||
self.s.setblocking(0)
|
||||
# FIXME: throws WOULDBLOCK if request too large to fit in
|
||||
# system buffer
|
||||
self.s.sendall(buf)
|
||||
self.s.shutdown(socket.SHUT_WR)
|
||||
r=self.processTCPReply()
|
||||
if r.header['id'] == self.tid:
|
||||
self.response = r
|
||||
break
|
||||
finally:
|
||||
self.s.close()
|
||||
except socket.error:
|
||||
continue
|
||||
|
||||
#class DnsAsyncRequest(DnsRequest):
|
||||
class DnsAsyncRequest(DnsRequest,asyncore.dispatcher_with_send):
|
||||
" an asynchronous request object. out of date, probably broken "
|
||||
def __init__(self,*name,**args):
|
||||
DnsRequest.__init__(self, *name, **args)
|
||||
# XXX todo
|
||||
if args.has_key('done') and args['done']:
|
||||
self.donefunc=args['done']
|
||||
else:
|
||||
self.donefunc=self.showResult
|
||||
#self.realinit(name,args) # XXX todo
|
||||
self.async=1
|
||||
def conn(self):
|
||||
self.getSource()
|
||||
self.connect((self.ns,self.port))
|
||||
self.time_start=time.time()
|
||||
if self.args.has_key('start') and self.args['start']:
|
||||
asyncore.dispatcher.go(self)
|
||||
def socketInit(self,a,b):
|
||||
self.create_socket(a,b)
|
||||
asyncore.dispatcher.__init__(self)
|
||||
self.s=self
|
||||
def handle_read(self):
|
||||
if self.args['protocol'] == 'udp':
|
||||
self.response=self.processUDPReply()
|
||||
if self.donefunc:
|
||||
apply(self.donefunc,(self,))
|
||||
def handle_connect(self):
|
||||
self.send(self.request)
|
||||
def handle_write(self):
|
||||
pass
|
||||
def showResult(self,*s):
|
||||
self.response.show()
|
||||
|
||||
#
|
||||
# $Log: Base.py,v $
|
||||
# Revision 1.12.2.10 2008/08/01 03:58:03 customdesigned
|
||||
# Don't try to close socket when never opened.
|
||||
#
|
||||
# Revision 1.12.2.9 2008/08/01 03:48:31 customdesigned
|
||||
# Fix more breakage from port randomization patch. Support Ipv6 queries.
|
||||
#
|
||||
# Revision 1.12.2.8 2008/07/31 18:22:59 customdesigned
|
||||
# Wait until tcp response at least starts coming in.
|
||||
#
|
||||
# Revision 1.12.2.7 2008/07/28 01:27:00 customdesigned
|
||||
# Check configured port.
|
||||
#
|
||||
# Revision 1.12.2.6 2008/07/28 00:17:10 customdesigned
|
||||
# Randomize source ports.
|
||||
#
|
||||
# Revision 1.12.2.5 2008/07/24 20:10:55 customdesigned
|
||||
# Randomize tid in requests, and check in response.
|
||||
#
|
||||
# Revision 1.12.2.4 2007/05/22 20:28:31 customdesigned
|
||||
# Missing import Lib
|
||||
#
|
||||
# Revision 1.12.2.3 2007/05/22 20:25:52 customdesigned
|
||||
# Use socket.inetntoa,inetaton.
|
||||
#
|
||||
# Revision 1.12.2.2 2007/05/22 20:21:46 customdesigned
|
||||
# Trap socket error
|
||||
#
|
||||
# Revision 1.12.2.1 2007/05/22 20:19:35 customdesigned
|
||||
# Skip bogus but non-empty lines in resolv.conf
|
||||
#
|
||||
# Revision 1.12 2002/04/23 06:04:27 anthonybaxter
|
||||
# attempt to refactor the DNSRequest.req method a little. after doing a bit
|
||||
# of this, I've decided to bite the bullet and just rewrite the puppy. will
|
||||
# be checkin in some design notes, then unit tests and then writing the sod.
|
||||
#
|
||||
# Revision 1.11 2002/03/19 13:05:02 anthonybaxter
|
||||
# converted to class based exceptions (there goes the python1.4 compatibility :)
|
||||
#
|
||||
# removed a quite gross use of 'eval()'.
|
||||
#
|
||||
# Revision 1.10 2002/03/19 12:41:33 anthonybaxter
|
||||
# tabnannied and reindented everything. 4 space indent, no tabs.
|
||||
# yay.
|
||||
#
|
||||
# Revision 1.9 2002/03/19 12:26:13 anthonybaxter
|
||||
# death to leading tabs.
|
||||
#
|
||||
# Revision 1.8 2002/03/19 10:30:33 anthonybaxter
|
||||
# first round of major bits and pieces. The major stuff here (summarised
|
||||
# from my local, off-net CVS server :/ this will cause some oddities with
|
||||
# the
|
||||
#
|
||||
# tests/testPackers.py:
|
||||
# a large slab of unit tests for the packer and unpacker code in DNS.Lib
|
||||
#
|
||||
# DNS/Lib.py:
|
||||
# placeholder for addSRV.
|
||||
# added 'klass' to addA, make it the same as the other A* records.
|
||||
# made addTXT check for being passed a string, turn it into a length 1 list.
|
||||
# explicitly check for adding a string of length > 255 (prohibited).
|
||||
# a bunch of cleanups from a first pass with pychecker
|
||||
# new code for pack/unpack. the bitwise stuff uses struct, for a smallish
|
||||
# (disappointly small, actually) improvement, while addr2bin is much
|
||||
# much faster now.
|
||||
#
|
||||
# DNS/Base.py:
|
||||
# added DiscoverNameServers. This automatically does the right thing
|
||||
# on unix/ win32. No idea how MacOS handles this. *sigh*
|
||||
# Incompatible change: Don't use ParseResolvConf on non-unix, use this
|
||||
# function, instead!
|
||||
# a bunch of cleanups from a first pass with pychecker
|
||||
#
|
||||
# Revision 1.5 2001/08/09 09:22:28 anthonybaxter
|
||||
# added what I hope is win32 resolver lookup support. I'll need to try
|
||||
# and figure out how to get the CVS checkout onto my windows machine to
|
||||
# make sure it works (wow, doing something other than games on the
|
||||
# windows machine :)
|
||||
#
|
||||
# Code from Wolfgang.Strobl@gmd.de
|
||||
# win32dns.py from
|
||||
# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66260
|
||||
#
|
||||
# Really, ParseResolvConf() should be renamed "FindNameServers" or
|
||||
# some such.
|
||||
#
|
||||
# Revision 1.4 2001/08/09 09:08:55 anthonybaxter
|
||||
# added identifying header to top of each file
|
||||
#
|
||||
# Revision 1.3 2001/07/19 07:20:12 anthony
|
||||
# Handle blank resolv.conf lines.
|
||||
# Patch from Bastian Kleineidam
|
||||
#
|
||||
# Revision 1.2 2001/07/19 06:57:07 anthony
|
||||
# cvs keywords added
|
||||
#
|
||||
#
|
||||
54
lib/DNS/Class.py
Normal file
54
lib/DNS/Class.py
Normal file
@@ -0,0 +1,54 @@
|
||||
"""
|
||||
$Id: Class.py,v 1.6 2002/04/23 12:52:19 anthonybaxter Exp $
|
||||
|
||||
This file is part of the pydns project.
|
||||
Homepage: http://pydns.sourceforge.net
|
||||
|
||||
This code is covered by the standard Python License.
|
||||
|
||||
CLASS values (section 3.2.4)
|
||||
"""
|
||||
|
||||
|
||||
IN = 1 # the Internet
|
||||
CS = 2 # the CSNET class (Obsolete - used only for examples in
|
||||
# some obsolete RFCs)
|
||||
CH = 3 # the CHAOS class. When someone shows me python running on
|
||||
# a Symbolics Lisp machine, I'll look at implementing this.
|
||||
HS = 4 # Hesiod [Dyer 87]
|
||||
|
||||
# QCLASS values (section 3.2.5)
|
||||
|
||||
ANY = 255 # any class
|
||||
|
||||
|
||||
# Construct reverse mapping dictionary
|
||||
|
||||
_names = dir()
|
||||
classmap = {}
|
||||
for _name in _names:
|
||||
if _name[0] != '_': classmap[eval(_name)] = _name
|
||||
|
||||
def classstr(klass):
|
||||
if classmap.has_key(klass): return classmap[klass]
|
||||
else: return `klass`
|
||||
|
||||
#
|
||||
# $Log: Class.py,v $
|
||||
# Revision 1.6 2002/04/23 12:52:19 anthonybaxter
|
||||
# cleanup whitespace.
|
||||
#
|
||||
# Revision 1.5 2002/03/19 12:41:33 anthonybaxter
|
||||
# tabnannied and reindented everything. 4 space indent, no tabs.
|
||||
# yay.
|
||||
#
|
||||
# Revision 1.4 2002/03/19 12:26:13 anthonybaxter
|
||||
# death to leading tabs.
|
||||
#
|
||||
# Revision 1.3 2001/08/09 09:08:55 anthonybaxter
|
||||
# added identifying header to top of each file
|
||||
#
|
||||
# Revision 1.2 2001/07/19 06:57:07 anthony
|
||||
# cvs keywords added
|
||||
#
|
||||
#
|
||||
693
lib/DNS/Lib.py
Normal file
693
lib/DNS/Lib.py
Normal file
@@ -0,0 +1,693 @@
|
||||
# -*- encoding: utf-8 -*-
|
||||
"""
|
||||
$Id: Lib.py,v 1.11.2.3 2007/05/22 20:27:40 customdesigned Exp $
|
||||
|
||||
This file is part of the pydns project.
|
||||
Homepage: http://pydns.sourceforge.net
|
||||
|
||||
This code is covered by the standard Python License.
|
||||
|
||||
Library code. Largely this is packers and unpackers for various types.
|
||||
"""
|
||||
|
||||
#
|
||||
#
|
||||
# See RFC 1035:
|
||||
# ------------------------------------------------------------------------
|
||||
# Network Working Group P. Mockapetris
|
||||
# Request for Comments: 1035 ISI
|
||||
# November 1987
|
||||
# Obsoletes: RFCs 882, 883, 973
|
||||
#
|
||||
# DOMAIN NAMES - IMPLEMENTATION AND SPECIFICATION
|
||||
# ------------------------------------------------------------------------
|
||||
|
||||
|
||||
import string, types
|
||||
|
||||
import Type
|
||||
import Class
|
||||
import Opcode
|
||||
import Status
|
||||
|
||||
from Base import DNSError
|
||||
|
||||
class UnpackError(DNSError): pass
|
||||
class PackError(DNSError): pass
|
||||
|
||||
# Low-level 16 and 32 bit integer packing and unpacking
|
||||
|
||||
from struct import pack as struct_pack
|
||||
from struct import unpack as struct_unpack
|
||||
from socket import inet_ntoa, inet_aton
|
||||
|
||||
def pack16bit(n):
|
||||
return struct_pack('!H', n)
|
||||
|
||||
def pack32bit(n):
|
||||
return struct_pack('!L', n)
|
||||
|
||||
def unpack16bit(s):
|
||||
return struct_unpack('!H', s)[0]
|
||||
|
||||
def unpack32bit(s):
|
||||
return struct_unpack('!L', s)[0]
|
||||
|
||||
def addr2bin(addr):
|
||||
return struct_unpack('!l', inet_aton(addr))[0]
|
||||
|
||||
def bin2addr(n):
|
||||
return inet_ntoa(struct_pack('!L', n))
|
||||
|
||||
# Packing class
|
||||
|
||||
class Packer:
|
||||
" packer base class. supports basic byte/16bit/32bit/addr/string/name "
|
||||
def __init__(self):
|
||||
self.buf = ''
|
||||
self.index = {}
|
||||
def getbuf(self):
|
||||
return self.buf
|
||||
def addbyte(self, c):
|
||||
if len(c) != 1: raise TypeError, 'one character expected'
|
||||
self.buf = self.buf + c
|
||||
def addbytes(self, bytes):
|
||||
self.buf = self.buf + bytes
|
||||
def add16bit(self, n):
|
||||
self.buf = self.buf + pack16bit(n)
|
||||
def add32bit(self, n):
|
||||
self.buf = self.buf + pack32bit(n)
|
||||
def addaddr(self, addr):
|
||||
n = addr2bin(addr)
|
||||
self.buf = self.buf + pack32bit(n)
|
||||
def addstring(self, s):
|
||||
if len(s) > 255:
|
||||
raise ValueError, "Can't encode string of length "+ \
|
||||
"%s (> 255)"%(len(s))
|
||||
self.addbyte(chr(len(s)))
|
||||
self.addbytes(s)
|
||||
def addname(self, name):
|
||||
# Domain name packing (section 4.1.4)
|
||||
# Add a domain name to the buffer, possibly using pointers.
|
||||
# The case of the first occurrence of a name is preserved.
|
||||
# Redundant dots are ignored.
|
||||
list = []
|
||||
for label in string.splitfields(name, '.'):
|
||||
if label:
|
||||
label = label.encode('utf8')
|
||||
if len(label) > 63:
|
||||
raise PackError, 'label too long'
|
||||
list.append(label)
|
||||
keys = []
|
||||
for i in range(len(list)):
|
||||
key = string.upper(string.joinfields(list[i:], '.'))
|
||||
keys.append(key)
|
||||
if self.index.has_key(key):
|
||||
pointer = self.index[key]
|
||||
break
|
||||
else:
|
||||
i = len(list)
|
||||
pointer = None
|
||||
# Do it into temporaries first so exceptions don't
|
||||
# mess up self.index and self.buf
|
||||
buf = ''
|
||||
offset = len(self.buf)
|
||||
index = []
|
||||
for j in range(i):
|
||||
label = list[j]
|
||||
n = len(label)
|
||||
if offset + len(buf) < 0x3FFF:
|
||||
index.append((keys[j], offset + len(buf)))
|
||||
else:
|
||||
print 'DNS.Lib.Packer.addname:',
|
||||
print 'warning: pointer too big'
|
||||
buf = buf + (chr(n) + label)
|
||||
if pointer:
|
||||
buf = buf + pack16bit(pointer | 0xC000)
|
||||
else:
|
||||
buf = buf + '\0'
|
||||
self.buf = self.buf + buf
|
||||
for key, value in index:
|
||||
self.index[key] = value
|
||||
def dump(self):
|
||||
keys = self.index.keys()
|
||||
keys.sort()
|
||||
print '-'*40
|
||||
for key in keys:
|
||||
print '%20s %3d' % (key, self.index[key])
|
||||
print '-'*40
|
||||
space = 1
|
||||
for i in range(0, len(self.buf)+1, 2):
|
||||
if self.buf[i:i+2] == '**':
|
||||
if not space: print
|
||||
space = 1
|
||||
continue
|
||||
space = 0
|
||||
print '%4d' % i,
|
||||
for c in self.buf[i:i+2]:
|
||||
if ' ' < c < '\177':
|
||||
print ' %c' % c,
|
||||
else:
|
||||
print '%2d' % ord(c),
|
||||
print
|
||||
print '-'*40
|
||||
|
||||
|
||||
# Unpacking class
|
||||
|
||||
|
||||
class Unpacker:
|
||||
def __init__(self, buf):
|
||||
self.buf = buf
|
||||
self.offset = 0
|
||||
def getbyte(self):
|
||||
if self.offset >= len(self.buf):
|
||||
raise UnpackError, "Ran off end of data"
|
||||
c = self.buf[self.offset]
|
||||
self.offset = self.offset + 1
|
||||
return c
|
||||
def getbytes(self, n):
|
||||
s = self.buf[self.offset : self.offset + n]
|
||||
if len(s) != n: raise UnpackError, 'not enough data left'
|
||||
self.offset = self.offset + n
|
||||
return s
|
||||
def get16bit(self):
|
||||
return unpack16bit(self.getbytes(2))
|
||||
def get32bit(self):
|
||||
return unpack32bit(self.getbytes(4))
|
||||
def getaddr(self):
|
||||
return bin2addr(self.get32bit())
|
||||
def getstring(self):
|
||||
return self.getbytes(ord(self.getbyte()))
|
||||
def getname(self):
|
||||
# Domain name unpacking (section 4.1.4)
|
||||
c = self.getbyte()
|
||||
i = ord(c)
|
||||
if i & 0xC0 == 0xC0:
|
||||
d = self.getbyte()
|
||||
j = ord(d)
|
||||
pointer = ((i<<8) | j) & ~0xC000
|
||||
save_offset = self.offset
|
||||
try:
|
||||
self.offset = pointer
|
||||
domain = self.getname()
|
||||
finally:
|
||||
self.offset = save_offset
|
||||
return domain
|
||||
if i == 0:
|
||||
return ''
|
||||
domain = self.getbytes(i)
|
||||
remains = self.getname()
|
||||
if not remains:
|
||||
return domain
|
||||
else:
|
||||
return domain + '.' + remains
|
||||
|
||||
|
||||
# Test program for packin/unpacking (section 4.1.4)
|
||||
|
||||
def testpacker():
|
||||
N = 2500
|
||||
R = range(N)
|
||||
import timing
|
||||
# See section 4.1.4 of RFC 1035
|
||||
timing.start()
|
||||
for i in R:
|
||||
p = Packer()
|
||||
p.addaddr('192.168.0.1')
|
||||
p.addbytes('*' * 20)
|
||||
p.addname('f.ISI.ARPA')
|
||||
p.addbytes('*' * 8)
|
||||
p.addname('Foo.F.isi.arpa')
|
||||
p.addbytes('*' * 18)
|
||||
p.addname('arpa')
|
||||
p.addbytes('*' * 26)
|
||||
p.addname('')
|
||||
timing.finish()
|
||||
print timing.milli(), "ms total for packing"
|
||||
print round(timing.milli() / i, 4), 'ms per packing'
|
||||
#p.dump()
|
||||
u = Unpacker(p.buf)
|
||||
u.getaddr()
|
||||
u.getbytes(20)
|
||||
u.getname()
|
||||
u.getbytes(8)
|
||||
u.getname()
|
||||
u.getbytes(18)
|
||||
u.getname()
|
||||
u.getbytes(26)
|
||||
u.getname()
|
||||
timing.start()
|
||||
for i in R:
|
||||
u = Unpacker(p.buf)
|
||||
|
||||
res = (u.getaddr(),
|
||||
u.getbytes(20),
|
||||
u.getname(),
|
||||
u.getbytes(8),
|
||||
u.getname(),
|
||||
u.getbytes(18),
|
||||
u.getname(),
|
||||
u.getbytes(26),
|
||||
u.getname())
|
||||
timing.finish()
|
||||
print timing.milli(), "ms total for unpacking"
|
||||
print round(timing.milli() / i, 4), 'ms per unpacking'
|
||||
#for item in res: print item
|
||||
|
||||
|
||||
# Pack/unpack RR toplevel format (section 3.2.1)
|
||||
|
||||
class RRpacker(Packer):
|
||||
def __init__(self):
|
||||
Packer.__init__(self)
|
||||
self.rdstart = None
|
||||
def addRRheader(self, name, type, klass, ttl, *rest):
|
||||
self.addname(name)
|
||||
self.add16bit(type)
|
||||
self.add16bit(klass)
|
||||
self.add32bit(ttl)
|
||||
if rest:
|
||||
if rest[1:]: raise TypeError, 'too many args'
|
||||
rdlength = rest[0]
|
||||
else:
|
||||
rdlength = 0
|
||||
self.add16bit(rdlength)
|
||||
self.rdstart = len(self.buf)
|
||||
def patchrdlength(self):
|
||||
rdlength = unpack16bit(self.buf[self.rdstart-2:self.rdstart])
|
||||
if rdlength == len(self.buf) - self.rdstart:
|
||||
return
|
||||
rdata = self.buf[self.rdstart:]
|
||||
save_buf = self.buf
|
||||
ok = 0
|
||||
try:
|
||||
self.buf = self.buf[:self.rdstart-2]
|
||||
self.add16bit(len(rdata))
|
||||
self.buf = self.buf + rdata
|
||||
ok = 1
|
||||
finally:
|
||||
if not ok: self.buf = save_buf
|
||||
def endRR(self):
|
||||
if self.rdstart is not None:
|
||||
self.patchrdlength()
|
||||
self.rdstart = None
|
||||
def getbuf(self):
|
||||
if self.rdstart is not None: self.patchrdlength()
|
||||
return Packer.getbuf(self)
|
||||
# Standard RRs (section 3.3)
|
||||
def addCNAME(self, name, klass, ttl, cname):
|
||||
self.addRRheader(name, Type.CNAME, klass, ttl)
|
||||
self.addname(cname)
|
||||
self.endRR()
|
||||
def addHINFO(self, name, klass, ttl, cpu, os):
|
||||
self.addRRheader(name, Type.HINFO, klass, ttl)
|
||||
self.addstring(cpu)
|
||||
self.addstring(os)
|
||||
self.endRR()
|
||||
def addMX(self, name, klass, ttl, preference, exchange):
|
||||
self.addRRheader(name, Type.MX, klass, ttl)
|
||||
self.add16bit(preference)
|
||||
self.addname(exchange)
|
||||
self.endRR()
|
||||
def addNS(self, name, klass, ttl, nsdname):
|
||||
self.addRRheader(name, Type.NS, klass, ttl)
|
||||
self.addname(nsdname)
|
||||
self.endRR()
|
||||
def addPTR(self, name, klass, ttl, ptrdname):
|
||||
self.addRRheader(name, Type.PTR, klass, ttl)
|
||||
self.addname(ptrdname)
|
||||
self.endRR()
|
||||
def addSOA(self, name, klass, ttl,
|
||||
mname, rname, serial, refresh, retry, expire, minimum):
|
||||
self.addRRheader(name, Type.SOA, klass, ttl)
|
||||
self.addname(mname)
|
||||
self.addname(rname)
|
||||
self.add32bit(serial)
|
||||
self.add32bit(refresh)
|
||||
self.add32bit(retry)
|
||||
self.add32bit(expire)
|
||||
self.add32bit(minimum)
|
||||
self.endRR()
|
||||
def addTXT(self, name, klass, ttl, list):
|
||||
self.addRRheader(name, Type.TXT, klass, ttl)
|
||||
if type(list) is types.StringType:
|
||||
list = [list]
|
||||
for txtdata in list:
|
||||
self.addstring(txtdata)
|
||||
self.endRR()
|
||||
# Internet specific RRs (section 3.4) -- class = IN
|
||||
def addA(self, name, klass, ttl, address):
|
||||
self.addRRheader(name, Type.A, klass, ttl)
|
||||
self.addaddr(address)
|
||||
self.endRR()
|
||||
def addWKS(self, name, ttl, address, protocol, bitmap):
|
||||
self.addRRheader(name, Type.WKS, Class.IN, ttl)
|
||||
self.addaddr(address)
|
||||
self.addbyte(chr(protocol))
|
||||
self.addbytes(bitmap)
|
||||
self.endRR()
|
||||
def addSRV(self):
|
||||
raise NotImplementedError
|
||||
|
||||
def prettyTime(seconds):
|
||||
if seconds<60:
|
||||
return seconds,"%d seconds"%(seconds)
|
||||
if seconds<3600:
|
||||
return seconds,"%d minutes"%(seconds/60)
|
||||
if seconds<86400:
|
||||
return seconds,"%d hours"%(seconds/3600)
|
||||
if seconds<604800:
|
||||
return seconds,"%d days"%(seconds/86400)
|
||||
else:
|
||||
return seconds,"%d weeks"%(seconds/604800)
|
||||
|
||||
|
||||
class RRunpacker(Unpacker):
|
||||
def __init__(self, buf):
|
||||
Unpacker.__init__(self, buf)
|
||||
self.rdend = None
|
||||
def getRRheader(self):
|
||||
name = self.getname()
|
||||
rrtype = self.get16bit()
|
||||
klass = self.get16bit()
|
||||
ttl = self.get32bit()
|
||||
rdlength = self.get16bit()
|
||||
self.rdend = self.offset + rdlength
|
||||
return (name, rrtype, klass, ttl, rdlength)
|
||||
def endRR(self):
|
||||
if self.offset != self.rdend:
|
||||
raise UnpackError, 'end of RR not reached'
|
||||
def getCNAMEdata(self):
|
||||
return self.getname()
|
||||
def getHINFOdata(self):
|
||||
return self.getstring(), self.getstring()
|
||||
def getMXdata(self):
|
||||
return self.get16bit(), self.getname()
|
||||
def getNSdata(self):
|
||||
return self.getname()
|
||||
def getPTRdata(self):
|
||||
return self.getname()
|
||||
def getSOAdata(self):
|
||||
return self.getname(), \
|
||||
self.getname(), \
|
||||
('serial',)+(self.get32bit(),), \
|
||||
('refresh ',)+prettyTime(self.get32bit()), \
|
||||
('retry',)+prettyTime(self.get32bit()), \
|
||||
('expire',)+prettyTime(self.get32bit()), \
|
||||
('minimum',)+prettyTime(self.get32bit())
|
||||
def getTXTdata(self):
|
||||
list = []
|
||||
while self.offset != self.rdend:
|
||||
list.append(self.getstring())
|
||||
return list
|
||||
def getAdata(self):
|
||||
return self.getaddr()
|
||||
def getWKSdata(self):
|
||||
address = self.getaddr()
|
||||
protocol = ord(self.getbyte())
|
||||
bitmap = self.getbytes(self.rdend - self.offset)
|
||||
return address, protocol, bitmap
|
||||
def getSRVdata(self):
|
||||
"""
|
||||
_Service._Proto.Name TTL Class SRV Priority Weight Port Target
|
||||
"""
|
||||
priority = self.get16bit()
|
||||
weight = self.get16bit()
|
||||
port = self.get16bit()
|
||||
target = self.getname()
|
||||
#print '***priority, weight, port, target', priority, weight, port, target
|
||||
return priority, weight, port, target
|
||||
|
||||
|
||||
# Pack/unpack Message Header (section 4.1)
|
||||
|
||||
class Hpacker(Packer):
|
||||
def addHeader(self, id, qr, opcode, aa, tc, rd, ra, z, rcode,
|
||||
qdcount, ancount, nscount, arcount):
|
||||
self.add16bit(id)
|
||||
self.add16bit((qr&1)<<15 | (opcode&0xF)<<11 | (aa&1)<<10
|
||||
| (tc&1)<<9 | (rd&1)<<8 | (ra&1)<<7
|
||||
| (z&7)<<4 | (rcode&0xF))
|
||||
self.add16bit(qdcount)
|
||||
self.add16bit(ancount)
|
||||
self.add16bit(nscount)
|
||||
self.add16bit(arcount)
|
||||
|
||||
class Hunpacker(Unpacker):
|
||||
def getHeader(self):
|
||||
id = self.get16bit()
|
||||
flags = self.get16bit()
|
||||
qr, opcode, aa, tc, rd, ra, z, rcode = (
|
||||
(flags>>15)&1,
|
||||
(flags>>11)&0xF,
|
||||
(flags>>10)&1,
|
||||
(flags>>9)&1,
|
||||
(flags>>8)&1,
|
||||
(flags>>7)&1,
|
||||
(flags>>4)&7,
|
||||
(flags>>0)&0xF)
|
||||
qdcount = self.get16bit()
|
||||
ancount = self.get16bit()
|
||||
nscount = self.get16bit()
|
||||
arcount = self.get16bit()
|
||||
return (id, qr, opcode, aa, tc, rd, ra, z, rcode,
|
||||
qdcount, ancount, nscount, arcount)
|
||||
|
||||
|
||||
# Pack/unpack Question (section 4.1.2)
|
||||
|
||||
class Qpacker(Packer):
|
||||
def addQuestion(self, qname, qtype, qclass):
|
||||
self.addname(qname)
|
||||
self.add16bit(qtype)
|
||||
self.add16bit(qclass)
|
||||
|
||||
class Qunpacker(Unpacker):
|
||||
def getQuestion(self):
|
||||
return self.getname(), self.get16bit(), self.get16bit()
|
||||
|
||||
|
||||
# Pack/unpack Message(section 4)
|
||||
# NB the order of the base classes is important for __init__()!
|
||||
|
||||
class Mpacker(RRpacker, Qpacker, Hpacker):
|
||||
pass
|
||||
|
||||
class Munpacker(RRunpacker, Qunpacker, Hunpacker):
|
||||
pass
|
||||
|
||||
|
||||
# Routines to print an unpacker to stdout, for debugging.
|
||||
# These affect the unpacker's current position!
|
||||
|
||||
def dumpM(u):
|
||||
print 'HEADER:',
|
||||
(id, qr, opcode, aa, tc, rd, ra, z, rcode,
|
||||
qdcount, ancount, nscount, arcount) = u.getHeader()
|
||||
print 'id=%d,' % id,
|
||||
print 'qr=%d, opcode=%d, aa=%d, tc=%d, rd=%d, ra=%d, z=%d, rcode=%d,' \
|
||||
% (qr, opcode, aa, tc, rd, ra, z, rcode)
|
||||
if tc: print '*** response truncated! ***'
|
||||
if rcode: print '*** nonzero error code! (%d) ***' % rcode
|
||||
print ' qdcount=%d, ancount=%d, nscount=%d, arcount=%d' \
|
||||
% (qdcount, ancount, nscount, arcount)
|
||||
for i in range(qdcount):
|
||||
print 'QUESTION %d:' % i,
|
||||
dumpQ(u)
|
||||
for i in range(ancount):
|
||||
print 'ANSWER %d:' % i,
|
||||
dumpRR(u)
|
||||
for i in range(nscount):
|
||||
print 'AUTHORITY RECORD %d:' % i,
|
||||
dumpRR(u)
|
||||
for i in range(arcount):
|
||||
print 'ADDITIONAL RECORD %d:' % i,
|
||||
dumpRR(u)
|
||||
|
||||
class DnsResult:
|
||||
|
||||
def __init__(self,u,args):
|
||||
self.header={}
|
||||
self.questions=[]
|
||||
self.answers=[]
|
||||
self.authority=[]
|
||||
self.additional=[]
|
||||
self.args=args
|
||||
self.storeM(u)
|
||||
|
||||
def show(self):
|
||||
import time
|
||||
print '; <<>> PDG.py 1.0 <<>> %s %s'%(self.args['name'],
|
||||
self.args['qtype'])
|
||||
opt=""
|
||||
if self.args['rd']:
|
||||
opt=opt+'recurs '
|
||||
h=self.header
|
||||
print ';; options: '+opt
|
||||
print ';; got answer:'
|
||||
print ';; ->>HEADER<<- opcode %s, status %s, id %d'%(
|
||||
h['opcode'],h['status'],h['id'])
|
||||
flags=filter(lambda x,h=h:h[x],('qr','aa','rd','ra','tc'))
|
||||
print ';; flags: %s; Ques: %d, Ans: %d, Auth: %d, Addit: %d'%(
|
||||
string.join(flags),h['qdcount'],h['ancount'],h['nscount'],
|
||||
h['arcount'])
|
||||
print ';; QUESTIONS:'
|
||||
for q in self.questions:
|
||||
print ';; %s, type = %s, class = %s'%(q['qname'],q['qtypestr'],
|
||||
q['qclassstr'])
|
||||
print
|
||||
print ';; ANSWERS:'
|
||||
for a in self.answers:
|
||||
print '%-20s %-6s %-6s %s'%(a['name'],`a['ttl']`,a['typename'],
|
||||
a['data'])
|
||||
print
|
||||
print ';; AUTHORITY RECORDS:'
|
||||
for a in self.authority:
|
||||
print '%-20s %-6s %-6s %s'%(a['name'],`a['ttl']`,a['typename'],
|
||||
a['data'])
|
||||
print
|
||||
print ';; ADDITIONAL RECORDS:'
|
||||
for a in self.additional:
|
||||
print '%-20s %-6s %-6s %s'%(a['name'],`a['ttl']`,a['typename'],
|
||||
a['data'])
|
||||
print
|
||||
if self.args.has_key('elapsed'):
|
||||
print ';; Total query time: %d msec'%self.args['elapsed']
|
||||
print ';; To SERVER: %s'%(self.args['server'])
|
||||
print ';; WHEN: %s'%time.ctime(time.time())
|
||||
|
||||
def storeM(self,u):
|
||||
(self.header['id'], self.header['qr'], self.header['opcode'],
|
||||
self.header['aa'], self.header['tc'], self.header['rd'],
|
||||
self.header['ra'], self.header['z'], self.header['rcode'],
|
||||
self.header['qdcount'], self.header['ancount'],
|
||||
self.header['nscount'], self.header['arcount']) = u.getHeader()
|
||||
self.header['opcodestr']=Opcode.opcodestr(self.header['opcode'])
|
||||
self.header['status']=Status.statusstr(self.header['rcode'])
|
||||
for i in range(self.header['qdcount']):
|
||||
#print 'QUESTION %d:' % i,
|
||||
self.questions.append(self.storeQ(u))
|
||||
for i in range(self.header['ancount']):
|
||||
#print 'ANSWER %d:' % i,
|
||||
self.answers.append(self.storeRR(u))
|
||||
for i in range(self.header['nscount']):
|
||||
#print 'AUTHORITY RECORD %d:' % i,
|
||||
self.authority.append(self.storeRR(u))
|
||||
for i in range(self.header['arcount']):
|
||||
#print 'ADDITIONAL RECORD %d:' % i,
|
||||
self.additional.append(self.storeRR(u))
|
||||
|
||||
def storeQ(self,u):
|
||||
q={}
|
||||
q['qname'], q['qtype'], q['qclass'] = u.getQuestion()
|
||||
q['qtypestr']=Type.typestr(q['qtype'])
|
||||
q['qclassstr']=Class.classstr(q['qclass'])
|
||||
return q
|
||||
|
||||
def storeRR(self,u):
|
||||
r={}
|
||||
r['name'],r['type'],r['class'],r['ttl'],r['rdlength'] = u.getRRheader()
|
||||
r['typename'] = Type.typestr(r['type'])
|
||||
r['classstr'] = Class.classstr(r['class'])
|
||||
#print 'name=%s, type=%d(%s), class=%d(%s), ttl=%d' \
|
||||
# % (name,
|
||||
# type, typename,
|
||||
# klass, Class.classstr(class),
|
||||
# ttl)
|
||||
mname = 'get%sdata' % r['typename']
|
||||
if hasattr(u, mname):
|
||||
r['data']=getattr(u, mname)()
|
||||
else:
|
||||
r['data']=u.getbytes(r['rdlength'])
|
||||
return r
|
||||
|
||||
def dumpQ(u):
|
||||
qname, qtype, qclass = u.getQuestion()
|
||||
print 'qname=%s, qtype=%d(%s), qclass=%d(%s)' \
|
||||
% (qname,
|
||||
qtype, Type.typestr(qtype),
|
||||
qclass, Class.classstr(qclass))
|
||||
|
||||
def dumpRR(u):
|
||||
name, type, klass, ttl, rdlength = u.getRRheader()
|
||||
typename = Type.typestr(type)
|
||||
print 'name=%s, type=%d(%s), class=%d(%s), ttl=%d' \
|
||||
% (name,
|
||||
type, typename,
|
||||
klass, Class.classstr(klass),
|
||||
ttl)
|
||||
mname = 'get%sdata' % typename
|
||||
if hasattr(u, mname):
|
||||
print ' formatted rdata:', getattr(u, mname)()
|
||||
else:
|
||||
print ' binary rdata:', u.getbytes(rdlength)
|
||||
|
||||
if __name__ == "__main__":
|
||||
testpacker()
|
||||
#
|
||||
# $Log: Lib.py,v $
|
||||
# Revision 1.11.2.3 2007/05/22 20:27:40 customdesigned
|
||||
# Fix unpacker underflow.
|
||||
#
|
||||
# Revision 1.11.2.2 2007/05/22 20:25:53 customdesigned
|
||||
# Use socket.inetntoa,inetaton.
|
||||
#
|
||||
# Revision 1.11.2.1 2007/05/22 20:20:39 customdesigned
|
||||
# Mark utf-8 encoding
|
||||
#
|
||||
# Revision 1.11 2002/03/19 13:05:02 anthonybaxter
|
||||
# converted to class based exceptions (there goes the python1.4 compatibility :)
|
||||
#
|
||||
# removed a quite gross use of 'eval()'.
|
||||
#
|
||||
# Revision 1.10 2002/03/19 12:41:33 anthonybaxter
|
||||
# tabnannied and reindented everything. 4 space indent, no tabs.
|
||||
# yay.
|
||||
#
|
||||
# Revision 1.9 2002/03/19 10:30:33 anthonybaxter
|
||||
# first round of major bits and pieces. The major stuff here (summarised
|
||||
# from my local, off-net CVS server :/ this will cause some oddities with
|
||||
# the
|
||||
#
|
||||
# tests/testPackers.py:
|
||||
# a large slab of unit tests for the packer and unpacker code in DNS.Lib
|
||||
#
|
||||
# DNS/Lib.py:
|
||||
# placeholder for addSRV.
|
||||
# added 'klass' to addA, make it the same as the other A* records.
|
||||
# made addTXT check for being passed a string, turn it into a length 1 list.
|
||||
# explicitly check for adding a string of length > 255 (prohibited).
|
||||
# a bunch of cleanups from a first pass with pychecker
|
||||
# new code for pack/unpack. the bitwise stuff uses struct, for a smallish
|
||||
# (disappointly small, actually) improvement, while addr2bin is much
|
||||
# much faster now.
|
||||
#
|
||||
# DNS/Base.py:
|
||||
# added DiscoverNameServers. This automatically does the right thing
|
||||
# on unix/ win32. No idea how MacOS handles this. *sigh*
|
||||
# Incompatible change: Don't use ParseResolvConf on non-unix, use this
|
||||
# function, instead!
|
||||
# a bunch of cleanups from a first pass with pychecker
|
||||
#
|
||||
# Revision 1.8 2001/08/09 09:08:55 anthonybaxter
|
||||
# added identifying header to top of each file
|
||||
#
|
||||
# Revision 1.7 2001/07/19 07:50:44 anthony
|
||||
# Added SRV (RFC 2782) support. Code from Michael Str�der.
|
||||
#
|
||||
# Revision 1.6 2001/07/19 07:39:18 anthony
|
||||
# 'type' -> 'rrtype' in getRRheader(). Fix from Michael Str�der.
|
||||
#
|
||||
# Revision 1.5 2001/07/19 07:34:19 anthony
|
||||
# oops. glitch in storeRR (fixed now).
|
||||
# Reported by Bastian Kleineidam and by greg lin.
|
||||
#
|
||||
# Revision 1.4 2001/07/19 07:16:42 anthony
|
||||
# Changed (opcode&0xF)<<11 to (opcode*0xF)<<11.
|
||||
# Patch from Timothy J. Miller.
|
||||
#
|
||||
# Revision 1.3 2001/07/19 06:57:07 anthony
|
||||
# cvs keywords added
|
||||
#
|
||||
#
|
||||
49
lib/DNS/Opcode.py
Normal file
49
lib/DNS/Opcode.py
Normal file
@@ -0,0 +1,49 @@
|
||||
"""
|
||||
$Id: Opcode.py,v 1.6 2002/04/23 10:51:43 anthonybaxter Exp $
|
||||
|
||||
This file is part of the pydns project.
|
||||
Homepage: http://pydns.sourceforge.net
|
||||
|
||||
This code is covered by the standard Python License.
|
||||
|
||||
Opcode values in message header. RFC 1035, 1996, 2136.
|
||||
"""
|
||||
|
||||
|
||||
|
||||
QUERY = 0
|
||||
IQUERY = 1
|
||||
STATUS = 2
|
||||
NOTIFY = 4
|
||||
UPDATE = 5
|
||||
|
||||
# Construct reverse mapping dictionary
|
||||
|
||||
_names = dir()
|
||||
opcodemap = {}
|
||||
for _name in _names:
|
||||
if _name[0] != '_': opcodemap[eval(_name)] = _name
|
||||
|
||||
def opcodestr(opcode):
|
||||
if opcodemap.has_key(opcode): return opcodemap[opcode]
|
||||
else: return `opcode`
|
||||
|
||||
#
|
||||
# $Log: Opcode.py,v $
|
||||
# Revision 1.6 2002/04/23 10:51:43 anthonybaxter
|
||||
# Added UPDATE, NOTIFY.
|
||||
#
|
||||
# Revision 1.5 2002/03/19 12:41:33 anthonybaxter
|
||||
# tabnannied and reindented everything. 4 space indent, no tabs.
|
||||
# yay.
|
||||
#
|
||||
# Revision 1.4 2002/03/19 12:26:13 anthonybaxter
|
||||
# death to leading tabs.
|
||||
#
|
||||
# Revision 1.3 2001/08/09 09:08:55 anthonybaxter
|
||||
# added identifying header to top of each file
|
||||
#
|
||||
# Revision 1.2 2001/07/19 06:57:07 anthony
|
||||
# cvs keywords added
|
||||
#
|
||||
#
|
||||
63
lib/DNS/Status.py
Normal file
63
lib/DNS/Status.py
Normal file
@@ -0,0 +1,63 @@
|
||||
"""
|
||||
$Id: Status.py,v 1.7 2002/04/23 12:52:19 anthonybaxter Exp $
|
||||
|
||||
This file is part of the pydns project.
|
||||
Homepage: http://pydns.sourceforge.net
|
||||
|
||||
This code is covered by the standard Python License.
|
||||
|
||||
Status values in message header
|
||||
"""
|
||||
|
||||
NOERROR = 0 # No Error [RFC 1035]
|
||||
FORMERR = 1 # Format Error [RFC 1035]
|
||||
SERVFAIL = 2 # Server Failure [RFC 1035]
|
||||
NXDOMAIN = 3 # Non-Existent Domain [RFC 1035]
|
||||
NOTIMP = 4 # Not Implemented [RFC 1035]
|
||||
REFUSED = 5 # Query Refused [RFC 1035]
|
||||
YXDOMAIN = 6 # Name Exists when it should not [RFC 2136]
|
||||
YXRRSET = 7 # RR Set Exists when it should not [RFC 2136]
|
||||
NXRRSET = 8 # RR Set that should exist does not [RFC 2136]
|
||||
NOTAUTH = 9 # Server Not Authoritative for zone [RFC 2136]
|
||||
NOTZONE = 10 # Name not contained in zone [RFC 2136]
|
||||
BADVERS = 16 # Bad OPT Version [RFC 2671]
|
||||
BADSIG = 16 # TSIG Signature Failure [RFC 2845]
|
||||
BADKEY = 17 # Key not recognized [RFC 2845]
|
||||
BADTIME = 18 # Signature out of time window [RFC 2845]
|
||||
BADMODE = 19 # Bad TKEY Mode [RFC 2930]
|
||||
BADNAME = 20 # Duplicate key name [RFC 2930]
|
||||
BADALG = 21 # Algorithm not supported [RFC 2930]
|
||||
|
||||
# Construct reverse mapping dictionary
|
||||
|
||||
_names = dir()
|
||||
statusmap = {}
|
||||
for _name in _names:
|
||||
if _name[0] != '_': statusmap[eval(_name)] = _name
|
||||
|
||||
def statusstr(status):
|
||||
if statusmap.has_key(status): return statusmap[status]
|
||||
else: return `status`
|
||||
|
||||
#
|
||||
# $Log: Status.py,v $
|
||||
# Revision 1.7 2002/04/23 12:52:19 anthonybaxter
|
||||
# cleanup whitespace.
|
||||
#
|
||||
# Revision 1.6 2002/04/23 10:57:57 anthonybaxter
|
||||
# update to complete the list of response codes.
|
||||
#
|
||||
# Revision 1.5 2002/03/19 12:41:33 anthonybaxter
|
||||
# tabnannied and reindented everything. 4 space indent, no tabs.
|
||||
# yay.
|
||||
#
|
||||
# Revision 1.4 2002/03/19 12:26:13 anthonybaxter
|
||||
# death to leading tabs.
|
||||
#
|
||||
# Revision 1.3 2001/08/09 09:08:55 anthonybaxter
|
||||
# added identifying header to top of each file
|
||||
#
|
||||
# Revision 1.2 2001/07/19 06:57:07 anthony
|
||||
# cvs keywords added
|
||||
#
|
||||
#
|
||||
76
lib/DNS/Type.py
Normal file
76
lib/DNS/Type.py
Normal file
@@ -0,0 +1,76 @@
|
||||
# -*- encoding: utf-8 -*-
|
||||
"""
|
||||
$Id: Type.py,v 1.6.2.1 2007/05/22 20:20:39 customdesigned Exp $
|
||||
|
||||
This file is part of the pydns project.
|
||||
Homepage: http://pydns.sourceforge.net
|
||||
|
||||
This code is covered by the standard Python License.
|
||||
|
||||
TYPE values (section 3.2.2)
|
||||
"""
|
||||
|
||||
A = 1 # a host address
|
||||
NS = 2 # an authoritative name server
|
||||
MD = 3 # a mail destination (Obsolete - use MX)
|
||||
MF = 4 # a mail forwarder (Obsolete - use MX)
|
||||
CNAME = 5 # the canonical name for an alias
|
||||
SOA = 6 # marks the start of a zone of authority
|
||||
MB = 7 # a mailbox domain name (EXPERIMENTAL)
|
||||
MG = 8 # a mail group member (EXPERIMENTAL)
|
||||
MR = 9 # a mail rename domain name (EXPERIMENTAL)
|
||||
NULL = 10 # a null RR (EXPERIMENTAL)
|
||||
WKS = 11 # a well known service description
|
||||
PTR = 12 # a domain name pointer
|
||||
HINFO = 13 # host information
|
||||
MINFO = 14 # mailbox or mail list information
|
||||
MX = 15 # mail exchange
|
||||
TXT = 16 # text strings
|
||||
AAAA = 28 # IPv6 AAAA records (RFC 1886)
|
||||
SRV = 33 # DNS RR for specifying the location of services (RFC 2782)
|
||||
|
||||
|
||||
# Additional TYPE values from host.c source
|
||||
|
||||
UNAME = 110
|
||||
MP = 240
|
||||
|
||||
# QTYPE values (section 3.2.3)
|
||||
|
||||
AXFR = 252 # A request for a transfer of an entire zone
|
||||
MAILB = 253 # A request for mailbox-related records (MB, MG or MR)
|
||||
MAILA = 254 # A request for mail agent RRs (Obsolete - see MX)
|
||||
ANY = 255 # A request for all records
|
||||
|
||||
# Construct reverse mapping dictionary
|
||||
|
||||
_names = dir()
|
||||
typemap = {}
|
||||
for _name in _names:
|
||||
if _name[0] != '_': typemap[eval(_name)] = _name
|
||||
|
||||
def typestr(type):
|
||||
if typemap.has_key(type): return typemap[type]
|
||||
else: return `type`
|
||||
#
|
||||
# $Log: Type.py,v $
|
||||
# Revision 1.6.2.1 2007/05/22 20:20:39 customdesigned
|
||||
# Mark utf-8 encoding
|
||||
#
|
||||
# Revision 1.6 2002/03/19 12:41:33 anthonybaxter
|
||||
# tabnannied and reindented everything. 4 space indent, no tabs.
|
||||
# yay.
|
||||
#
|
||||
# Revision 1.5 2002/03/19 12:26:13 anthonybaxter
|
||||
# death to leading tabs.
|
||||
#
|
||||
# Revision 1.4 2001/08/09 09:08:55 anthonybaxter
|
||||
# added identifying header to top of each file
|
||||
#
|
||||
# Revision 1.3 2001/07/19 07:38:28 anthony
|
||||
# added type code for SRV. From Michael Str�der.
|
||||
#
|
||||
# Revision 1.2 2001/07/19 06:57:07 anthony
|
||||
# cvs keywords added
|
||||
#
|
||||
#
|
||||
70
lib/DNS/__init__.py
Normal file
70
lib/DNS/__init__.py
Normal file
@@ -0,0 +1,70 @@
|
||||
# -*- encoding: utf-8 -*-
|
||||
# $Id: __init__.py,v 1.8.2.6 2008/08/01 04:01:25 customdesigned Exp $
|
||||
#
|
||||
# This file is part of the pydns project.
|
||||
# Homepage: http://pydns.sourceforge.net
|
||||
#
|
||||
# This code is covered by the standard Python License.
|
||||
#
|
||||
|
||||
# __init__.py for DNS class.
|
||||
|
||||
__version__ = '2.3.3'
|
||||
|
||||
import Type,Opcode,Status,Class
|
||||
from Base import DnsRequest, DNSError
|
||||
from Lib import DnsResult
|
||||
from Base import *
|
||||
from Lib import *
|
||||
Error=DNSError
|
||||
from lazy import *
|
||||
Request = DnsRequest
|
||||
Result = DnsResult
|
||||
|
||||
|
||||
#
|
||||
# $Log: __init__.py,v $
|
||||
# Revision 1.8.2.6 2008/08/01 04:01:25 customdesigned
|
||||
# Release 2.3.3
|
||||
#
|
||||
# Revision 1.8.2.5 2008/07/28 02:11:07 customdesigned
|
||||
# Bump version.
|
||||
#
|
||||
# Revision 1.8.2.4 2008/07/28 00:17:10 customdesigned
|
||||
# Randomize source ports.
|
||||
#
|
||||
# Revision 1.8.2.3 2008/07/24 20:10:55 customdesigned
|
||||
# Randomize tid in requests, and check in response.
|
||||
#
|
||||
# Revision 1.8.2.2 2007/05/22 21:06:52 customdesigned
|
||||
# utf-8 in __init__.py
|
||||
#
|
||||
# Revision 1.8.2.1 2007/05/22 20:39:20 customdesigned
|
||||
# Release 2.3.1
|
||||
#
|
||||
# Revision 1.8 2002/05/06 06:17:49 anthonybaxter
|
||||
# found that the old README file called itself release 2.2. So make
|
||||
# this one 2.3...
|
||||
#
|
||||
# Revision 1.7 2002/05/06 06:16:15 anthonybaxter
|
||||
# make some sort of reasonable version string. releasewards ho!
|
||||
#
|
||||
# Revision 1.6 2002/03/19 13:05:02 anthonybaxter
|
||||
# converted to class based exceptions (there goes the python1.4 compatibility :)
|
||||
#
|
||||
# removed a quite gross use of 'eval()'.
|
||||
#
|
||||
# Revision 1.5 2002/03/19 12:41:33 anthonybaxter
|
||||
# tabnannied and reindented everything. 4 space indent, no tabs.
|
||||
# yay.
|
||||
#
|
||||
# Revision 1.4 2001/11/26 17:57:51 stroeder
|
||||
# Added __version__
|
||||
#
|
||||
# Revision 1.3 2001/08/09 09:08:55 anthonybaxter
|
||||
# added identifying header to top of each file
|
||||
#
|
||||
# Revision 1.2 2001/07/19 06:57:07 anthony
|
||||
# cvs keywords added
|
||||
#
|
||||
#
|
||||
51
lib/DNS/lazy.py
Normal file
51
lib/DNS/lazy.py
Normal file
@@ -0,0 +1,51 @@
|
||||
# $Id: lazy.py,v 1.5.2.1 2007/05/22 20:23:38 customdesigned Exp $
|
||||
#
|
||||
# This file is part of the pydns project.
|
||||
# Homepage: http://pydns.sourceforge.net
|
||||
#
|
||||
# This code is covered by the standard Python License.
|
||||
#
|
||||
|
||||
# routines for lazy people.
|
||||
import Base
|
||||
import string
|
||||
|
||||
def revlookup(name):
|
||||
"convenience routine for doing a reverse lookup of an address"
|
||||
if Base.defaults['server'] == []: Base.DiscoverNameServers()
|
||||
a = string.split(name, '.')
|
||||
a.reverse()
|
||||
b = string.join(a, '.')+'.in-addr.arpa'
|
||||
# this will only return one of any records returned.
|
||||
return Base.DnsRequest(b, qtype = 'ptr').req().answers[0]['data']
|
||||
|
||||
def mxlookup(name):
|
||||
"""
|
||||
convenience routine for doing an MX lookup of a name. returns a
|
||||
sorted list of (preference, mail exchanger) records
|
||||
"""
|
||||
if Base.defaults['server'] == []: Base.DiscoverNameServers()
|
||||
a = Base.DnsRequest(name, qtype = 'mx').req().answers
|
||||
l = map(lambda x:x['data'], a)
|
||||
l.sort()
|
||||
return l
|
||||
|
||||
#
|
||||
# $Log: lazy.py,v $
|
||||
# Revision 1.5.2.1 2007/05/22 20:23:38 customdesigned
|
||||
# Lazy call to DiscoverNameServers
|
||||
#
|
||||
# Revision 1.5 2002/05/06 06:14:38 anthonybaxter
|
||||
# reformat, move import to top of file.
|
||||
#
|
||||
# Revision 1.4 2002/03/19 12:41:33 anthonybaxter
|
||||
# tabnannied and reindented everything. 4 space indent, no tabs.
|
||||
# yay.
|
||||
#
|
||||
# Revision 1.3 2001/08/09 09:08:55 anthonybaxter
|
||||
# added identifying header to top of each file
|
||||
#
|
||||
# Revision 1.2 2001/07/19 06:57:07 anthony
|
||||
# cvs keywords added
|
||||
#
|
||||
#
|
||||
Reference in New Issue
Block a user