Maximum CD 2011 October/maximum-cd-2011-10.iso/DiscContents/digsby_setup.exe/lib/dns/resolver.pyo

Python Compiled Bytecode | 2011-06-22 | 13.9 KB | 596 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.6)

import socket
import sys
import time
import dns.exception as dns
import dns.message as dns
import dns.name as dns
import dns.query as dns
import dns.rcode as dns
import dns.rdataclass as dns
import dns.rdatatype as dns
if sys.platform == 'win32':
    import _winreg


class NXDOMAIN(dns.exception.DNSException):
    pass

Timeout = dns.exception.Timeout

class NoAnswer(dns.exception.DNSException):
    pass


class NoNameservers(dns.exception.DNSException):
    pass


class NotAbsolute(dns.exception.DNSException):
    pass


class NoRootSOA(dns.exception.DNSException):
    pass


class Answer(object):

    def __init__(self, qname, rdtype, rdclass, response):
        self.qname = qname
        self.rdtype = rdtype
        self.rdclass = rdclass
        self.response = response
        min_ttl = -1
        rrset = None
        for count in xrange(0, 15):

            try:
                rrset = response.find_rrset(response.answer, qname, rdclass, rdtype)
                if min_ttl == -1 or rrset.ttl < min_ttl:
                    min_ttl = rrset.ttl

            continue
            except KeyError:
                if rdtype != dns.rdatatype.CNAME:

                    try:
                        crrset = response.find_rrset(response.answer, qname, rdclass, dns.rdatatype.CNAME)
                        if min_ttl == -1 or crrset.ttl < min_ttl:
                            min_ttl = crrset.ttl

                        for rd in crrset:
                            qname = rd.target

                    except KeyError:
                        raise NoAnswer
                    except:
                        None<EXCEPTION MATCH>KeyError


                None<EXCEPTION MATCH>KeyError
                raise NoAnswer
                continue



        if rrset is None:
            raise NoAnswer
        rrset is None
        self.rrset = rrset
        self.expiration = time.time() + min_ttl


    def __getattr__(self, attr):
        if attr == 'name':
            return self.rrset.name
        if attr == 'ttl':
            return self.rrset.ttl
        if attr == 'covers':
            return self.rrset.covers
        if attr == 'rdclass':
            return self.rrset.rdclass
        if attr == 'rdtype':
            return self.rrset.rdtype
        raise AttributeError(attr)


    def __len__(self):
        return len(self.rrset)


    def __iter__(self):
        return iter(self.rrset)


    def __getitem__(self, i):
        return self.rrset[i]


    def __delitem__(self, i):
        del self.rrset[i]


    def __getslice__(self, i, j):
        return self.rrset[i:j]


    def __delslice__(self, i, j):
        del self.rrset[i:j]



class Cache(object):

    def __init__(self, cleaning_interval = 300):
        self.data = { }
        self.cleaning_interval = cleaning_interval
        self.next_cleaning = time.time() + self.cleaning_interval


    def maybe_clean(self):
        now = time.time()
        if self.next_cleaning <= now:
            keys_to_delete = []
            for k, v in self.data.iteritems():
                if v.expiration <= now:
                    keys_to_delete.append(k)
                    continue

            for k in keys_to_delete:
                del self.data[k]

            now = time.time()
            self.next_cleaning = now + self.cleaning_interval



    def get(self, key):
        self.maybe_clean()
        v = self.data.get(key)
        if v is None or v.expiration <= time.time():
            return None
        return v


    def put(self, key, value):
        self.maybe_clean()
        self.data[key] = value


    def flush(self, key = None):
        if key is not None:
            if self.data.has_key(key):
                del self.data[key]

        else:
            self.data = { }
            self.next_cleaning = time.time() + self.cleaning_interval



class Resolver(object):

    def __init__(self, filename = '/etc/resolv.conf', configure = True):
        self.reset()
        if configure:
            if sys.platform == 'win32':
                self.read_registry()
            elif filename:
                self.read_resolv_conf(filename)




    def reset(self):
        self.domain = dns.name.Name(dns.name.from_text(socket.gethostname())[1:])
        if len(self.domain) == 0:
            self.domain = dns.name.root

        self.nameservers = []
        self.search = []
        self.port = 53
        self.timeout = 2
        self.lifetime = 30
        self.keyring = None
        self.keyname = None
        self.keyalgorithm = dns.tsig.default_algorithm
        self.edns = -1
        self.ednsflags = 0
        self.payload = 0
        self.cache = None


    def read_resolv_conf(self, f):
        if isinstance(f, str) or isinstance(f, unicode):

            try:
                f = open(f, 'r')
            except IOError:
                self.nameservers = [
                    '127.0.0.1']
                return None

            want_close = True
        else:
            want_close = False

        try:
            for l in f:
                if len(l) == 0 and l[0] == '#' or l[0] == ';':
                    continue

                tokens = l.split()
                if len(tokens) == 0:
                    continue

                if tokens[0] == 'nameserver':
                    self.nameservers.append(tokens[1])
                    continue
                if tokens[0] == 'domain':
                    self.domain = dns.name.from_text(tokens[1])
                    continue
                if tokens[0] == 'search':
                    for suffix in tokens[1:]:
                        self.search.append(dns.name.from_text(suffix))

        finally:
            if want_close:
                f.close()


        if len(self.nameservers) == 0:
            self.nameservers.append('127.0.0.1')



    def _determine_split_char(self, entry):
        if entry.find(' ') >= 0:
            split_char = ' '
        elif entry.find(',') >= 0:
            split_char = ','
        else:
            split_char = ' '
        return split_char


    def _config_win32_nameservers(self, nameservers):
        nameservers = str(nameservers)
        split_char = self._determine_split_char(nameservers)
        ns_list = nameservers.split(split_char)
        for ns in ns_list:
            if ns not in self.nameservers:
                self.nameservers.append(ns)
                continue



    def _config_win32_domain(self, domain):
        self.domain = dns.name.from_text(str(domain))


    def _config_win32_search(self, search):
        search = str(search)
        split_char = self._determine_split_char(search)
        search_list = search.split(split_char)
        for s in search_list:
            if s not in self.search:
                self.search.append(dns.name.from_text(s))
                continue



    def _config_win32_fromkey(self, key):

        try:
            (servers, rtype) = _winreg.QueryValueEx(key, 'NameServer')
        except WindowsError:
            servers = None

        if servers:
            self._config_win32_nameservers(servers)

            try:
                (dom, rtype) = _winreg.QueryValueEx(key, 'Domain')
                if dom:
                    self._config_win32_domain(dom)
            except WindowsError:
                pass
            except:
                None<EXCEPTION MATCH>WindowsError


        None<EXCEPTION MATCH>WindowsError

        try:
            (servers, rtype) = _winreg.QueryValueEx(key, 'DhcpNameServer')
        except WindowsError:
            servers = None

        if servers:
            self._config_win32_nameservers(servers)

            try:
                (dom, rtype) = _winreg.QueryValueEx(key, 'DhcpDomain')
                if dom:
                    self._config_win32_domain(dom)
            except WindowsError:
                pass
            except:
                None<EXCEPTION MATCH>WindowsError


        None<EXCEPTION MATCH>WindowsError

        try:
            (search, rtype) = _winreg.QueryValueEx(key, 'SearchList')
        except WindowsError:
            search = None

        if search:
            self._config_win32_search(search)



    def read_registry(self):
        lm = _winreg.ConnectRegistry(None, _winreg.HKEY_LOCAL_MACHINE)
        want_scan = False

        try:
            tcp_params = _winreg.OpenKey(lm, 'SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters')
            want_scan = True
        except EnvironmentError:
            tcp_params = _winreg.OpenKey(lm, 'SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP')



        try:
            self._config_win32_fromkey(tcp_params)
        finally:
            tcp_params.Close()

        if want_scan:
            interfaces = _winreg.OpenKey(lm, 'SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces')

            try:
                i = 0
                while True:

                    try:
                        guid = _winreg.EnumKey(interfaces, i)
                        i += 1
                        key = _winreg.OpenKey(interfaces, guid)
                        if not self._win32_is_nic_enabled(lm, guid, key):
                            continue


                        try:
                            self._config_win32_fromkey(key)
                        finally:
                            key.Close()

                    continue
                    except EnvironmentError:
                        break
                        continue


                    None<EXCEPTION MATCH>EnvironmentError
            finally:
                interfaces.Close()

        lm.Close()


    def _win32_is_nic_enabled(self, lm, guid, interface_key):

        try:
            connection_key = _winreg.OpenKey(lm, 'SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection' % guid)

            try:
                (pnp_id, ttype) = _winreg.QueryValueEx(connection_key, 'PnpInstanceID')
                if ttype != _winreg.REG_SZ:
                    raise ValueError
                ttype != _winreg.REG_SZ
                device_key = _winreg.OpenKey(lm, 'SYSTEM\\CurrentControlSet\\Enum\\%s' % pnp_id)

                try:
                    (flags, ttype) = _winreg.QueryValueEx(device_key, 'ConfigFlags')
                    if ttype != _winreg.REG_DWORD:
                        raise ValueError
                    ttype != _winreg.REG_DWORD
                    return not (flags & 1)
                finally:
                    device_key.Close()

            finally:
                connection_key.Close()

        except (EnvironmentError, ValueError):

            try:
                (nte, ttype) = _winreg.QueryValueEx(interface_key, 'NTEContextList')
                return nte is not None
            except WindowsError:
                return False


            None<EXCEPTION MATCH>WindowsError



    def _compute_timeout(self, start):
        now = time.time()
        if now < start:
            if start - now > 1:
                raise Timeout
            start - now > 1
            now = start

        duration = now - start
        if duration >= self.lifetime:
            raise Timeout
        duration >= self.lifetime
        return min(self.lifetime - duration, self.timeout)


    def query(self, qname, rdtype = dns.rdatatype.A, rdclass = dns.rdataclass.IN, tcp = False, source = None):
        if isinstance(qname, (str, unicode)):
            qname = dns.name.from_text(qname, None)

        if isinstance(rdtype, str):
            rdtype = dns.rdatatype.from_text(rdtype)

        if isinstance(rdclass, str):
            rdclass = dns.rdataclass.from_text(rdclass)

        qnames_to_try = []
        if qname.is_absolute():
            qnames_to_try.append(qname)
        elif len(qname) > 1:
            qnames_to_try.append(qname.concatenate(dns.name.root))

        if self.search:
            for suffix in self.search:
                qnames_to_try.append(qname.concatenate(suffix))

        else:
            qnames_to_try.append(qname.concatenate(self.domain))
        all_nxdomain = True
        start = time.time()
        for qname in qnames_to_try:
            if self.cache:
                answer = self.cache.get((qname, rdtype, rdclass))
                if answer:
                    return answer

            request = dns.message.make_query(qname, rdtype, rdclass)
            if self.keyname is not None:
                request.use_tsig(self.keyring, self.keyname, algorithm = self.keyalgorithm)

            request.use_edns(self.edns, self.ednsflags, self.payload)
            response = None
            nameservers = self.nameservers[:]
            backoff = 0.1
            while response is None:
                if len(nameservers) == 0:
                    raise NoNameservers
                len(nameservers) == 0
                for nameserver in nameservers[:]:
                    timeout = self._compute_timeout(start)

                    try:
                        if tcp:
                            response = dns.query.tcp(request, nameserver, timeout, self.port, source = source)
                        else:
                            response = dns.query.udp(request, nameserver, timeout, self.port, source = source)
                    except (socket.error, dns.exception.Timeout):
                        response = None
                        continue
                    except dns.query.UnexpectedSource:
                        response = None
                        continue
                    except dns.exception.FormError:
                        nameservers.remove(nameserver)
                        response = None
                        continue

                    rcode = response.rcode()
                    if rcode == dns.rcode.NOERROR or rcode == dns.rcode.NXDOMAIN:
                        break

                    if rcode != dns.rcode.SERVFAIL:
                        nameservers.remove(nameserver)

                    response = None

                if response is not None:
                    break

                if len(nameservers) > 0:
                    timeout = self._compute_timeout(start)
                    sleep_time = min(timeout, backoff)
                    backoff *= 2
                    time.sleep(sleep_time)
                    continue
            if response.rcode() == dns.rcode.NXDOMAIN:
                continue

            all_nxdomain = False

        if all_nxdomain:
            raise NXDOMAIN
        all_nxdomain
        answer = Answer(qname, rdtype, rdclass, response)
        if self.cache:
            self.cache.put((qname, rdtype, rdclass), answer)

        return answer


    def use_tsig(self, keyring, keyname = None, algorithm = dns.tsig.default_algorithm):
        self.keyring = keyring
        if keyname is None:
            self.keyname = self.keyring.keys()[0]
        else:
            self.keyname = keyname
        self.keyalgorithm = algorithm


    def use_edns(self, edns, ednsflags, payload):
        if edns is None:
            edns = -1

        self.edns = edns
        self.ednsflags = ednsflags
        self.payload = payload


default_resolver = None

def get_default_resolver():
    global default_resolver
    if default_resolver is None:
        default_resolver = Resolver()

    return default_resolver


def query(qname, rdtype = dns.rdatatype.A, rdclass = dns.rdataclass.IN, tcp = False, source = None):
    return get_default_resolver().query(qname, rdtype, rdclass, tcp, source)


def zone_for_name(name, rdclass = dns.rdataclass.IN, tcp = False, resolver = None):
    if isinstance(name, (str, unicode)):
        name = dns.name.from_text(name, dns.name.root)

    if resolver is None:
        resolver = get_default_resolver()

    if not name.is_absolute():
        raise NotAbsolute(name)
    name.is_absolute()
    while None:

        try:
            answer = resolver.query(name, dns.rdatatype.SOA, rdclass, tcp)
            return name
        continue
        except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):

            try:
                name = name.parent()
            except dns.name.NoParent:
                raise NoRootSOA
            except:
                None<EXCEPTION MATCH>dns.name.NoParent


            None<EXCEPTION MATCH>dns.name.NoParent


        return None