+++ /dev/null
-#!/usr/bin/python
-# Python Domain Name Server
-# Copyright (C) 2002 Digital Lumber, Inc.
-
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-import socket
-import asyncore
-import asynchat
-import select
-import types
-import random
-import time
-import signal
-import string
-import sys
-import sipb_xen_database
-from errno import EALREADY, EINPROGRESS, EWOULDBLOCK, ECONNRESET, \
- ENOTCONN, ESHUTDOWN, EINTR, EISCONN, ETIMEDOUT
-
-# EXAMPLE ZONE FILE DATA STRUCTURE
-
-# NOTE:
-# There are no trailing dots in the internal data
-# structure. Although it's hard to tell by reading
-# the RFC's, the dots on the end of names are just
-# used internally by the resolvers and servers to
-# see if they need to append a domain name onto
-# the end of names. There are no trailing dots
-# on names in queries on the network.
-
-examplenet = {'example.net':{'SOA':[{'class':'IN',
- 'ttl':10,
- 'mname':'ns1.example.net',
- 'rname':'hostmaster.example.net',
- 'serial':1,
- 'refresh':10800,
- 'retry':3600,
- 'expire':604800,
- 'minimum':3600}],
- 'NS':[{'class':'IN',
- 'ttl':10,
- 'nsdname':'ns1.example.net'},
- {'ttl':10,
- 'nsdname':'ns2.example.net'}],
- 'MX':[{'class':'IN',
- 'ttl':10,
- 'preference':10,
- 'exchange':'mail.example.net'}]},
- 'server1.example.net':{'A':[{'class':'IN',
- 'ttl':10,
- 'address':'10.1.2.3'}]},
- 'www.example.net':{'CNAME':[{'class':'IN',
- 'ttl':10,
- 'cname':'server1.example.net'}]},
- 'router.example.net':{'A':[{'class':'IN',
- 'ttl':10,
- 'address':'10.1.2.1'},
- {'class':'IN',
- 'ttl':10,
- 'address':'10.2.1.1'}]}
-
- }
-
-# setup logging defaults
-loglevel = 0
-logfile = sys.stdout
-
-try:
- file
-except NameError:
- def file(name, mode='r', buffer=0):
- return open(name, mode, buffer)
-
-def log(level,msg):
- if level <= loglevel:
- logfile.write(msg+'\n')
-
-def timestamp():
- return time.strftime('%m/%d/%y %H:%M:%S')+ '-'
-
-def inttoasc(number):
- try:
- hs = hex(number)[2:]
- except:
- log(0,'inttoasc cannot convert ' + repr(number))
- if hs[-1:].upper() == 'L':
- hs = hs[:-1]
- result = ''
- while len(hs) > 2:
- result = chr(int(hs[-2:],16)) + result
- hs = hs[:-2]
- result = chr(int(hs,16)) + result
-
- return result
-
-def asctoint(ascnum):
- rascnum = ''
- for i in range(len(ascnum)-1,-1,-1):
- rascnum = rascnum + ascnum[i]
- result = 0
- count = 0
- for c in rascnum:
- x = ord(c) << (8*count)
- result = result + x
- count = count + 1
-
- return result
-
-def ipv6net_aton(ip_string):
- packed_ip = ''
- # first account for shorthand syntax
- pieces = ip_string.split(':')
- pcount = 0
- for part in pieces:
- if part != '':
- pcount = pcount + 1
- if pcount < 8:
- rs = '0:'*(8-pcount)
- ip_string = ip_string.replace('::',':'+rs)
- if ip_string[0] == ':':
- ip_string = ip_string[1:]
- pieces = ip_string.split(':')
- for part in pieces:
- # pad with the zeros
- i = 4-len(part)
- part = i*'0'+part
- packed_ip = packed_ip + chr(int(part[:2],16))+ chr(int(part[2:],16))
- return packed_ip
-
-def ipv6net_ntoa(packed_ip):
- ip_string = ''
- count = 0
- for c in packed_ip:
- ip_string = ip_string + hex(ord(c))[2:]
- count = count + 1
- if count == 2:
- ip_string = ip_string + ':'
- count = 0
- return ip_string[:-1]
-
-def getversion(qname, id, rd, ra, versionstr):
- msg = message()
- msg.header.id = id
- msg.header.qr = 1
- msg.header.aa = 1
- msg.header.rd = rd
- msg.header.ra = ra
- msg.header.rcode = 0
- msg.question.qname = qname
- msg.question.qtype = 'TXT'
- msg.question.qclass = 'CH'
- if qname == 'version.bind':
- msg.header.ancount = 2
- msg.answerlist.append({qname:{'CNAME':[{'cname':'version.oak',
- 'ttl':360000,
- 'class':'CH'}]}})
- msg.answerlist.append({'version.oak':{'TXT':[{'txtdata':versionstr,
- 'ttl':360000,
- 'class':'CH'}]}})
- else:
- msg.header.ancount = 1
- msg.answerlist.append({qname:{'TXT':[{'txtdata':versionstr,
- 'ttl':360000,
- 'class':'CH'}]}})
- return msg
-
-def getrcode(rcode):
- if rcode == 0:
- rcodestr = 'NOERROR(No error condition)'
- elif rcode == 1:
- rcodestr = 'FORMERR(Format Error)'
- elif rcode == 2:
- rcodestr = 'SERVFAIL(Internal failure)'
- elif rcode == 3:
- rcodestr = 'NXDOMAIN(Name does not exist)'
- elif rcode == 4:
- rcodestr = 'NOTIMP(Not Implemented)'
- elif rcode == 5:
- rcodestr = 'REFUSED(Security violation)'
- elif rcode == 6:
- rcodestr = 'YXDOMAIN(Name exists)'
- elif rcode == 7:
- rcodestr = 'YXRRSET(RR exists)'
- elif rcode == 8:
- rcodestr = 'NXRRSET(RR does not exist)'
- elif rcode == 9:
- rcodestr = 'NOTAUTH(Server not Authoritative)'
- elif rcode == 10:
- rcodestr = 'NOTZONE(Name not in zone)'
- else:
- rcodestr = 'Unknown RCODE(' + str(rcode) + ')'
- return rcodestr
-
-def printrdata(dnstype, rdata):
- if dnstype == 'A':
- return rdata['address']
- elif dnstype == 'MX':
- return str(rdata['preference'])+'\t'+rdata['exchange']+'.'
- elif dnstype == 'NS':
- return rdata['nsdname']+'.'
- elif dnstype == 'PTR':
- return rdata['ptrdname']+'.'
- elif dnstype == 'CNAME':
- return rdata['cname']+'.'
- elif dnstype == 'SOA':
- return (rdata['mname']+'.\t'+rdata['rname']+'. (\n'+35*' '+str(rdata['serial'])+'\n'+
- 35*' '+str(rdata['refresh'])+'\n'+35*' '+str(rdata['retry'])+'\n'+35*' '+
- str(rdata['expire'])+'\n'+35*' '+str(rdata['minimum'])+' )')
-
-def makezonedatalist(zonedata, origin):
- # unravel structure into list
- zonedatalist = []
- # get soa first
- soanode = zonedata[origin]
- zonedatalist.append([origin+'.','SOA',soanode['SOA'][0]])
- for item in soanode.keys():
- if item != 'SOA':
- for listitem in soanode[item]:
- zonedatalist.append([origin+'.', item, listitem])
- for nodename in zonedata.keys():
- if nodename != origin:
- for item in zonedata[nodename].keys():
- for listitem in zonedata[nodename][item]:
- zonedatalist.append([nodename+'.', item, listitem])
- return zonedatalist
-
-def writezonefile(zonedata, origin, file):
- zonedatalist = makezonedatalist(zonedata, origin)
- for rr in zonedatalist:
- owner = rr[0]
- dnstype = rr[1]
- line = (owner + (35-len(owner))*' ' + str(rr[2]['ttl']) + '\t\tIN\t' +
- dnstype + '\t' + printrdata(dnstype, rr[2]))
- file.write(line + '\n')
-
-def readzonefiles(zonedict):
- for k in zonedict.keys():
- filepath = zonedict[k]['filename']
- try:
- pr = zonefileparser()
- pr.parse(zonedict[k]['origin'],filepath)
- zonedict[k]['zonedata'] = pr.getzdict()
- except ZonefileError, lineno:
- log(0,'Error reading zone file ' + filepath + ' at line ' +
- str(lineno) + '\n')
- del zonedict[k]
-
-def slowloop(tofunc='',timeout=5.0):
- if not tofunc:
- def tofunc(): return
- map = asyncore.socket_map
- while map:
- r = []; w=[]; e=[]
- for fd, obj in map.items():
- if obj.readable():
- r.append(fd)
- if obj.writable():
- w.append(fd)
- try:
- starttime = time.time()
- r,w,e = select.select(r,w,e,timeout)
- endtime = time.time()
- if endtime-starttime >= timeout:
- tofunc()
- except select.error, err:
- if err[0] != EINTR:
- raise
- r=[]; w=[]; e=[]
- log(0,'ERROR in select')
-
- for fd in r:
- try:
- obj=map[fd]
- except KeyError:
- log(0,'KeyError in socket map')
- continue
- try:
- obj.handle_read_event()
- except:
- log(0,'calling HANDLE ERROR from loop')
- log(0,repr(obj))
- obj.handle_error()
- for fd in w:
- try:
- obj=map[fd]
- except KeyError:
- log(0,'KeyError in socket map')
- continue
- try:
- obj.handle_read_event()
- except:
- log(0,'calling HANDLE ERROR from loop')
- log(0,repr(obj))
- obj.handle_error()
-
-def fastloop(tofunc='',timeout=5.0):
- if not tofunc:
- def tofunc(): return
- polltimeout = timeout*1000
- map = asyncore.socket_map
- while map:
- regfds = 0
- pollobj = select.poll()
- for fd, obj in map.items():
- flags = 0
- if obj.readable():
- flags = select.POLLIN
- if obj.writable():
- flags = flags | select.POLLOUT
- if flags:
- pollobj.register(fd, flags)
- regfds = regfds + 1
- try:
- starttime = time.time()
- r = pollobj.poll(polltimeout)
- endtime = time.time()
- if endtime-starttime >= timeout:
- tofunc()
- except select.error, err:
- if err[0] != EINTR:
- raise
- r = []
- log(0,'ERROR in select')
- for fd, flags in r:
- try:
- obj = map[fd]
- badvals = (select.POLLPRI + select.POLLERR +
- select.POLLHUP + select.POLLNVAL)
- if (flags & badvals):
- if (flags & select.POLLPRI):
- log(0,'POLLPRI')
- if (flags & select.POLLERR):
- log(0,'POLLERR')
- if (flags & select.POLLHUP):
- log(0,'POLLHUP')
- if (flags & select.POLLNVAL):
- log(0,'POLLNVAL')
- obj.handle_error()
- else:
- if (flags & select.POLLIN):
- obj.handle_read_event()
- if (flags & select.POLLOUT):
- obj.handle_write_event()
- except KeyError:
- log(0,'KeyError in socket map')
- continue
- except:
- # print traceback
- sf = StringIO.StringIO()
- traceback.print_exc(file=sf)
- log(0,'ERROR IN LOOP:')
- log(0,sf.getvalue())
- sf.close()
- log(0,repr(obj))
- obj.handle_error()
-
-if hasattr(select,'poll'):
- loop = fastloop
-else:
- loop = slowloop
-
-class ZonefileError(Exception):
- def __init__(self, linenum, errordesc=''):
- self.linenum = linenum
- self.errordesc = errordesc
- def __str__(self):
- return str(self.linenum) + ' (' + self.errordesc + ')'
-
-class zonefileparser:
- def __init__(self):
- self.zonedata = {}
- self.dnstypes = ['A','AAAA','CNAME','HINFO','LOC','MX',
- 'NS','PTR','RP','SOA','SRV','TXT']
-
- def stripcomments(self, line):
- i = line.find(';')
- if i >= 0:
- line = line[:i]
- return line
-
- def strip(self, line):
- # strip trailing linefeeds
- if line[-1:] == '\n':
- line = line[:-1]
- return line
-
- def getzdict(self):
- return self.zonedata
-
- def addorigin(self, origin, name):
- if name[-1:] != '.':
- return name + '.' + origin
- else:
- return name[:-1]
-
- def getstrings(self, s):
- if s.find('"') == -1:
- return s.split()
- else:
- x = s.split('"')
- rlist = []
- for i in x:
- if i != '' and i != ' ':
- rlist.append(i)
- return rlist
-
- def getlocsize(self, s):
- if s[-1:] == 'm':
- size = float(s[:-1])*100
- else:
- size = float(s)*100
- i = 0
- while size > 9:
- size = size/10
- i = i + 1
- return (int(size),i)
-
- def getloclat(self, l,c):
- deg = float(l[0])
- min = 0
- secs = 0
- if len(l) == 3:
- min = float(l[1])
- secs = float(l[2])
- elif len(l) == 2:
- min = float(l[1])
- rval = ((((deg *60) + min) * 60) + secs) * 1000
- if c in ['N','E']:
- rval = rval + (2**31)
- elif c in ['S','W']:
- rval = (2**31) - rval
- else:
- log(0,'ERROR: unsupported latitude/longitude direction')
- return long(rval)
-
- def getgname(self, name, iter):
- if name == '0' or name == 'O':
- return ''
- start = 0
- offset = 0
- width = 0
- base = 'd'
- for x in range(name.count('$')):
- i = name.find('$',start)
- j = i
- start = i+1
- if i>0:
- if name[i-1] == '\\':
- continue
- if len(name)>i+1:
- if name[i+1] == '$':
- continue
- if name[i+1] == '{':
- j = name.find('}',i+1)
- owb = name[i+2:j].split(',')
- if len(owb) == 1:
- offset = int(owb[0])
- elif len(owb) == 2:
- offset = int(owb[0])
- width = int(owb[1])
- elif len(owb) == 3:
- offset = int(owb[0])
- width = int(owb[1])
- base = owb[2]
- val = iter - offset
- if base == 'd':
- rs = str(val)
- elif base == 'o':
- rs = oct(val)
- elif base == 'x':
- rs = hex(val)[2:].lower()
- elif base == 'X':
- rs = hex(val)[2:].upper()
- else:
- rs = ''
- if len(rs) > width:
- rs = (width-len(rs))*'0'+rs
- name = name[:i]+rs+name[j+1:]
- start = i+len(rs)+1
-
- return name
-
- def getrrdata(self, origin, dnstype, dnsclass, ttl, tokens):
- rdata = {}
- rdata['class'] = dnsclass
- rdata['ttl'] = ttl
- if dnstype == 'A':
- rdata['address'] = tokens[0]
- elif dnstype == 'AAAA':
- rdata['address'] = tokens[0]
- elif dnstype == 'CNAME':
- rdata['cname'] = self.addorigin(origin,tokens[0].lower())
- elif dnstype == 'HINFO':
- sl = self.getstrings(' '.join(tokens))
- rdata['cpu'] = sl[0]
- rdata['os'] = sl[1]
- elif dnstype == 'LOC':
- if 'N' in tokens:
- i = tokens.index('N')
- else:
- i = tokens.index('S')
- lat = self.getloclat(tokens[0:i],tokens[i])
- if 'E' in tokens:
- j = tokens.index('E')
- else:
- j = tokens.index('W')
- lng = self.getloclat(tokens[i+1:j],tokens[j])
- size = self.getlocsize('1m')
- horiz_pre = self.getlocsize('1000m')
- vert_pre = self.getlocsize('10m')
- if len(tokens[j+1:]) == 2:
- size = self.getlocsize(tokens[-1:][0])
- elif len(tokens[j+1:]) == 3:
- size = self.getlocsize(tokens[-2:-1][0])
- horiz_pre = self.getlocsize(tokens[-1:][0])
- elif len(tokens[j+1:]) == 4:
- size = self.getlocsize(tokens[-3:-2][0])
- horiz_pre = self.getlocsize(tokens[-2:-1][0])
- vert_pre = self.getlocsize(tokens[-1:][0])
- if tokens[j+1][-1:] == 'm':
- alt = int((float(tokens[j+1][:-1])*100)+10000000)
- else:
- size = int((float(tokens[j+1])*100)+10000000)
- rdata['version'] = 0
- rdata['size'] = size
- rdata['horiz_pre'] = horiz_pre
- rdata['vert_pre'] = vert_pre
- rdata['latitude'] = lat
- rdata['longitude'] = lng
- rdata['altitude'] = 0
- elif dnstype == 'MX':
- rdata['preference'] = int(tokens[0])
- rdata['exchange'] = self.addorigin(origin,tokens[1].lower())
- elif dnstype == 'NS':
- rdata['nsdname'] = self.addorigin(origin,tokens[0].lower())
- elif dnstype == 'PTR':
- rdata['ptrdname'] = self.addorigin(origin,tokens[0].lower())
- elif dnstype == 'RP':
- rdata['mboxdname'] = self.addorigin(origin,tokens[0].lower())
- rdata['txtdname'] = self.addorigin(origin,tokens[1].lower())
- elif dnstype == 'SOA':
- rdata['mname'] = self.addorigin(origin,tokens[0].lower())
- rdata['rname'] = self.addorigin(origin,tokens[1].lower())
- rdata['serial'] = int(tokens[2])
- rdata['refresh'] = int(tokens[3])
- rdata['retry'] = int(tokens[4])
- rdata['expire'] = int(tokens[5])
- rdata['minimum'] = int(tokens[6])
- elif dnstype == 'SRV':
- rdata['priority'] = int(tokens[0])
- rdata['weight'] = int(tokens[1])
- rdata['port'] = int(tokens[2])
- rdata['target'] = self.addorigin(origin,tokens[3].lower())
- elif dnstype == 'TXT':
- rdata['txtdata'] = self.getstrings(' '.join(tokens))[0]
- else:
- raise ZonefileError(lineno,'bad DNS type')
- return rdata
-
- def addrec(self, owner, dnstype, rrdata):
- if self.zonedata.has_key(owner):
- if not self.zonedata[owner].has_key(dnstype):
- self.zonedata[owner][dnstype] = []
- else:
- self.zonedata[owner] = {}
- self.zonedata[owner][dnstype] = []
- self.zonedata[owner][dnstype].append(rrdata)
-
- def parse(self, origin, f):
- closefile = 0
- if type(f) != types.FileType:
- # must be a path
- try:
- f = file(f)
- closefile = 1
- except:
- log(0,'Invalid path to zonefile')
- return
- lastowner = ''
- lastdnsclass = ''
- lastttl = 3600
- lineno = 0
- while 1:
- line = f.readline()
- if not line:
- break
- lineno = lineno + 1
- line = self.stripcomments(line)
- line = self.strip(line)
- if not line:
- continue
- if line.find('(') >= 0:
- # grab lines until end paren
- if line.find(')') == -1:
- line2 = self.stripcomments(f.readline())
- lineno = lineno + 1
- line2 = self.strip(line2)
- line = line + line2
- while line2.find(')') == -1:
- line2 = self.strip(self.stripcomments(f.readline()))
- lineno = lineno + 1
- line = line + line2
- # now strip the parenthesis
- line = line.replace(')','')
- line = line.replace('(','')
- # now line equals the entire RR entry
- tokens = line.split()
- if tokens[0].upper() == '$ORIGIN':
- try:
- origin = tokens[1].lower()
- except:
- raise ZonefileError(lineno, 'bad origin')
- elif tokens[0].upper() == '$INCLUDE':
- try:
- f2 = file(tokens[1].lower())
- if len(tokens) > 2:
- self.parse(tokens[2].lower(), f2)
- else:
- self.parse(origin, f2)
- f2.close()
- except:
- raise ZonefileError(lineno, 'bad INCLUDE directive')
- elif tokens[0].upper() == '$TTL':
- try:
- lastttl = int(tokens[1])
- except:
- raise ZonefileError(lineno, 'bad TTL directive')
- elif tokens[0].upper() == '$GENERATE':
- try:
- lhs = tokens[2].lower()
- dnstype = tokens[3].upper()
- rhs = tokens[4].lower()
- rng = tokens[1].split('-')
- start = int(rng[0])
- i = rng[1].find('/')
- if i != -1:
- stop = int(rng[1][:i])+1
- step = int(rng[1][i+1:])
- else:
- stop = int(rng[1])+1
- step = 1
- for i in range(start,stop,step):
- grhs = self.getgname(rhs,i)
- if dnstype in ['NS','CNAME','PTR']:
- grhs = self.addorigin(origin,grhs)
- rrdata = self.getrrdata(origin, dnstype, 'IN', lastttl,
- [grhs])
- glhs = self.addorigin(origin,self.getgname(lhs,i))
- self.addrec(glhs,dnstype, rrdata)
- except KeyError:
- raise ZonefileError(lineno, 'bad GENERATE directive')
- else:
- try:
- # if line begins with blank then owner is last owner
- if line[0] in string.whitespace:
- owner = lastowner
- else:
- owner = tokens[0].lower()
- tokens = tokens[1:]
- if owner == '@':
- owner = origin
- elif owner[-1:] != '.':
- owner = owner + '.' + origin
- else:
- owner = owner[:-1] # strip off trailing dot
- # line format is either: [class] [ttl] type RDATA
- # or [ttl] [class] type RDATA
- # - items in brackets are optional
- #
- # need to figure out which token is type
- # and backfill the missing data
- count = 0
- for token in tokens:
- if token.upper() in self.dnstypes:
- break
- count = count + 1
- # the following strips off the ttl and class if they exist
- if count == 0:
- ttl = lastttl
- dnsclass = lastdnsclass
- elif count == 1:
- if tokens[0].isdigit():
- ttl = int(tokens[0])
- dnsclass = lastdnsclass
- else:
- ttl = lastttl
- dnsclass = tokens[0].upper()
- tokens = tokens[1:]
- elif count == 2:
- if tokens[0].isdigit():
- ttl = int(tokens[0])
- dnsclass = tokens[1].upper()
- else:
- ttl = int(tokens[1])
- dnsclass = tokens[0].upper()
- tokens = tokens[2:]
- else:
- raise ZonefileError(lineno,'bad ttl or class')
- dnstype = tokens[0]
- # make sure all of the structure is there
- rrdata = self.getrrdata(origin, dnstype, dnsclass,
- ttl, tokens[1:])
- self.addrec(owner, dnstype, rrdata)
- lastowner = owner
- lastttl = ttl
- lastdnsclass = dnsclass
- except:
- raise ZonefileError(lineno,'unable to parse line')
- if closefile:
- f.close()
-
-class dnsconfig:
- def __init__(self):
- # self.zonedb = zonedb({})
- self.cached = {}
- self.loglevel = 0
-
- def getview(self, msg, address, port):
- # return:
- # 1. a list of zone keys
- # 2. whether or not to use the resolver
- # (i.e. answer recursive queries)
- # 3. a list of forwarder addresses
- return ['servers.csail.mit.edu'], 1, []
-
- def allowupdate(self, msg, address, port):
- # return 1 if updates are allowed
- # NOTE: can only update the zones
- # returned by the getview func
- return 1
-
- def outpackets(self, packetlist):
- # modify outgoing packets
- return packetlist
-
-class dnsheader:
- def __init__(self, id=1):
- self.id = id # 16bit identifier generated by queryer
- self.qr = 0 # one bit field specifying query(0) or response(1)
- self.opcode = 0 # 4bit field specifying type of query
- self.aa = 0 # authoritative answer
- self.tc = 0 # message is not truncated
- self.rd = 1 # recursion desired
- self.ra = 0 # recursion available?
- self.z = 0 # reserved for future use
- self.rcode = 0 # response code (set in response)
- self.qdcount = 1 # number of questions, only 1 is supported
- self.ancount = 0 # number of rrs in the answer section
- self.nscount = 0 # number of name server rrs in authority section
- self.arcount = 0 # number or rrs in the additional section
-
-class dnsquestion:
- def __init__(self):
- self.qname = 'localhost'
- self.qtype = 'A'
- self.qclass = 'IN'
-
-class dnsupdatezone:
- pass
-
-class message:
- def __init__(self, msgdata=''):
- if msgdata:
- self.header = dnsheader()
- else:
- self.header = dnsheader(id=random.randrange(1,32768))
- self.question = dnsquestion()
- self.answerlist = []
- self.authlist = []
- self.addlist = []
- self.u = ''
- self.qtypes = {1:'A',2:'NS',3:'MD',4:'MF',5:'CNAME',6:'SOA',
- 7:'MB',8:'MG',9:'MR',10:'NULL',11:'WKS',
- 12:'PTR',13:'HINFO',14:'MINFO',15:'MX',
- 16:'TXT',17:'RP',28:'AAAA',29:'LOC',33:'SRV',
- 38:'A6',39:'DNAME',251:'IXFR',252:'AXFR',
- 253:'MAILB',254:'MAILA',255:'ANY'}
- self.rqtypes = {}
- for key in self.qtypes.keys():
- self.rqtypes[self.qtypes[key]] = key
- self.qclasses = {1:'IN',2:'CS',3:'CH',4:'HS',254:'NONE',255:'ANY'}
- self.rqclasses = {}
- for key in self.qclasses.keys():
- self.rqclasses[self.qclasses[key]] = key
-
- if msgdata:
- self.processpkt(msgdata)
-
- def getdomainname(self, data, i):
- log(4,'IN GETDOMAINNAME')
- domainname = ''
- gotpointer = 0
- labellength= ord(data[i])
- log(4,'labellength:' + str(labellength))
- i = i + 1
- while labellength != 0:
- while labellength >= 192:
- # pointer
- if not gotpointer:
- rindex = i + 1
- gotpointer = 1
- log(4,'got pointer')
- i = asctoint(chr(ord(data[i-1]) & 63)+data[i])
- log(4,'new index:'+str(i))
- labellength = ord(data[i])
- log(4,'labellength:' + str(labellength))
- i = i + 1
- if domainname:
- domainname = domainname + '.' + data[i:i+labellength]
- else:
- domainname = data[i:i+labellength]
- log(4,'domainname:'+domainname)
- i = i + labellength
- labellength = ord(data[i])
- log(4,'labellength:' + str(labellength))
- i = i + 1
- if not gotpointer:
- rindex = i
-
- return domainname.lower(), rindex
-
- def getrrdata(self, type, msgdata, rdlength, i):
- log(4,'unpacking RR data')
- rdata = msgdata[i:i+rdlength]
- if type == 'A':
- return {'address':socket.inet_ntoa(rdata)}
- elif type == 'AAAA':
- return {'address':ipv6net_ntoa(rdata)}
- elif type == 'CNAME':
- cname, i = self.getdomainname(msgdata,i)
- return {'cname':cname}
- elif type == 'HINFO':
- cpulen = ord(rdata[0])
- cpu = rdata[1:cpulen+1]
- return {'cpu':cpu,
- 'os':rdata[cpulen+2:]}
- elif type == 'LOC':
- return {'version':ord(rdata[0]),
- 'size':self.locsize(rdata[1]),
- 'horiz_pre':self.locsize(rdata[2]),
- 'vert_pre':self.locsize(rdata[3]),
- 'latitude':asctoint(rdata[4:8]),
- 'longitude':asctoint(rdata[8:12]),
- 'altitude':asctoint(rdata[12:16])}
- elif type == 'MX':
- exchange, i = self.getdomainname(msgdata,i+2)
- return {'preference':asctoint(rdata[:2]),
- 'exchange':exchange}
- elif type == 'NS':
- nsdname, i = self.getdomainname(msgdata,i)
- return {'nsdname':nsdname}
- elif type == 'PTR':
- ptrdname, i = self.getdomainname(msgdata,i)
- return {'ptrdname':ptrdname}
- elif type == 'RP':
- mboxdname, i = self.getdomainname(msgdata,i)
- txtdname, i = self.getdomainname(msgdata,i)
- return {'mboxdname':mboxdname,
- 'txtdname':txtdname}
- elif type == 'SOA':
- mname, i = self.getdomainname(msgdata,i)
- rname, i = self.getdomainname(msgdata,i)
- return {'mname':mname,
- 'rname':rname,
- 'serial':asctoint(msgdata[i:i+4]),
- 'refresh':asctoint(msgdata[i+4:i+8]),
- 'retry':asctoint(msgdata[i+8:i+12]),
- 'expire':asctoint(msgdata[i+12:i+16]),
- 'minimum':asctoint(msgdata[i+16:i+20])}
- elif type == 'SRV':
- target, i = self.getdomainname(msgdata,i+6)
- return {'priority':asctoint(rdata[0:2]),
- 'weight':asctoint(rdata[2:4]),
- 'port':asctoint(rdata[4:6]),
- 'target':target}
- elif type == 'TXT':
- return {'txtdata':rdata[1:]}
- else:
- return {'rdata':rdata}
-
- def getrr(self, data, i):
- log(4,'unpacking RR name')
- name, i = self.getdomainname(data, i)
- type = asctoint(data[i:i+2])
- type = self.qtypes.get(type,chr(type))
- klass = asctoint(data[i+2:i+4])
- klass = self.qclasses.get(klass,chr(klass))
- ttl = asctoint(data[i+4:i+8])
- rdlength = asctoint(data[i+8:i+10])
- rrdata = self.getrrdata(type,data,rdlength,i+10)
- rrdata['ttl'] = ttl
- rrdata['class'] = klass
- rr = {name:{type:[rrdata]}}
- return rr, i+10+rdlength
-
- def processpkt(self, msgdata):
- self.header.id = asctoint(msgdata[:2])
- self.header.qr = ord(msgdata[2]) >> 7
- self.header.opcode = (ord(msgdata[2]) & 127) >> 3
- if self.header.opcode == 5:
- # UPDATE packet
- log(4,'processing UPDATE packet')
- del self.header.aa
- del self.header.tc
- del self.header.rd
- del self.header.ra
- del self.header.qdcount
- del self.header.ancount
- del self.header.nscount
- del self.header.arcount
- del self.question
- self.zone = dnsupdatezone()
- del self.answerlist
- del self.authlist
- del self.addlist
- self.header.z = 0
- self.header.rcode = ord(msgdata[3]) & 15
- self.header.zocount = asctoint(msgdata[4:6])
- self.header.prcount = asctoint(msgdata[6:8])
- self.header.upcount = asctoint(msgdata[8:10])
- self.header.arcount = asctoint(msgdata[10:12])
- self.zolist = []
- self.prlist = []
- self.uplist = []
- self.addlist = []
- i = 12
- for x in range(self.header.zocount):
- (dn, i) = self.getdomainname(msgdata,i)
- self.zone.zname = dn
- type = asctoint(msgdata[i:i+2])
- self.zone.ztype = self.qtypes.get(type,chr(type))
- klass = asctoint(msgdata[i+2:i+4])
- self.zone.zclass = self.qclasses.get(klass,chr(klass))
- i = i + 4
- for x in range(self.header.prcount):
- rr, i = self.getrr(msgdata,i)
- self.prlist.append(rr)
- for x in range(self.header.upcount):
- rr, i = self.getrr(msgdata,i)
- self.uplist.append(rr)
- for x in range(self.header.arcount):
- rr, i = self.getrr(msgdata,i)
- self.adlist.append(rr)
- else:
- self.header.aa = (ord(msgdata[2]) & 4) >> 2
- self.header.tc = (ord(msgdata[2]) & 2) >> 1
- self.header.rd = ord(msgdata[2]) & 1
- self.header.ra = ord(msgdata[3]) >> 7
- self.header.z = (ord(msgdata[3]) & 112) >> 4
- self.header.rcode = ord(msgdata[3]) & 15
- self.header.qdcount = asctoint(msgdata[4:6])
- self.header.ancount = asctoint(msgdata[6:8])
- self.header.nscount = asctoint(msgdata[8:10])
- self.header.arcount = asctoint(msgdata[10:12])
- i = 12
- for x in range(self.header.qdcount):
- log(4,'unpacking question')
- (dn, i) = self.getdomainname(msgdata,i)
- self.question.qname = dn
- rrtype = asctoint(msgdata[i:i+2])
- self.question.qtype = self.qtypes.get(rrtype,chr(rrtype))
- klass = asctoint(msgdata[i+2:i+4])
- self.question.qclass = self.qclasses.get(klass,chr(klass))
- i = i + 4
- for x in range(self.header.ancount):
- log(4,'unpacking answer RR')
- rr, i = self.getrr(msgdata,i)
- self.answerlist.append(rr)
- for x in range(self.header.nscount):
- log(4,'unpacking auth RR')
- rr, i = self.getrr(msgdata,i)
- self.authlist.append(rr)
- for x in range(self.header.arcount):
- log(4,'unpacking additional RR')
- rr, i = self.getrr(msgdata,i)
- self.addlist.append(rr)
- return
-
- def pds(self, s, l):
- # pad string with chr(0)'s so that
- # return string length is l
- x = l - len(s)
- return x*chr(0) + s
-
- def locsize(self, s):
- x1 = ord(s) >> 4
- x2 = ord(s) & 15
- return (x1, x2)
-
- def packlocsize(self, x):
- return chr((x[0] << 4) + x[1])
-
- def packdomainname(self, name, i, msgcomp):
- log(4,'packing domainname: ' + name)
- if name == '':
- return chr(0)
- if name in msgcomp.keys():
- log(4,'using pointer for: ' + name)
- return msgcomp[name]
- packedname = ''
- tokens = name.split('.')
- for j in range(len(tokens)):
- packedname = packedname + chr(len(tokens[j])) + tokens[j]
- nameleft = '.'.join(tokens[j+1:])
- if nameleft in msgcomp.keys():
- log(4,'using pointer for: ' + nameleft)
- return packedname+msgcomp[nameleft]
- # haven't used a pointer so put this in the dictionary
- pointer = inttoasc(i)
- if len(pointer) == 1:
- msgcomp[name] = chr(192)+pointer
- else:
- msgcomp[name] = chr(192|ord(pointer[0])) + pointer[1]
- log(4,'added pointer for ' + name + '(' + str(i) + ')')
- return packedname + chr(0)
-
- def packrr(self, rr, i, msgcomp):
- rrname = rr.keys()[0]
- rrtype = rr[rrname].keys()[0]
- if self.rqtypes.has_key(rrtype):
- typeval = self.rqtypes[rrtype]
- else:
- typeval = ord(rrtype)
- dbrec = rr[rrname][rrtype][0]
- ttl = dbrec['ttl']
- rclass = self.rqclasses[dbrec['class']]
- packedrr = (self.packdomainname(rrname, i, msgcomp) +
- self.pds(inttoasc(typeval),2) +
- self.pds(inttoasc(rclass),2) +
- self.pds(inttoasc(ttl),4))
- i = i + len(packedrr) + 2
- if rrtype == 'A':
- rdata = socket.inet_aton(dbrec['address'])
- elif rrtype == 'AAAA':
- rdata = ipv6net_aton(dbrec['address'])
- elif rrtype == 'CNAME':
- rdata = self.packdomainname(dbrec['cname'], i, msgcomp)
- elif rrtype == 'HINFO':
- rdata = (chr(len(dbrec['cpu'])) + dbrec['cpu'] +
- chr(len(dbrec['os'])) + dbrec['os'])
- elif rrtype == 'LOC':
- rdata = (chr(dbrec['version']) +
- self.packlocsize(dbrec['size']) +
- self.packlocsize(dbrec['horiz_pre']) +
- self.packlocsize(dbrec['vert_pre']) +
- self.pds(inttoasc(dbrec['latitude']),4) +
- self.pds(inttoasc(dbrec['longitude']),4) +
- self.pds(inttoasc(dbrec['altitude']),4))
- elif rrtype == 'MX':
- rdata = (self.pds(inttoasc(dbrec['preference']),2) +
- self.packdomainname(dbrec['exchange'], i+2, msgcomp))
- elif rrtype == 'NS':
- rdata = self.packdomainname(dbrec['nsdname'], i, msgcomp)
- elif rrtype == 'PTR':
- rdata = self.packdomainname(dbrec['ptrdname'], i, msgcomp)
- elif rrtype == 'RP':
- rdata1 = self.packdomainname(dbrec['mboxdname'], i , msgcomp)
- i = i + len(rdata1)
- rdata2 = self.packdomainname(dbrec['mboxdname'], i , msgcomp)
- rdata = rdata1 + rdata2
- elif rrtype == 'SOA':
- rdata1 = self.packdomainname(dbrec['mname'], i, msgcomp)
- i = i + len(rdata1)
- rdata2 = self.packdomainname(dbrec['rname'], i, msgcomp)
- rdata = (rdata1 +
- rdata2 +
- self.pds(inttoasc(dbrec['serial']),4) +
- self.pds(inttoasc(dbrec['refresh']),4) +
- self.pds(inttoasc(dbrec['retry']),4) +
- self.pds(inttoasc(dbrec['expire']),4) +
- self.pds(inttoasc(dbrec['minimum']),4))
- elif rrtype == 'SRV':
- rdata = (self.pds(inttoasc(dbrec['priority']),2) +
- self.pds(inttoasc(dbrec['weight']),2) +
- self.pds(inttoasc(dbrec['port']),2) +
- self.packdomainname(dbrec['target'], i+6, msgcomp))
- elif rrtype == 'TXT':
- rdata = chr(len(dbrec['txtdata'])) + dbrec['txtdata']
- else:
- rdata = dbrec['rdata']
-
- return packedrr+self.pds(inttoasc(len(rdata)),2)+rdata
-
- def buildpkt(self):
- # keep dictionary of names packed (so we can use pointers)
- msgcomp = {}
- # header
- if self.header.id > 65535:
- log(0,'building packet with bad ID field')
- self.header.id = 1
- msgdata = inttoasc(self.header.id)
- if len(msgdata) == 1:
- msgdata = chr(0) + msgdata
- h1 = ((self.header.qr << 7) +
- (self.header.opcode << 3) +
- (self.header.aa << 2) +
- (self.header.tc << 1) +
- (self.header.rd))
- h2 = ((self.header.ra << 7) +
- (self.header.z << 4) +
- (self.header.rcode))
- msgdata = msgdata + chr(h1) + chr(h2)
- msgdata = msgdata + self.pds(inttoasc(self.header.qdcount),2)
- msgdata = msgdata + self.pds(inttoasc(self.header.ancount),2)
- msgdata = msgdata + self.pds(inttoasc(self.header.nscount),2)
- msgdata = msgdata + self.pds(inttoasc(self.header.arcount),2)
- # question
- msgdata = msgdata + self.packdomainname(self.question.qname, len(msgdata), msgcomp)
- if self.rqtypes.has_key(self.question.qtype):
- typeval = self.rqtypes[self.question.qtype]
- else:
- typeval = ord(self.question.qtype)
- msgdata = msgdata + self.pds(inttoasc(typeval),2)
- if self.rqclasses.has_key(self.question.qclass):
- classval = self.rqclasses[self.question.qclass]
- else:
- classval = ord(self.question.qclass)
- msgdata = msgdata + self.pds(inttoasc(classval),2)
- # rr's
- # RR record format:
- # {'name' : {'type' : [rdata, rdata, ...]}
- # example: {'test.blah.net': {'A': [{'address': '10.1.1.2',
- # 'ttl': 3600L}]}}
- for rr in self.answerlist:
- log(4,'packing answer RR')
- msgdata = msgdata + self.packrr(rr, len(msgdata), msgcomp)
- for rr in self.authlist:
- log(4,'packing auth RR')
- msgdata = msgdata + self.packrr(rr, len(msgdata), msgcomp)
- for rr in self.addlist:
- log(4,'packing additional RR')
- msgdata = msgdata + self.packrr(rr, len(msgdata), msgcomp)
-
- return msgdata
-
- def printpkt(self):
- print 'ID: ' +str(self.header.id)
- if self.header.qr:
- print 'QR: RESPONSE'
- else:
- print 'QR: QUERY'
- if self.header.opcode == 0:
- print 'OPCODE: STANDARD QUERY'
- elif self.header.opcode == 1:
- print 'OPCODE: INVERSE QUERY'
- elif self.header.opcode == 2:
- print 'OPCODE: SERVER STATUS REQUEST'
- elif self.header.opcode == 5:
- print 'UPDATE REQUEST'
- else:
- print 'OPCODE: UNKNOWN QUERY TYPE'
- if self.header.opcode != 5:
- if self.header.aa:
- print 'AA: AUTHORITATIVE ANSWER'
- else:
- print 'AA: NON-AUTHORITATIVE ANSWER'
- if self.header.tc:
- print 'TC: MESSAGE IS TRUNCATED'
- else:
- print 'TC: MESSAGE IS NOT TRUNCATED'
- if self.header.rd:
- print 'RD: RECURSION DESIRED'
- else:
- print 'RD: RECURSION NOT DESIRED'
- if self.header.ra:
- print 'RA: RECURSION AVAILABLE'
- else:
- print 'RA: RECURSION IS NOT AVAILABLE'
- if self.header.rcode == 1:
- printrcode = 'FORMERR'
- elif self.header.rcode == 2:
- printrcode = 'SERVFAIL'
- elif self.header.rcode == 3:
- printrcode = 'NXDOMAIN'
- elif self.header.rcode == 4:
- printrcode = 'NOTIMP'
- elif self.header.rcode == 5:
- printrcode = 'REFUSED'
- elif self.header.rcode == 6:
- printrcode = 'YXDOMAIN'
- elif self.header.rcode == 7:
- printrcode = 'YXRRSET'
- elif self.header.rcode == 8:
- printrcode = 'NXRRSET'
- elif self.header.rcode == 9:
- printrcode = 'NOTAUTH'
- elif self.header.rcode == 10:
- printrcode = 'NOTZONE'
- else:
- printrcode = 'NOERROR'
- print 'RCODE: ' + printrcode
- if self.header.opcode == 5:
- print 'NUMBER OF RRs in the Zone Section: ' + str(self.header.zocount)
- print 'NUMBER OF RRs in the Prerequisite Section: ' + str(self.header.prcount)
- print 'NUMBER OF RRs in the Update Section: ' + str(self.header.upcount)
- print 'NUMBER OF RRs in the Additional Data Section: ' + str(self.header.arcount)
- print 'ZONE SECTION:'
- print 'zname: ' + self.zone.zname
- print 'zonetype: ' + self.zone.ztype
- print 'zoneclass: ' + self.zone.zclass
- print 'PREREQUISITE RRs:'
- for rr in self.prlist:
- print rr
- print 'UPDATE RRs:'
- for rr in self.uplist:
- print rr
- print 'ADDITIONAL RRs:'
- for rr in self.addlist:
- print rr
-
-
- else:
- print 'NUMBER OF QUESTION RRs: ' + str(self.header.qdcount)
- print 'NUMBER OF ANSWER RRs: ' + str(self.header.ancount)
- print 'NUMBER OF NAME SERVER RRs: ' + str(self.header.nscount)
- print 'NUMBER OF ADDITIONAL RRs: ' + str(self.header.arcount)
- print 'QUESTION SECTION:'
- print 'qname: ' + self.question.qname
- print 'querytype: ' + self.question.qtype
- print 'queryclass: ' + self.question.qclass
- print 'ANSWER RRs:'
- for rr in self.answerlist:
- print rr
- print 'AUTHORITY RRs:'
- for rr in self.authlist:
- print rr
- print 'ADDITIONAL RRs:'
- for rr in self.addlist:
- print rr
-
-class zonedb:
- def __init__(self, zdict):
- self.zdict = zdict
- self.updates = {}
- for k in self.zdict.keys():
- if self.zdict[k]['type'] == 'slave':
- self.zdict[k]['lastupdatetime'] = 0
-
- def error(self, id, qname, querytype, queryclass, rcode):
- error = message()
- error.header.id = id
- error.header.rcode = rcode
- error.header.qr = 1
- error.question.qname = qname
- error.question.qtype = querytype
- error.question.qclass = queryclass
- return error
-
- def getorigin(self, zkey):
- origin = ''
- if self.zdict.has_key(zkey):
- origin = self.zdict[zkey]['origin']
- return origin
-
- def getmasterip(self, zkey):
- masterip = ''
- if self.zdict.has_key(zkey):
- if self.zdict[zkey].has_key('masterip'):
- masterip = self.zdict[zkey]['masterip']
- return masterip
-
- def zonetrans(self, query):
- # build a list of messages
- # each message contains one rr of the zone
- # the first and last message are the
- # SOA records
- origin = query.question.qname
- querytype = query.question.qtype
- zkey = ''
- for zonekey in self.zdict.keys():
- if self.zdict[zonekey]['origin'] == query.question.qname:
- zkey = zonekey
- if not zkey:
- return []
- zonedata = self.zdict[zkey]['zonedata']
- queryid = query.header.id
- soarec = zonedata[origin]['SOA'][0]
- soa = {origin:{'SOA':[soarec]}}
- curserial = soarec['serial']
- rrlist = []
- if querytype == 'IXFR':
- clientserial = query.authlist[0][origin]['SOA'][0]['serial']
- if clientserial < curserial:
- for i in range(clientserial,curserial+1):
- if self.updates[zkey].has_key(i):
- for rr in self.updates[zkey][i]['added']:
- rrlist.append(rr)
- for rr in self.updates[zkey][i]['removed']:
- rrlist.append(rr)
- if len(rrlist) > 0:
- rrlist.insert(0,soa)
- rrlist.append(soa)
- else:
- rrlist.append(soa)
- else:
- for nodename in zonedata.keys():
- for rrtype in zonedata[nodename].keys():
- if not (rrtype == 'SOA' and nodename == origin):
- for rr in zonedata[nodename][rrtype]:
- rrlist.append({nodename:{rrtype:[rr]}})
- rrlist.insert(0,soa)
- rrlist.append(soa)
- msglist = []
- for rr in rrlist:
- msg = message()
- msg.header.id = queryid
- msg.header.qr = 1
- msg.header.aa = 1
- msg.header.rd = 0
- msg.header.qdcount = 1
- msg.question.qname = origin
- msg.question.qtype = querytype
- msg.question.qclass = 'IN'
- msg.header.ancount = 1
- msg.answerlist.append(rr)
- msglist.append(msg)
- return msglist
-
- def update_zone(self, rrlist, params):
- zonekey = params[0]
- zonedata = {}
- soa = rrlist.pop()
- origin = soa.keys()[0]
- for rr in rrlist:
- rrname = rr.keys()[0]
- rrtype = rr[rrname].keys()[0]
- dbrec = rr[rrname][rrtype][0]
- if zonedata.has_key(rrname):
- if not zonedata[rrname].has_key(rrtype):
- zonedata[rrname][rrtype] = []
- else:
- zonedata[rrname] = {}
- zonedata[rrname][rrtype] = []
- zonedata[rrname][rrtype].append(dbrec)
- self.zdict[zonekey]['zonedata'] = zonedata
- curtime = time.time()
- self.zdict[zonekey]['lastupdatetime'] = curtime
- try:
- f = file(self.zdict[zonekey]['filename'],'w')
- writezonefile(zonedata, self.zdict[zonekey]['origin'], f)
- f.close()
- except:
- log(0,'unable to write zone ' + zonekey + 'to disk')
- log(1,'finished zone transfer for: ' + zonekey + ' (' + str(curtime) + ')')
-
- def remove_zone(self, zonekey):
- if self.zdict.has_key(zonekey):
- del self.zdict[zonekey]
-
- def getslaves(self, curtime):
- rlist = []
- for k in self.zdict.keys():
- if self.zdict[k]['type'] == 'slave':
- origin = self.zdict[k]['origin']
- refresh = self.zdict[k]['zonedata'][origin]['SOA'][0]['refresh']
- if self.zdict[k]['lastupdatetime'] + refresh < curtime:
- rlist.append((k, origin, self.zdict[k]['masterip']))
- return rlist
-
- def zmatch(self, qname, zkeys):
- for zkey in zkeys:
- if self.zdict.has_key(zkey):
- origin = self.zdict[zkey]['origin']
- if qname.rfind(origin) != -1:
- return zkey
- return ''
-
- def getzlist(self, name, zone):
- if name == zone:
- return
- zlist = []
- i = name.rfind(zone)
- if i == -1:
- return
- firstpart = name[:i-1]
- partlist = firstpart.split('.')
- partlist.reverse()
- lastpart = zone
- for x in range(len(partlist)):
- lastpart = partlist[x] + '.' + lastpart
- zlist.append(lastpart)
- return zlist
-
- def lookup(self, zkeys, query, addr, server, dorecursion, flist, cbfunc):
- # handle zone transfers seperately
- qname = query.question.qname
- querytype = query.question.qtype
- queryclass = query.question.qclass
- if querytype in ['AXFR','IXFR']:
- for zkey in self.zdict.keys():
- if zkey in zkeys:
- if qname == self.zdict[zkey]['origin']:
- answerlist = self.zonetrans(query)
- break
- else:
- answerlist = []
- cbfunc(query, addr, server, dorecursion, flist, answerlist)
- else:
- zonekey = self.zmatch(qname, zkeys)
- if zonekey:
- origin = self.zdict[zonekey]['origin']
- zonedict = self.zdict[zonekey]['zonedata']
- referral = 0
- rranswerlist = []
- rrnslist = []
- rraddlist = []
- answer = message()
- answer.header.aa = 1
- answer.header.id = query.header.id
- answer.header.qr = 1
- answer.header.opcode = query.header.opcode
- answer.header.rcode = 4
- answer.header.ra = dorecursion
- answer.question.qname = query.question.qname
- answer.question.qtype = query.question.qtype
- answer.question.qclass = query.question.qclass
- answer.header.ra = dorecursion
- s = '.servers.csail.mit.edu'
- if qname.endswith(s):
- host = qname[:-len(s)]
- value = sipb_xen_database.NIC.get_by(hostname=host)
- if value is None:
- pass
- else:
- ip = value.ip
- rranswerlist.append({qname: {'A': [{'address': ip,
- 'class': 'IN',
- 'ttl': 10}]}})
- if zonedict.has_key(qname):
- # found the node, now take care of CNAMEs
- if zonedict[qname].has_key('CNAME'):
- if querytype != 'CNAME':
- nodetype = 'CNAME'
- while nodetype == 'CNAME':
- rranswerlist.append({qname:{'CNAME':[zonedict[qname]['CNAME'][0]]}})
- qname = zonedict[qname]['CNAME'][0]['cname']
- if zonedict.has_key(qname):
- nodetype = zonedict[qname].keys()[0]
- else:
- # error, shouldn't have a CNAME that points to nothing
- return
- # if we get this far, then the record has matched and we should return
- # a reply that has no error (even if there is no info macthing the qtype)
- answer.header.rcode = 0
- answernode = zonedict[qname]
- if querytype == 'ANY':
- for type in answernode.keys():
- for rec in answernode[type]:
- rranswerlist.append({qname:{type:[rec]}})
- elif answernode.has_key(querytype):
- for rec in answernode[querytype]:
- rranswerlist.append({qname:{querytype:[rec]}})
- # do rrset ordering (cyclic)
- if len(answernode[querytype]) > 1:
- rec = answernode[querytype].pop(0)
- answernode[querytype].append(rec)
- else:
- # remove all cname rrs from answerlist
- rranswerlist = []
- else:
- # would check for wildcards here (but aren't because they seem bad)
- # see if we need to give a referral
- zlist = self.getzlist(qname,origin)
- for zonename in zlist:
- if zonedict.has_key(zonename):
- if zonedict[zonename].has_key('NS'):
- answer.header.rcode = 0
- referral = 1
- for rec in zonedict[zonename]['NS']:
- rrnslist.append({zonename:{'NS':[rec]}})
- nsdname = rec['nsdname']
- # add glue records if they exist
- if zonedict.has_key(nsdname):
- if zonedict[nsdname].has_key('A'):
- for gluerec in zonedict[nsdname]['A']:
- rraddlist.append({nsdname:{'A':[gluerec]}})
- # negative caching stuff
- if not referral:
- if not rranswerlist:
- # NOTE: RFC1034 section 4.3.4 says we should add the SOA record
- # to the additional section of the response. BIND adds
- # it to the ns section though
- answer.header.rcode = 3
- rrnslist.append({origin:{'SOA':[zonedict[origin]['SOA'][0]]}})
- else:
- for rec in zonedict[origin]['NS']:
- rrnslist.append({origin:{'NS':[rec]}})
- answer.header.ancount = len(rranswerlist)
- answer.header.nscount = len(rrnslist)
- answer.header.arcount = len(rraddlist)
- answer.answerlist = rranswerlist
- answer.authlist = rrnslist
- answer.addlist = rraddlist
- cbfunc(query, addr, server, dorecursion, flist, [answer])
- else:
- cbfunc(query, addr, server, dorecursion, flist, [])
-
- def handle_update(self, msg, addr, ns):
- zkey = ''
- slaves = []
- for zonekey in self.zdict.keys():
- if (self.zdict[zonekey]['type'] == 'master' and
- self.zdict[zonekey]['origin'] == msg.zone.zname):
- zkey = zonekey
- if not zkey:
- log(2,'SENDING NOTAUTH UPDATE ERROR')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 9)
- return errormsg, '', slaves
- # find the slaves for the zone
- if self.zdict[zkey].has_key('slaves'):
- slaves = self.zdict[zkey]['slaves']
- origin = self.zdict[zkey]['origin']
- zd = self.zdict[zkey]['zonedata']
- # check the permissions
- if not ns.config.allowupdate(msg, addr[0], addr[1]):
- log(2,'SENDING REFUSED UPDATE ERROR')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 5)
- return errormsg, origin, slaves
- # now check the prereqs
- temprrset = {}
- for rr in msg.prlist:
- rrname = rr.keys()[0]
- rrtype = rr[rrname].keys()[0]
- dbrec = rr[rrname][rrtype][0]
- if dbrec['ttl'] != 0:
- log(2,'FORMERROR(1)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 1)
- return errormsg, origin, slaves
- if rrname.rfind(msg.zone.zname) == -1:
- log(2,'NOTZONE(10)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 10)
- return errormsg, origin, slaves
- if dbrec['class'] == 'ANY':
- if dbrec['rdata']:
- log(2,'FORMERROR(1)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 1)
- return errormsg, origin, slaves
- if rrtype == 'ANY':
- if not zd.has_key(rrname):
- log(2,'NXDOMAIN(3)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 3)
- return errormsg, origin, slaves
- else:
- rrsettest = 0
- if zd.has_key(rrname):
- if zd[rrname].has_key(rrtype):
- rrsettest = 1
- if not rrsettest:
- log(2,'NXRRSET(8)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 8)
- return errormsg, origin, slaves
- if dbrec['class'] == 'NONE':
- if dbrec['rdata']:
- log(2,'FORMERROR(1)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 1)
- return errormsg, origin, slaves
- if rrtype == 'ANY':
- if zd.has_key(rrname):
- log(2,'YXDOMAIN(6)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 6)
- return errormsg, origin, slaves
- else:
- if zd.has_key(rrname):
- if zd[rrname].has_key(rrtype):
- log(2,'YXRRSET(7)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 7)
- return errormsg, origin, slaves
- if dbrec['class'] == msg.zone.zclass:
- if temprrset.has_key(rrname):
- if not temprrset[rrname].has_key(rrtype):
- temprrset[rrname][rrtype] = []
- else:
- temprrset[rrname] = {}
- temprrset[rrname][rrtype] = []
- temprrset[rrname][rrtype].append(dbrec)
- else:
- log(2,'FORMERROR(1)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 1)
- return errormsg, origin, slaves
- for nodename in temprrset.keys():
- if not self.rrmatch(temprrset[nodename],zd[nodename]):
- log(2,'NXRRSET(8)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 8)
- return errormsg, origin, slaves
-
- # update section prescan
- for rr in msg.uplist:
- rrname = rr.keys()[0]
- rrtype = rr[rrname].keys()[0]
- dbrec = rr[rrname][rrtype][0]
- if rrname.rfind(msg.zone.zname) == -1:
- log(2,'NOTZONE(10)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 10)
- return errormsg, origin, slaves
- if dbrec['class'] == msg.zone.zclass:
- if rrtype in ['ANY','MAILA','MAILB','AXFR']:
- log(2,'FORMERROR(1)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 1)
- return errormsg, origin, slaves
- elif dbrec['class'] == 'ANY':
- if dbrec['ttl'] != 0 or dbrec['rdata'] or rrtype in ['MAILA','MAILB','AXFR']:
- log(2,'FORMERROR(1)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 1)
- return errormsg, origin, slaves
- elif dbrec['class'] == 'NONE':
- if dbrec['ttl'] != 0 or rrtype in ['ANY','MAILA','MAILB','AXFR']:
- log(2,'FORMERROR(1)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 1)
- return errormsg, origin, slaves
- else:
- log(2,'FORMERROR(1)')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 1)
- return errormsg, origin, slaves
-
- # now handle actual update
- curserial = zd[msg.zone.zname]['SOA'][0]['serial']
- # update the soa serial here
- clearupdatehist = 0
- if len(msg.uplist) > 0:
- # initialize history structure
- if not self.updates.has_key(zkey):
- self.updates[zkey] = {}
- self.updates[zkey][curserial] = {'removed':[],
- 'added':[]}
- if curserial == 2**32:
- newserial = 2
- clearupdatehist = 1
- else:
- newserial = curserial + 1
- self.updates[zkey][newserial] = {'removed':[],
- 'added':[]}
- zd[msg.zone.zname]['SOA'][0]['serial'] = newserial
- for rr in msg.uplist:
- rrname = rr.keys()[0]
- rrtype = rr[rrname].keys()[0]
- dbrec = rr[rrname][rrtype][0]
- if dbrec['class'] == msg.zone.zclass:
- if rrtype == 'SOA':
- if zd.has_key(rrname):
- if zd[rrname].has_key('SOA'):
- if dbrec['serial'] > zd[rrname]['SOA'][0]['serial']:
- del zd[rrname]['SOA'][0]
- zd[rrname]['SOA'].append(dbrec)
- clearupdatehist = 1
- elif rrtype == 'WKS':
- if zd.has_key(rrname):
- if zd[rrname].has_key('WKS'):
- rdata = zd[rrname]['WKS'][0]
- oldrr = {rrname:{'WKS':[rdata]}}
- self.updates[zkey][curserial]['removed'].append(oldrr)
- del zd[rrname]['WKS'][0]
- zd[rrname]['WKS'].append(dbrec)
- newrr = {rrname:{'WKS':[dbrec]}}
- self.updates[zkey][newserial]['added'].append(newrr)
- else:
- if zd.has_key(rrname):
- if not zd[rrname].has_key(rrtype):
- zd[rrname][rrtype] = []
- else:
- zd[rrname] = {}
- zd[rrname][rrtype] = []
- zd[rrname][rrtype].append(dbrec)
- newrr = {rrname:{rrtype:[dbrec]}}
- self.updates[zkey][newserial]['added'].append(newrr)
- elif dbrec['class'] == 'ANY':
- if rrtype == 'ANY':
- if rrname == msg.zone.zname:
- if zd.has_key(rrname):
- for dnstype in zd[rrname].keys():
- if dnstype not in ['SOA','NS']:
- for rdata in zd[rrname][dnstype]:
- oldrr = {rrname:{dnstype:[rdata]}}
- self.updates[zkey][curserial]['removed'].append(oldrr)
- del zd[rrname][dnstype]
- else:
- if zd.has_key(rrname):
- for dnstype in zd[rrname].keys():
- for rdata in zd[rrname][dnstype]:
- oldrr = {rrname:{dnstype:[rdata]}}
- self.updates[zkey][curserial]['removed'].append(oldrr)
- del zd[rrname]
- else:
- if zd.has_key(rrname):
- if zd[rrname].has_key(rrtype):
- if rrname == msg.zone.zname:
- if rrtype not in ['SOA','NS']:
- for rdata in zd[rrname][dnstype]:
- oldrr = {rrname:{dnstype:[rdata]}}
- self.updates[zkey][curserial]['removed'].append(oldrr)
- del zd[rrname][rrtype]
- else:
- for rdata in zd[rrname][dnstype]:
- oldrr = {rrname:{dnstype:[rdata]}}
- self.updates[zkey][curserial]['removed'].append(oldrr)
- del zd[rrname][rrtype]
- elif dbrec['class'] == 'NONE':
- if not (rrname == msg.zone.zname and rrtype in ['SOA','NS']):
- if zd.had_key(rrname):
- if zd[rrname].has_key(rrtype):
- for i in range(len(zd[rrname][rrtype])):
- if dbrec == zd[rrname][rrtype][i]:
- rdata = zd[rrname][dnstype][i]
- oldrr = {rrname:{dnstype:[rdata]}}
- self.updates[zkey][curserial]['removed'].append(oldrr)
- del zd[rrname][rrtype][i]
- if len(zd[rrname][rrtype]) == 0:
- del zd[rrname][rrtype]
- if clearupdatehist:
- self.updates[zkey] = {}
- log(2,'SENDING UPDATE NOERROR MSG')
- noerrormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 0)
- return noerrormsg, origin, slaves
-
-class dnscache:
- def __init__(self,cachezone):
- self.cachedb = cachezone
- # go through and set all of the root ttls to zero
- for node in self.cachedb.keys():
- for rtype in self.cachedb[node].keys():
- for rr in self.cachedb[node][rtype]:
- rr['ttl'] = 0
- if rtype == 'NS':
- rr['rtt'] = 0
- # add special entries for localhost
- self.cachedb['localhost'] = {'A':[{'address':'127.0.0.1', 'ttl':0, 'class':'IN'}]}
- self.cachedb['1.0.0.127.in-addr.arpa'] = {'PTR':[{'ptrdname':'localhost', 'ttl':0,'class':'IN'}]}
- self.cachedb['']['SOA'] = []
- self.cachedb['']['SOA'].append({'class':'IN','ttl':0,'mname':'cachedb',
- 'rname':'cachedb@localhost','serial':1,'refresh':10800,
- 'retry':3600,'expire':604800,'minimum':3600})
-
- def hasrdata(self, irrdata, rrdatalist):
- # compare everything but ttls
- test = 0
- testrrdata = irrdata.copy()
- del testrrdata['ttl']
- for rrdata in rrdatalist:
- temprrdata = rrdata.copy()
- del temprrdata['ttl']
- if temprrdata == testrrdata:
- test = 1
- return test
-
- def add(self, rr, qzone, nsdname):
- # NOTE: can't cache records from sites
- # that don't own those records (i.e. example.com
- # can't give us A records for www.example.net)
- name = rr.keys()[0]
- if (qzone != '') and (name[-len(qzone):] != qzone):
- log(2,'cache GOT possible POISON: ' + name + ' for zone ' + qzone)
- return
- rtype = rr[name].keys()[0]
- rdata = rr[name][rtype][0]
- if rdata['ttl'] < 3600:
- log(2,'low ttl: ' + str(rdata['ttl']))
- rdata['ttl'] = 3600
- rdata['ttl'] = int(time.time() + rdata['ttl'])
- if rtype == 'NS':
- rdata['rtt'] = 0
- name = name.lower()
- rtype = rtype.upper()
- if self.cachedb.has_key(name):
- if self.cachedb[name].has_key(rtype):
- if not self.hasrdata(rdata, self.cachedb[name][rtype]):
- self.cachedb[name][rtype].append(rdata)
- log(3,'appended rdata to ' +
- name + '(' + rtype + ') in cache')
- else:
- log(3,'same rdata for ' + name + '(' +
- rtype + ') is already in cache')
- else:
- self.cachedb[name][rtype] = [rdata]
- log(3,'appended ' + rtype + ' and rdata to node ' +
- name + ' in cache')
- else:
- self.cachedb[name] = {rtype:[rdata]}
- log(3,'added node ' + name + '(' + rtype + ') to cache')
- self.reap()
-
- def addneg(self, qname, querytype, queryclass):
- if not self.cachedb.has_key(qname):
- self.cachedb['qname'] = {querytype: [{'ttl':time.time()+3600}]}
- else:
- if not self.cachedb[qname].has_key(querytype):
- self.cachedb[qname][querytype] = [{'ttl':time.time()+3600}]
-
- def haskey(self, qname, querytype, msg=''):
- log(3,'looking for ' + qname + '(' + querytype + ') in cache')
- if self.cachedb.has_key(qname):
- rranswerlist = []
- rrnslist = []
- rraddlist = []
- if self.cachedb[qname].has_key('CNAME'):
- if querytype != 'CNAME':
- nodetype = 'CNAME'
- while nodetype == 'CNAME':
- if len(self.cachedb[qname]['CNAME'][0].keys()) > 1:
- log(3,'Adding CNAME to cache answer')
- rranswerlist.append({qname:{'CNAME':[self.cachedb[qname]['CNAME'][0]]}})
- qname = self.cachedb[qname]['CNAME'][0]['cname']
- if self.cachedb.has_key(qname):
- nodetype = self.cachedb[qname].keys()[0]
- else:
- # shouldn't have a CNAME that points to nothing
- return
- if querytype == 'ANY':
- for type in self.cache[qname].keys():
- for rec in self.cachedb[qname][type]:
- # can't append negative entries
- if len(rec.keys()) > 1:
- rranswerlist.append({qname:{type:[rec]}})
- elif self.cachedb[qname].has_key(querytype):
- for rec in self.cachedb[qname][querytype]:
- if len(rec.keys()) > 1:
- rranswerlist.append({qname:{querytype:[rec]}})
- if rranswerlist:
- if msg:
- answer = message()
- answer.header.id = msg.header.id
- answer.header.qr = 1
- answer.header.opcode = msg.header.opcode
- answer.header.ra = 1
- answer.question.qname = msg.question.qname
- answer.question.qtype = msg.question.qtype
- answer.question.qclass = msg.question.qclass
- answer.header.rcode = 0
- answer.header.ancount = len(rranswerlist)
- answer.answerlist = rranswerlist
- return answer
- else:
- return 1
- else:
- log(3,'Cache has no node for ' + qname)
-
- def getnslist(self, qname):
- # find the best nameserver to ask from the cache
- tokens = qname.split('.')
- nsdict = {}
- curtime = time.time()
- for i in range(len(tokens)):
- domainname = '.'.join(tokens[i:])
- if self.cachedb.has_key(domainname):
- if self.cachedb[domainname].has_key('NS'):
- for nsrec in self.cachedb[domainname]['NS']:
- badserver = 0
- if nsrec.has_key('badtill'):
- if nsrec['badtill'] < curtime:
- del nsrec['badtill']
- else:
- badserver = 1
- if badserver:
- log(2,'BAD SERVER, not using ' + nsrec['nsdname'])
- if self.cachedb.has_key(nsrec['nsdname']) and not badserver:
- if self.cachedb[nsrec['nsdname']].has_key('A'):
- for arec in self.cachedb[nsrec['nsdname']]['A']:
- nsdict[nsrec['rtt']] = {'name':nsrec['nsdname'],
- 'ip':arec['address']}
- if nsdict:
- break
- if not nsdict:
- domainname = ''
- # nothing in the cache matches so give back the root servers
- for nsrec in self.cachedb['']['NS']:
- badserver = 0
- if nsrec.has_key('badtill'):
- if curtime > nsrec['badtill']:
- del nsrec['badtill']
- else:
- badserver = 1
- if not badserver:
- for arec in self.cachedb[nsrec['nsdname']]['A']:
- nsdict[(nsrec['rtt'])] = {'name':nsrec['nsdname'],'ip':arec['address']}
-
- return (domainname, nsdict)
-
- def badns(self, zonename, nsdname):
- if self.cachedb.has_key(zonename):
- if self.cachedb[zonename].has_key('NS'):
- for nsrec in self.cachedb[zonename]['NS']:
- if nsrec['nsdname'] == nsdname:
- log(2,'Setting ' + nsdname + ' as bad nameserver')
- nsrec['badtill'] = time.time() + 3600
-
-
- def updatertt(self, qname, zone, rtt):
- if self.cachedb.has_key(zone):
- if self.cachedb[zone].has_key('NS'):
- for rr in self.cachedb[zone]['NS']:
- if rr['nsdname'] == qname:
- log(2,'updating rtt for ' + qname + ' to ' + str(rtt))
- rr['rtt'] = rtt
-
- def reap(self):
- # expire all old records
- ntime = time.time()
- for nodename in self.cachedb.keys():
- for rrtype in self.cachedb[nodename].keys():
- for rdata in self.cachedb[nodename][rrtype]:
- ttl = rdata['ttl']
- if ttl != 0:
- if ttl < ntime:
- self.cachedb[nodename][rrtype].remove(rdata)
- if len(self.cachedb[nodename][rrtype]) == 0:
- del self.cachedb[nodename][rrtype]
- if len(self.cachedb[nodename]) == 0:
- del self.cachedb[nodename]
-
- return
-
- def zonetrans(self, queryid):
- # build a list of messages
- # each message contains one rr of the zone
- # the first and last message are the
- # SOA records
- zonedata = self.cachedb
- rrlist = []
- soa = {'':{'SOA':[zonedata['']['SOA'][0]]}}
- for nodename in zonedata.keys():
- for rrtype in zonedata[nodename].keys():
- if not (rrtype == 'SOA' and nodename == ''):
- for rr in zonedata[nodename][rrtype]:
- rrlist.append({nodename:{rrtype:[rr]}})
- rrlist.insert(0,soa)
- rrlist.append(soa)
- msglist = []
- for rr in rrlist:
- msg = message()
- msg.header.id = queryid
- msg.header.qr = 1
- msg.header.aa = 1
- msg.header.rd = 0
- msg.header.qdcount = 1
- msg.question.qname = 'cache'
- msg.question.qtype = 'AXFR'
- msg.question.qclass = 'IN'
- msg.header.ancount = 1
- msg.answerlist.append(rr)
- msglist.append(msg)
- return msglist
-
-class gethostaddr(asyncore.dispatcher):
- def __init__(self, hostname, cbfunc, serveraddr='127.0.0.1'):
- asyncore.dispatcher.__init__(self)
- self.msg = message()
- self.msg.question.qname = hostname
- self.msg.question.qtype = 'A'
- self.cbfunc = cbfunc
- self.create_socket(socket.AF_INET, socket.SOCK_DGRAM)
- self.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 200 * 1024)
- self.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 200 * 1024)
- self.socket.sendto(self.msg.buildpkt(), (serveraddr,53))
-
- def handle_read(self):
- replydata, addr = self.socket.recvfrom(1500)
- self.close()
- try:
- replymsg = message(replydata)
- except:
- log(0,'unable to process packet')
- return
- answername = replymsg.question.qname
- cname = ''
- # go through twice to catch cnames after A recs
- for rr in replymsg.answerlist:
- rrname = rr.keys()[0]
- rrtype = rr[rrname].keys()[0]
- dbrec = rr[rrname][rrtype][0]
- if rrname == answername and rrtype == 'CNAME':
- answername = dbrec['cname']
- cname = answername
- for rr in replymsg.answerlist:
- rrname = rr.keys()[0]
- rrtype = rr[rrname].keys()[0]
- dbrec = rr[rrname][rrtype][0]
- if rrname == answername and rrtype == 'A':
- self.cbfunc(dbrec['address'])
- return
- # if we got a cname and no A send query for cname
- if cname:
- self.msg = message()
- self.msg.question.qname = cname
- self.msg.question.qtype = 'A'
- self.socket.sendto(self.msg.buildpkt(), (serveraddr,53))
- else:
- self.cbfunc('')
-
- def writable(self):
- return 0
-
- def handle_write(self):
- pass
-
- def handle_connect(self):
- pass
-
- def handle_close(self):
- self.close()
-
- def log_info (self, message, type='info'):
- if __debug__ or type != 'info':
- log(0,'%s: %s' % (type, message))
-
-class simpleudprequest(asyncore.dispatcher):
- def __init__(self, msg, cbfunc, serveraddr='127.0.0.1', outqkey=''):
- asyncore.dispatcher.__init__(self)
- self.gotanswer = 0
- self.msg = msg
- self.cbfunc = cbfunc
- self.create_socket(socket.AF_INET, socket.SOCK_DGRAM)
- self.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 200 * 1024)
- self.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 200 * 1024)
- self.outqkey = outqkey
- self.socket.sendto(self.msg.buildpkt(), (serveraddr,53))
-
- def handle_read(self):
- replydata, addr = self.socket.recvfrom(1500)
- self.close()
- try:
- replymsg = message(replydata)
- except:
- log(0,'unable to process packet')
- return
- self.cbfunc(replymsg, self.outqkey)
-
- def writable(self):
- return 0
-
- def handle_write(self):
- pass
-
- def handle_connect(self):
- pass
-
- def handle_close(self):
- self.close()
-
- def log_info (self, message, type='info'):
- if __debug__ or type != 'info':
- log(0,'%s: %s' % (type, message))
-
-class simpletcprequest(asyncore.dispatcher):
- def __init__(self, msg, cbfunc, cbparams=[], serveraddr='127.0.0.1', errorfunc=''):
- asyncore.dispatcher.__init__(self)
- self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
- self.query = msg
- self.cbfunc = cbfunc
- self.cbparams = cbparams
- self.errorfunc = errorfunc
- msgdata = msg.buildpkt()
- ml = inttoasc(len(msgdata))
- if len(ml) == 1:
- ml = chr(0) + ml
- self.buffer = ml+msgdata
- self.rbuffer = ''
- self.rmsgleft = 0
- self.rrlist = []
- log(2,'sending tcp request to ' + serveraddr)
- self.connect((serveraddr,53))
-
- def recv (self, buffer_size):
- try:
- data = self.socket.recv (buffer_size)
- if not data:
- # a closed connection is indicated by signaling
- # a read condition, and having recv() return 0.
- self.handle_close()
- return ''
- else:
- return data
- except socket.error, why:
- # winsock sometimes throws ENOTCONN
- if why[0] in [ECONNRESET, ENOTCONN, ESHUTDOWN, ETIMEDOUT]:
- self.handle_close()
- return ''
- else:
- raise socket.error, why
-
- def handle_connect(self):
- pass
-
- def handle_msg(self, msg):
- if self.query.question.qtype == 'AXFR':
- if len(self.rrlist) == 0:
- if len(msg.answerlist) == 0:
- if self.errorfunc:
- self.errorfunc(self.cbparams[0])
- self.close()
- return
- rr = msg.answerlist[0]
- rrname = rr.keys()[0]
- rrtype = rr[rrname].keys()[0]
- self.rrlist.append(rr)
- if rrtype == 'SOA' and len(self.rrlist) > 1:
- self.close()
- if self.cbparams:
- self.cbfunc(self.rrlist, self.cbparams)
- else:
- self.cbfunc(self.rrlist)
- else:
- self.close()
- if self.cbparams:
- self.cbfunc(msg, self.cbparams)
- else:
- self.cbfunc(msg)
-
- def handle_read(self):
- data = self.recv(8192)
- if len(self.rbuffer) == 0:
- self.rmsglength = asctoint(data[:2])
- data = data[2:]
- self.rbuffer = self.rbuffer + data
- while len(self.rbuffer) >= self.rmsglength and self.rmsglength != 0:
- msgdata = self.rbuffer[:self.rmsglength]
- self.rbuffer = self.rbuffer[self.rmsglength:]
- if len(self.rbuffer) == 0:
- self.rmsglength = 0
- else:
- self.rmsglength = asctoint(self.rbuffer[:2])
- self.rbuffer = self.rbuffer[2:]
- try:
- self.handle_msg(message(msgdata))
- except:
- return
-
- def writable(self):
- return (len(self.buffer) > 0)
-
- def handle_write(self):
- sent = self.send(self.buffer)
- self.buffer = self.buffer[sent:]
-
- def handle_close(self):
- if self.errorfunc:
- self.errorfunc(self.query.question.qname)
- self.close()
-
- def log_info (self, message, type='info'):
- if __debug__ or type != 'info':
- log(0,'%s: %s' % (type, message))
-
-class udpdnsserver(asyncore.dispatcher):
- def __init__(self, port, dnsserver):
- asyncore.dispatcher.__init__(self)
- self.create_socket(socket.AF_INET, socket.SOCK_DGRAM)
- self.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 200 * 1024)
- self.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 200 * 1024)
- self.bind(('',port))
- self.dnsserver = dnsserver
- self.maxmsgsize = 500
-
- def handle_read(self):
- try:
- while 1:
- msgdata, addr = self.socket.recvfrom(1500)
- self.dnsserver.handle_packet(msgdata, addr, self)
- except socket.error, why:
- if why[0] != asyncore.EWOULDBLOCK:
- raise socket.error, why
-
- def sendpackets(self, msglist, addr):
- for msg in msglist:
- msgdata = msg.buildpkt()
- if len(msgdata) > self.maxmsgsize:
- msg.header.tc = 1
- # take off all the answers to ensure
- # the packet size is small enough
- msg.header.ancount = 0
- msg.header.nscount = 0
- msg.header.arcount = 0
- msg.answerlist = []
- msg.authlist = []
- msg.addlist = []
- msgdata = msg.buildpkt()
- self.sendto(msgdata, addr)
-
- def writable(self):
- return 0
-
- def handle_write(self):
- pass
-
- def handle_connect(self):
- pass
-
- def handle_close(self):
- # print '1:In handle close'
- return
-
- def log_info (self, message, type='info'):
- if __debug__ or type != 'info':
- log(0,'%s: %s' % (type, message))
-
-class tcpdnschannel(asynchat.async_chat):
- def __init__(self, server, s, addr):
- asynchat.async_chat.__init__(self, s)
- self.server = server
- self.addr = addr
- self.set_terminator(None)
- self.databuffer = ''
- self.msglength = 0
- log(3,'Created new tcp channel')
-
- def collect_incoming_data(self, data):
- if self.msglength == 0:
- self.msglength = asctoint(data[:2])
- data = data[2:]
- self.databuffer = self.databuffer + data
- if len(self.databuffer) == self.msglength:
- # got entire message
- self.server.dnsserver.handle_packet(self.databuffer, self.addr, self)
- self.databuffer = ''
-
- def sendpackets(self, msglist, addr):
- for msg in msglist:
- x = msg.buildpkt()
- ml = inttoasc(len(x))
- if len(ml) == 1:
- ml = chr(0) + ml
- self.push(ml+x)
- self.close()
-
- def log_info (self, message, type='info'):
- if __debug__ or type != 'info':
- log(0,'%s: %s' % (type, message))
-
-class tcpdnsserver(asyncore.dispatcher):
- def __init__(self, port, dnsserver):
- asyncore.dispatcher.__init__(self)
- self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
- self.set_reuse_addr()
- self.bind(('',port))
- self.listen(5)
- self.dnsserver = dnsserver
-
- def handle_accept(self):
- conn, addr = self.accept()
- tcpdnschannel(self, conn, addr)
-
- def handle_close(self):
- self.close()
-
- def log_info (self, message, type='info'):
- if __debug__ or type != 'info':
- log(0,'%s: %s' % (type, message))
-
-class nameserver:
- def __init__(self, resolver, localconfig):
- self.resolver = resolver
- self.config = localconfig
- self.zdb = self.config.zonedatabase
- self.last_reap_time = time.time()
- self.maint_int = 10
- self.slavesupdating = []
- self.notifys = []
- self.sentnotify = []
- self.notify_retry_time = 30
- self.notify_retries = 4
- self.askedsoa = {}
- self.soatimeout = 10
-
- def error(self, id, qname, querytype, queryclass, rcode):
- error = message()
- error.header.id = id
- error.header.rcode = rcode
- error.header.qr = 1
- error.question.qname = qname
- error.question.qtype = querytype
- error.question.qclass = queryclass
- return error
-
- def need_zonetransfer(self, zkey, origin, masterip, trynum=0):
- self.askedsoa[zkey] = {'masterip':masterip,
- 'senttime':time.time(),
- 'origin':origin,
- 'trynum':trynum+1}
- query = message()
- query.header.id = random.randrange(1,32768)
- query.header.rd = 0
- query.question.qname = origin
- query.question.qtype = 'SOA'
- query.question.qclass = 'IN'
- log(3,'slave checking for new data in ' + origin)
- simpleudprequest(query, self.handle_soaquery,
- masterip, zkey)
-
- def handle_soaquery(self, msg, zkey):
- origin = msg.question.qname
- masterip = self.askedsoa[zkey]['masterip']
- del self.askedsoa[zkey]
- if zkey not in self.slavesupdating:
- self.slavesupdating.append(zkey)
- query = message()
- query.header.id = random.randrange(1,32768)
- query.header.rd = 0
- query.question.qname = origin
- query.question.qtype = 'AXFR'
- query.question.qclass = 'IN'
- log(3,'Updating slave zone: ' + zkey)
- simpletcprequest(query, self.handle_zonetrans,
- [zkey],masterip,self.handle_zterror)
-
- def handle_zonetrans(self, rrlist, params):
- log(1,'handling zone transfer')
- zonekey = params[0]
- self.zdb.update_zone(rrlist, params)
- self.slavesupdating.remove(zonekey)
-
- def handle_zterror(self, zonekey):
- self.slavesupdating.remove(zonekey)
- self.zdb.remove_zone(zonekey)
-
- def rrmatch(self, rrset1, rrset2):
- for rrtype in rrset1.keys():
- if rrtype not in rrset2.keys():
- return
- else:
- if len(rrset1[rrtype]) != len(rrset2[rrtype]):
- return
- return 1
-
- def process_notify(self, msg, ipaddr, port):
- (zkeys, dorecursion, flist) = self.config.getview(msg, ipaddr, port)
- goodzkey = ''
- for zkey in zkeys:
- origin = self.zdb.getorigin(zkey)
- if origin == msg.question.qname:
- masterip = self.zdb.getmasterip(zkey)
- if masterip:
- goodzkey = zkey
- if goodzkey:
- log(3,'got NOTIFY from ' + masterip)
- self.need_zonetransfer(goodzkey, origin, masterip, 0)
- return
-
- def notify(self):
- curtime = time.time()
- for origin, ipaddr, trynum, senttime in self.sentnotify:
- if senttime + self.notify_retry_time > curtime:
- self.notifys.append((origin, ipaddr, trynum))
- self.sentnotify.remove((origin, ipaddr, trynum, senttime))
- for origin, ipaddr, trynum in self.notifys:
- msg = message()
- msg.question.qname = origin
- msg.question.qtype = 'SOA'
- msg.question.qclass = 'IN'
- msg.header.opcode = 4
- # there probably is a better way to do this
- if self.resolver:
- self.resolver.send_to([msg],(ipaddr,53))
- if trynum+1 <= self.notify_retries:
- self.sentnotify.append((origin,ipaddr,trynum+1,curtime))
- self.notifys = []
-
- def handle_packet(self, msgdata, addr, server):
- # self.reap()
- try:
- msg = message(msgdata)
- except:
- return
- # find a matching view
- (zkeys, dorecursion, flist) = self.config.getview(msg, addr[0], addr[1])
- if not msg.header.qr and msg.header.opcode == 5:
- log(2,'GOT UPDATE PACKET')
- # check the zone section
- if (msg.header.zocount != 1 or
- msg.zone.ztype != 'SOA' or
- msg.zone.zclass != 'IN'):
- log(2,'SENDING FORMERR UPDATE ERROR')
- errormsg = self.error(msg.header.id, msg.zone.zname,
- msg.zone.ztype, msg.zone.zclass, 1)
- server.sendpackets([errormsg],addr)
- else:
- (answer, origin, slaves) = self.zdb.handle_update(msg, addr, self)
- if answer.header.rcode == 0:
- # schedule NOTIFYs to slaves
- for ipaddr in slaves:
- self.notifys.append((origin, ipaddr, 0))
- server.sendpackets([answer],addr)
- elif msg.header.opcode == 4:
- if msg.header.qr:
- log(0,'got NOTIFY response')
- for origin, ipaddr, trynum, senttime in self.sentnotify:
- if ipaddr == addr[0] and msg.question.qname == origin:
- self.sentnotify.remove((origin, ipaddr, trynum, senttime))
- else:
- log(0,'got NOTIFY')
- self.process_notify(msg, addr[0], addr[1])
- elif not msg.header.qr and msg.header.opcode == 0:
- # it's a question
- qname = msg.question.qname.lower()
- log(2,'GOT QUERY for ' + qname + '(' + msg.question.qtype +
- ') from ' + addr[0])
- # handle special version packet
- if (msg.question.qtype == 'TXT' and
- msg.question.qclass == 'CH'):
- if qname == 'version.bind':
- server.sendpackets([getversion(qname,
- msg.header.id,
- msg.header.rd,
- dorecursion, '1.0')],addr)
- elif qname == 'version.oak':
- server.sendpackets([getversion(qname,
- msg.header.id,
- msg.header.rd,
- dorecursion, '1.0')],addr)
- return
- self.zdb.lookup(zkeys, msg, addr, server, dorecursion,
- flist, self.lookup_callback)
-
- def lookup_callback(self, msg, addr, server, dorecursion, flist, answerlist):
- if answerlist:
- server.sendpackets(self.config.outpackets(answerlist), addr)
- elif dorecursion:
- if msg.question.qtype in ['AXFR','IXFR']:
- if msg.question.qname == 'cache' and msg.question.qtype == 'AXFR':
- if self.resolver:
- server.sendpackets(self.resolver.cache.zonetrans(msg.header.id),addr)
- else:
- # won't forward zone transfers and
- # don't handle recursive zone transfers
- server.sendpackets([self.error(msg.header.id, msg.question.qname,
- msg.question.qtype,
- msg.question.qclass,2)],addr)
- else:
- self.resolver.handle_query(msg, addr, flist, server.sendpackets)
-
- def reap(self):
- log(4,'in nameserver reap')
- # do all maintenence (interval) stuff here
- if self.resolver:
- self.resolver.reap()
- self.notify()
- curtime = time.time()
- if curtime > (self.last_reap_time + self.maint_int):
- self.last_reap_time = curtime
- # do zone transfers here if slave server and haven't asked for soa
- for (zkey, origin, masterip) in self.zdb.getslaves(curtime):
- if not self.askedsoa.has_key(zkey):
- self.need_zonetransfer(zkey, origin, masterip)
- for zkey in self.askedsoa.keys():
- if curtime > self.askedsoa[zkey]['senttime'] + self.soatimeout:
- if self.askedsoa[zkey]['trynum'] > 3:
- self.zdb.remove_zone(zkey)
- del self.askedsoa[zkey]
- else:
- masterip = self.askedsoa[zkey]['masterip']
- origin = self.askedsoa[zkey]['origin']
- trynum = self.askedsoa[zkey]['trynum']
- del self.askedsoa[zkey]
- self.need_zonetransfer(zkey, origin, masterip, trynum)
-
- def log_info (self, message, type='info'):
- if __debug__ or type != 'info':
- log(0,'%s: %s' % (type, message))
-
-class resolver(asyncore.dispatcher):
- def __init__(self, cache, port=0):
- asyncore.dispatcher.__init__(self)
- self.create_socket(socket.AF_INET, socket.SOCK_DGRAM)
- self.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 200 * 1024)
- self.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 200 * 1024)
- self.bind(('',port))
- self.cache = cache
- self.outqnum = 0
- self.outq = {}
- self.holdq = {}
- self.holdtime = 10
- self.holdqlength = 100
- self.last_reap_time = time.time()
- self.maint_int = 10
- self.timeout = 3
-
- def getoutqkey(self):
- self.outqnum = self.outqnum + 1
- if self.outqnum == 99999:
- self.outqnum = 1
- return str(self.outqnum)
-
- def error(self, id, qname, querytype, queryclass, rcode):
- error = message()
- error.header.id = id
- error.header.rcode = rcode
- error.header.qr = 1
- error.question.qname = qname
- error.question.qtype = querytype
- error.question.qclass = queryclass
- return error
-
- def qpacket(self, id, qname, querytype, queryclass):
- # create a question
- query = message()
- query.header.id = id
- query.header.rd = 0
- query.question.qname = qname
- query.question.qtype = querytype
- query.question.qclass = queryclass
- return query
-
- def send_to(self, msglist, addr):
- for msg in msglist:
- data = msg.buildpkt()
- if len(data) > 512:
- # packet to big
- msg.header.tc = 1
- msg.header.ancount = 0
- msg.answerlist = []
- msg.header.nscount = 0
- msg.authlist = []
- msg.header.arcount = 0
- msg.addlist = []
- self.socket.sendto(msg.buildpkt(), addr)
- else:
- self.socket.sendto(data, addr)
-
- def handle_read(self):
- try:
- while 1:
- msgdata, addr = self.socket.recvfrom(1500)
- # should put 'try' here in production server
- self.handle_packet(msgdata, addr)
- except socket.error, why:
- if why[0] != asyncore.EWOULDBLOCK:
- raise socket.error, why
-
- def handle_packet(self, msgdata, addr):
- try:
- msg = message(msgdata)
- except:
- return
- if not msg.header.qr:
- self.handle_query(msg, addr, [], self.send_to)
- else:
- log(2,'received unsolicited reply')
-
-
- def handle_query(self, msg, addr, flist, cbfunc):
- qname = msg.question.qname
- querytype = msg.question.qtype
- queryclass = msg.question.qclass
- # check the cache first
- answer = self.cache.haskey(qname,querytype,msg)
- if answer:
- cbfunc([answer], addr)
- log(2,'sent answer for ' + qname + '(' + querytype +
- ') from cache')
- else:
- # check if query is already in progess
- for oqkey in self.outq.keys():
- if (self.outq[oqkey]['qname'] == qname and
- self.outq[oqkey]['querytype'] == querytype):
- log(2,'query already in progress for '+qname+'('+querytype+')')
- # put entry in hold queue to try later
- hqrec = {'processtime':time.time()+self.holdtime,
- 'query':msg,'addr':addr,
- 'qname':qname,'querytype':querytype,
- 'queryclass':queryclass,
- 'cbfunc':cbfunc}
- self.putonhold(hqrec)
- return
-
- outqkey = self.getoutqkey()+str(msg.header.id)
- self.outq[outqkey] = {'query':msg,
- 'addr':addr,
- 'qname':qname,
- 'querytype':querytype,
- 'queryclass':queryclass,
- 'cbfunc':cbfunc,
- 'answerlist':[],
- 'addlist':[],
- 'qsent':0}
- if flist:
- self.outq[outqkey]['flist'] = flist
- self.askfns(outqkey)
- else:
- self.askns(outqkey)
-
- def putonhold(self,hqrec):
- hqid = hqrec['qname']+hqrec['querytype']
- if self.holdq.has_key(hqid):
- if len(self.holdq[hqid]) < self.holdqlength:
- hqrec['processtime']=time.time()+self.holdtime
- self.holdq[hqid].append(hqrec)
-
-
- def askns(self, outqkey):
- qname = self.outq[outqkey]['qname']
- querytype = self.outq[outqkey]['querytype']
- queryclass = self.outq[outqkey]['queryclass']
- # don't try more than 10 times to avoid loops
- if self.outq[outqkey]['qsent'] == 10:
- del self.outq[outqkey]
- log(2,'Dropping query for ' + qname + '(' + querytype + ')' +
- ' POSSIBLE LOOP')
- return
- # find the best nameservers to ask from the cache
- (qzone, nsdict) = self.cache.getnslist(qname)
- if not nsdict:
- # there are no good servers
- if self.outq[outqkey]['addr'] != 'IQ':
- qid = self.outq[outqkey]['query'].header.id
- self.outq[outqkey]['cbfunc'](self.error(qid,qname,querytype,queryclass,2),
- self.outq[outqkey]['addr'])
- del self.outq[outqkey]
- log(2,'Dropping query for ' + qname + '(' + querytype + ')' +
- 'no good name servers to ask')
- return
- # pick the best nameserver
- rtts = nsdict.keys()
- rtts.sort()
- bestnsip = nsdict[rtts[0]]['ip']
- bestnsname = nsdict[rtts[0]]['name']
- # fill in the callback data structure
- id=random.randrange(1,32768)
- self.outq[outqkey]['nsqueriedlastip'] = bestnsip
- self.outq[outqkey]['nsqueriedlastname'] = bestnsname
- self.outq[outqkey]['nsdict'] = nsdict
- self.outq[outqkey]['qzone'] = qzone
- self.outq[outqkey]['qsenttime'] = time.time()
- self.outq[outqkey]['qsent'] = self.outq[outqkey]['qsent'] + 1
- # self.socket.sendto(self.qpacket(id,qname,querytype,queryclass), (bestnsip,53))
- self.outq[outqkey]['request'] = simpleudprequest(self.qpacket(id,qname,querytype,queryclass),
- self.handle_response, bestnsip, outqkey)
- # update rtt so that we ask a different server next time
- self.cache.updatertt(bestnsname,qzone,1)
- log(2,outqkey+'|sent query to ' + bestnsip + '(' + bestnsname +
- ') for ' + qname + '(' + querytype + ')')
-
- def askfns(self, outqkey):
- flist = self.outq[outqkey]['flist']
- qname = self.outq[outqkey]['qname']
- querytype = self.outq[outqkey]['querytype']
- queryclass = self.outq[outqkey]['queryclass']
- self.outq[outqkey]['qsenttime'] = time.time()
- id=random.randrange(1,32768)
- # self.socket.sendto(self.qpacket(id,qname,querytype,queryclass), (flist[0],53))
- self.outq[outqkey]['request'] = simpleudprequest(self.qpacket(id,qname,querytype,queryclass),
- self.handle_fresponse, flist[0], outqkey)
- log(2,''+outqkey+'|sent query to forwarder')
-
- def handle_response(self, msg, outqkey):
- # either reponse:
- # 1. contains a name error
- # 2. answers the question
- # (cache data and return it)
- # 3. is (contains) a CNAME and qtype isn't
- # (cache cname and change qname to it)
- # (check if qname and qtype are in any other rrs in the response)
- # (must check cache again here)
- # 4. contains a better delegation
- # (cache the delegation and start again)
- # 5. is aserver failure
- # (delete server from list and try again)
-
- # make sure that original question is still outstanding
- if not self.outq.has_key(outqkey):
- # should never get here
- # if we do we aren't doing housekeeping of callbacks very well
- log(2,''+outqkey+'|got response for a question already answered for ' + msg.question.qname)
- return
-
- querytype = self.outq[outqkey]['querytype']
- if msg.header.rcode not in [1,2,4,5]:
- # update rtt time
- rtt = time.time() - self.outq[outqkey]['qsenttime']
- nsname = self.outq[outqkey]['nsqueriedlastname']
- zone = self.outq[outqkey]['qzone']
- self.cache.updatertt(nsname,zone,rtt)
-
- if msg.header.rcode == 3:
- log(2,outqkey+'|GOT Name Error for ' + msg.question.qname +
- '(' + msg.question.qtype + ')')
- # name error
- # cache negative answer
- self.cache.addneg(self.outq[outqkey]['qname'],
- self.outq[outqkey]['querytype'],
- self.outq[outqkey]['queryclass'])
- if self.outq[outqkey]['addr'] != 'IQ':
- answer = message()
- answer.question.qname = self.outq[outqkey]['query'].question.qname
- answer.question.qtype = self.outq[outqkey]['query'].question.qtype
- answer.question.qclass = self.outq[outqkey]['query'].question.qclass
- answer.header.id = self.outq[outqkey]['query'].header.id
- answer.header.qr = 1
- answer.header.opcode = self.outq[outqkey]['query'].header.opcode
- answer.header.ra = 1
- self.outq[outqkey]['cbfunc']([answer], self.outq[outqkey]['addr'])
- del self.outq[outqkey]
-
- elif msg.header.ancount > 0:
- # answer (may be CNAME)
- haveanswer = 0
- cname = ''
- log(2,'CACHING ANSWERLIST ENTRIES')
- for rr in msg.answerlist:
- rrname = rr.keys()[0]
- rrtype = rr[rrname].keys()[0]
- if ((rrname == msg.question.qname or rrname == cname ) and
- rrtype == msg.question.qtype):
- haveanswer = 1
- if rrname == msg.question.qname and rrtype == 'CNAME':
- cname = rr[rrname][rrtype][0]['cname']
- self.cache.add(rr, self.outq[outqkey]['qzone'],
- self.outq[outqkey]['nsqueriedlastname'])
- if haveanswer:
- if self.outq[outqkey]['addr'] != 'IQ':
- log(2,''+outqkey+'|GOT Answer for ' + msg.question.qname +
- '(' + msg.question.qtype + ')' )
- answer = message()
- answer.answerlist = msg.answerlist + self.outq[outqkey]['answerlist']
- answer.header.ancount = len(answer.answerlist)
- answer.question.qname = self.outq[outqkey]['query'].question.qname
- answer.question.qtype = self.outq[outqkey]['query'].question.qtype
- answer.question.qclass = self.outq[outqkey]['query'].question.qclass
- answer.header.id = self.outq[outqkey]['query'].header.id
- answer.header.qr = 1
- answer.header.opcode = self.outq[outqkey]['query'].header.opcode
- answer.header.ra = 1
- self.outq[outqkey]['cbfunc']([answer], self.outq[outqkey]['addr'])
- log(2,outqkey+'|sent answer retrieved from remote server for ' +
- self.outq[outqkey]['query'].question.qname)
- else:
- log(2,outqkey+'|GOT Answer(IQ) for ' + msg.question.qname + '(' +
- msg.question.qtype + ')')
- del self.outq[outqkey]
- elif cname:
- log(2,outqkey+'|GOT CNAME for ' + msg.question.qname + '(' + msg.question.qtype + ')')
- self.outq[outqkey]['answerlist'] = self.outq[outqkey]['answerlist'] + msg.answerlist
- self.outq[outqkey]['qname'] = cname
- self.askns(outqkey)
- else:
- log(2,outqkey+'|GOT BOGUS answer for ' + msg.question.qname + '(' +
- msg.question.qtype + ')')
- del self.outq[outqkey]
-
- elif msg.header.nscount > 0 and msg.header.ancount == 0:
- log(2,outqkey+'|GOT DELEGATION for ' + msg.question.qname + '(' + msg.question.qtype + ')')
- # delegation
- # cache the nameserver rrs and start over
- # if there are no glue records for nameservers must fetch them first
- log(2,'CACHING AUTHLIST ENTRIES')
- for rr in msg.authlist:
- self.cache.add(rr,self.outq[outqkey]['qzone'],self.outq[outqkey]['nsqueriedlastname'])
- log(2,'CACHING ADDLIST ENTRIES')
- for rr in msg.addlist:
- self.cache.add(rr,self.outq[outqkey]['qzone'],self.outq[outqkey]['nsqueriedlastname'])
- rrlist = msg.authlist+msg.addlist
- fetchglue = 0
- nscount = 0
- for rr in msg.authlist:
- nodename = rr.keys()[0]
- if rr[nodename].keys()[0] == 'NS':
- nscount = nscount + 1
- nsdname = rr[nodename]['NS'][0]['nsdname']
- if not self.cache.haskey(nsdname,'A'):
- log(2,outqkey+'|Glue record not in cache for ' + nsdname + '(A)')
- fetchglue = fetchglue + 1
- # need to fetch A rec
- noutqkey = self.getoutqkey()+str(random.randrange(1,32768))
- self.outq[noutqkey] = {'query':'',
- 'addr':'IQ',
- 'qname':nsdname,
- 'querytype':'A',
- 'queryclass':'IN',
- 'qsent':0}
- log(2,outqkey+'|sending a query to fetch glue records for ' + nsdname + '(A)')
- self.askns(noutqkey)
- if not nscount:
- log(2,outqkey+'|Dropping query (no ns recs) for ' +
- msg.question.qname + '(' + msg.question.qtype + ')' )
- del self.outq[outqkey]
- elif fetchglue == nscount:
- log(2,outqkey+'|Stalling query (no glue recs) for ' +
- msg.question.qname + '(' + msg.question.qtype + ')')
- self.putonhold(self.outq[outqkey])
- del self.outq[outqkey]
- else:
- log(2,outqkey+'|got (some) glue with delegation')
- self.askns(outqkey)
-
- elif msg.header.rcode in [1,2,4,5]:
- log(2,outqkey+'|GOT ' + getrcode(msg.header.rcode))
- log(2,'SERVER ' + self.outq[outqkey]['nsqueriedlastname'] + '(' +
- self.outq[outqkey]['nsqueriedlastip'] + ') FAILURE for ' + msg.question.qname)
- # don't ask this server for a while
- self.cache.badns(self.outq[outqkey]['qzone'],self.outq[outqkey]['nsqueriedlastname'])
- self.askns(outqkey)
- else:
- log(2,outqkey+'|GOT UNPARSEABLE REPLY')
- msg.printpkt()
-
- def handle_fresponse(self, msg, outqkey):
- if msg.header.rcode in [1,2,4,5]:
- self.outq[outqkey]['flist'].pop(0)
- if len(self.outq[outqkey]['flist']) == 0:
- qid = self.outq[outqkey]['query'].header.id
- qname = self.outq[outqkey]['qname']
- querytype = self.outq[outqkey]['querytype']
- queryclass = self.outq[outqkey]['queryclass']
- self.outq[outqkey]['cbfunc'](self.error(qid,qname,querytype,queryclass,2),
- self.outq[outqkey]['addr'])
- del self.outq[outqkey]
- else:
- self.askfns(outqkey)
- else:
- answer = message()
- answer.header.id = self.outq[outqkey]['query'].header.id
- answer.header.qr = 1
- answer.header.opcode = self.outq[outqkey]['query'].header.opcode
- answer.header.ra = 1
- answer.question.qname = self.outq[outqkey]['query'].question.qname
- answer.question.qtype = self.outq[outqkey]['query'].question.qtype
- answer.question.qclass = self.outq[outqkey]['query'].question.qclass
- answer.header.ancount = msg.header.ancount
- answer.header.nscount = msg.header.nscount
- answer.header.arcount = msg.header.arcount
- answer.answerlist = msg.answerlist
- answer.authlist = msg.authlist
- answer.addlist = msg.addlist
- if msg.header.rcode == 3:
- # name error
- # cache negative answer
- self.cache.addneg(self.outq[outqkey]['qname'],
- self.outq[outqkey]['querytype'],
- self.outq[outqkey]['queryclass'])
- else:
- # cache all rrs
- for rr in msg.answerlist:
- self.cache.add(rr,'','forwarder')
- for rr in msg.authlist:
- self.cache.add(rr,'','forwarder')
- for rr in msg.addlist:
- self.cache.add(rr,'','forwarder')
- self.outq[outqkey]['cbfunc']([answer], self.outq[outqkey]['addr'])
- del self.outq[outqkey]
-
- def writable(self):
- return 0
-
- def handle_write(self):
- pass
-
- def handle_connect(self):
- pass
-
- def handle_close(self):
- # print '1:In handle close'
- return
-
- def process_holdq(self):
- curtime = time.time()
- for hqkey in self.holdq.keys():
- for hqrec in self.holdq[hqkey]:
- if curtime >= hqrec['processtime']:
- log(2,'processing held query')
- answer = self.cache.haskey(hqrec['qname'],
- hqrec['querytype'],
- hqrec['query'])
- if answer:
- hqrec['cbfunc']([answer], hqrec['addr'])
- log(2,'sent answer for ' + hqrec['qname'] +
- '(' + hqrec['querytype'] + ') from cache')
- self.holdq[hqkey].remove(hqrec)
- if len(self.holdq[hqkey]) == 0:
- del self.holdq[hqkey]
-
- def reap(self):
- self.process_holdq()
- curtime = time.time()
- log(3,timestamp() + 'processed HOLDQ (sockets: ' +
- str(len(asyncore.socket_map.keys()))+')')
- if curtime > (self.last_reap_time + self.maint_int):
- self.last_reap_time = curtime
- for outqkey in self.outq.keys():
- if curtime > self.outq[outqkey]['qsenttime'] + self.timeout:
- log(2,'query for '+self.outq[outqkey]['qname']+'('+
- self.outq[outqkey]['querytype']+') expired')
- # don't set forwarders as bad
- if not self.outq[outqkey].has_key('flist'):
- self.cache.badns(self.outq[outqkey]['qzone'],
- self.outq[outqkey]['nsqueriedlastname'])
- if self.outq[outqkey].has_key('request'):
- log(3,'closing socket for expired query')
- self.outq[outqkey]['request'].close()
- del self.outq[outqkey]
- return
-
- def log_info (self, message, type='info'):
- if __debug__ or type != 'info':
- log(0,'%s: %s' % (type, message))
-
-
-def run(configobj):
- global loglevel
- r = resolver(dnscache(configobj.cached))
- ns = nameserver(r, configobj)
- udpds = udpdnsserver(53, ns)
- tcpds = tcpdnsserver(53, ns)
- loglevel = configobj.loglevel
- try:
- loop(ns.reap)
- except KeyboardInterrupt:
- print 'server done'
-
-if __name__ == '__main__':
- sipb_xen_database.connect('postgres://sipb-xen@sipb-xen-dev/sipb_xen')
- zonedict = {'example.net':{'origin':'example.net',
- 'filename':'db.example.net',
- 'type':'master',
- 'slaves':[]}}
-
-
- zonedict = {'servers.csail.mit.edu':{'origin':'servers.csail.mit.edu',
- 'filename':'db.servers.csail.mit.edu',
- 'type':'master',
- 'slaves':[]}}
-
- zonedict2 = {'example.net':{'origin':'example.net',
- 'filename':'db.example.net',
- 'type':'slave',
- 'masterip':'127.0.0.1'}}
- readzonefiles(zonedict)
- lconfig = dnsconfig()
- lconfig.zonedatabase = zonedb(zonedict)
- pr = zonefileparser()
- pr.parse('','db.ca')
- lconfig.cached = pr.getzdict()
- lconfig.loglevel = 3
-
- run(lconfig)
projects / invirt/packages/invirt-dns.git / commitdiff
