File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/names.zip
Back
PK y�Z.{sa�# �# srvconnect.pynu �[��� # -*- test-case-name: twisted.names.test.test_srvconnect -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import random from zope.interface import implementer from twisted.internet import error, interfaces from twisted.names import client, dns from twisted.names.error import DNSNameError from twisted.python.compat import nativeString class _SRVConnector_ClientFactoryWrapper: def __init__(self, connector, wrappedFactory): self.__connector = connector self.__wrappedFactory = wrappedFactory def startedConnecting(self, connector): self.__wrappedFactory.startedConnecting(self.__connector) def clientConnectionFailed(self, connector, reason): self.__connector.connectionFailed(reason) def clientConnectionLost(self, connector, reason): self.__connector.connectionLost(reason) def __getattr__(self, key): return getattr(self.__wrappedFactory, key) @implementer(interfaces.IConnector) class SRVConnector: """ A connector that looks up DNS SRV records. RFC 2782 details how SRV records should be interpreted and selected for subsequent connection attempts. The algorithm for using the records' priority and weight is implemented in L{pickServer}. @ivar servers: List of candidate server records for future connection attempts. @type servers: L{list} of L{dns.Record_SRV} @ivar orderedServers: List of server records that have already been tried in this round of connection attempts. @type orderedServers: L{list} of L{dns.Record_SRV} """ stopAfterDNS = 0 def __init__( self, reactor, service, domain, factory, protocol="tcp", connectFuncName="connectTCP", connectFuncArgs=(), connectFuncKwArgs={}, defaultPort=None, ): """ @param domain: The domain to connect to. If passed as a text string, it will be encoded using C{idna} encoding. @type domain: L{bytes} or L{str} @param defaultPort: Optional default port number to be used when SRV lookup fails and the service name is unknown. This should be the port number associated with the service name as defined by the IANA registry. @type defaultPort: L{int} """ self.reactor = reactor self.service = service self.domain = None if domain is None else dns.domainString(domain) self.factory = factory self.protocol = protocol self.connectFuncName = connectFuncName self.connectFuncArgs = connectFuncArgs self.connectFuncKwArgs = connectFuncKwArgs self._defaultPort = defaultPort self.connector = None self.servers = None # list of servers already used in this round: self.orderedServers = None def connect(self): """Start connection to remote server.""" self.factory.doStart() self.factory.startedConnecting(self) if not self.servers: if self.domain is None: self.connectionFailed( error.DNSLookupError("Domain is not defined."), ) return d = client.lookupService( "_%s._%s.%s" % ( nativeString(self.service), nativeString(self.protocol), nativeString(self.domain), ), ) d.addCallbacks(self._cbGotServers, self._ebGotServers) d.addCallback(lambda x, self=self: self._reallyConnect()) if self._defaultPort: d.addErrback(self._ebServiceUnknown) d.addErrback(self.connectionFailed) elif self.connector is None: self._reallyConnect() else: self.connector.connect() def _ebGotServers(self, failure): failure.trap(DNSNameError) # Some DNS servers reply with NXDOMAIN when in fact there are # just no SRV records for that domain. Act as if we just got an # empty response and use fallback. self.servers = [] self.orderedServers = [] def _cbGotServers(self, result): answers, auth, add = result if ( len(answers) == 1 and answers[0].type == dns.SRV and answers[0].payload and answers[0].payload.target == dns.Name(b".") ): # decidedly not available raise error.DNSLookupError( "Service %s not available for domain %s." % (repr(self.service), repr(self.domain)) ) self.servers = [] self.orderedServers = [] for a in answers: if a.type != dns.SRV or not a.payload: continue self.orderedServers.append(a.payload) def _ebServiceUnknown(self, failure): """ Connect to the default port when the service name is unknown. If no SRV records were found, the service name will be passed as the port. If resolving the name fails with L{error.ServiceNameUnknownError}, a final attempt is done using the default port. """ failure.trap(error.ServiceNameUnknownError) self.servers = [dns.Record_SRV(0, 0, self._defaultPort, self.domain)] self.orderedServers = [] self.connect() def pickServer(self): """ Pick the next server. This selects the next server from the list of SRV records according to their priority and weight values, as set out by the default algorithm specified in RFC 2782. At the beginning of a round, L{servers} is populated with L{orderedServers}, and the latter is made empty. L{servers} is the list of candidates, and L{orderedServers} is the list of servers that have already been tried. First, all records are ordered by priority and weight in ascending order. Then for each priority level, a running sum is calculated over the sorted list of records for that priority. Then a random value between 0 and the final sum is compared to each record in order. The first record that is greater than or equal to that random value is chosen and removed from the list of candidates for this round. @return: A tuple of target hostname and port from the chosen DNS SRV record. @rtype: L{tuple} of native L{str} and L{int} """ assert self.servers is not None assert self.orderedServers is not None if not self.servers and not self.orderedServers: # no SRV record, fall back.. return nativeString(self.domain), self.service if not self.servers and self.orderedServers: # start new round self.servers = self.orderedServers self.orderedServers = [] assert self.servers self.servers.sort(key=lambda record: (record.priority, record.weight)) minPriority = self.servers[0].priority index = 0 weightSum = 0 weightIndex = [] for x in self.servers: if x.priority == minPriority: weightSum += x.weight weightIndex.append((index, weightSum)) index += 1 rand = random.randint(0, weightSum) for index, weight in weightIndex: if weight >= rand: chosen = self.servers[index] del self.servers[index] self.orderedServers.append(chosen) return str(chosen.target), chosen.port raise RuntimeError(f"Impossible {self.__class__.__name__} pickServer result.") def _reallyConnect(self): if self.stopAfterDNS: self.stopAfterDNS = 0 return self.host, self.port = self.pickServer() assert self.host is not None, "Must have a host to connect to." assert self.port is not None, "Must have a port to connect to." connectFunc = getattr(self.reactor, self.connectFuncName) self.connector = connectFunc( self.host, self.port, _SRVConnector_ClientFactoryWrapper(self, self.factory), *self.connectFuncArgs, **self.connectFuncKwArgs, ) def stopConnecting(self): """Stop attempting to connect.""" if self.connector: self.connector.stopConnecting() else: self.stopAfterDNS = 1 def disconnect(self): """Disconnect whatever our are state is.""" if self.connector is not None: self.connector.disconnect() else: self.stopConnecting() def getDestination(self): assert self.connector return self.connector.getDestination() def connectionFailed(self, reason): self.factory.clientConnectionFailed(self, reason) self.factory.doStop() def connectionLost(self, reason): self.factory.clientConnectionLost(self, reason) self.factory.doStop() PK y�Z�� }� � tap.pynu �[��� # -*- test-case-name: twisted.names.test.test_tap -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Domain Name Server """ import os import traceback from twisted.application import internet, service from twisted.names import authority, dns, secondary, server from twisted.python import usage class Options(usage.Options): optParameters = [ ["interface", "i", "", "The interface to which to bind"], ["port", "p", "53", "The port on which to listen"], [ "resolv-conf", None, None, "Override location of resolv.conf (implies --recursive)", ], ["hosts-file", None, None, "Perform lookups with a hosts file"], ] optFlags = [ ["cache", "c", "Enable record caching"], ["recursive", "r", "Perform recursive lookups"], ["verbose", "v", "Log verbosely"], ] compData = usage.Completions( optActions={"interface": usage.CompleteNetInterfaces()} ) zones = None zonefiles = None def __init__(self): usage.Options.__init__(self) self["verbose"] = 0 self.bindfiles = [] self.zonefiles = [] self.secondaries = [] def opt_pyzone(self, filename): """Specify the filename of a Python syntax zone definition""" if not os.path.exists(filename): raise usage.UsageError(filename + ": No such file") self.zonefiles.append(filename) def opt_bindzone(self, filename): """Specify the filename of a BIND9 syntax zone definition""" if not os.path.exists(filename): raise usage.UsageError(filename + ": No such file") self.bindfiles.append(filename) def opt_secondary(self, ip_domain): """Act as secondary for the specified domain, performing zone transfers from the specified IP (IP/domain) """ args = ip_domain.split("/", 1) if len(args) != 2: raise usage.UsageError("Argument must be of the form IP[:port]/domain") address = args[0].split(":") if len(address) == 1: address = (address[0], dns.PORT) else: try: port = int(address[1]) except ValueError: raise usage.UsageError( f"Specify an integer port number, not {address[1]!r}" ) address = (address[0], port) self.secondaries.append((address, [args[1]])) def opt_verbose(self): """Increment verbosity level""" self["verbose"] += 1 def postOptions(self): if self["resolv-conf"]: self["recursive"] = True self.svcs = [] self.zones = [] for f in self.zonefiles: try: self.zones.append(authority.PySourceAuthority(f)) except Exception: traceback.print_exc() raise usage.UsageError("Invalid syntax in " + f) for f in self.bindfiles: try: self.zones.append(authority.BindAuthority(f)) except Exception: traceback.print_exc() raise usage.UsageError("Invalid syntax in " + f) for f in self.secondaries: svc = secondary.SecondaryAuthorityService.fromServerAddressAndDomains(*f) self.svcs.append(svc) self.zones.append(self.svcs[-1].getAuthority()) try: self["port"] = int(self["port"]) except ValueError: raise usage.UsageError("Invalid port: {!r}".format(self["port"])) def _buildResolvers(config): """ Build DNS resolver instances in an order which leaves recursive resolving as a last resort. @type config: L{Options} instance @param config: Parsed command-line configuration @return: Two-item tuple of a list of cache resovers and a list of client resolvers """ from twisted.names import cache, client, hosts ca, cl = [], [] if config["cache"]: ca.append(cache.CacheResolver(verbose=config["verbose"])) if config["hosts-file"]: cl.append(hosts.Resolver(file=config["hosts-file"])) if config["recursive"]: cl.append(client.createResolver(resolvconf=config["resolv-conf"])) return ca, cl def makeService(config): ca, cl = _buildResolvers(config) f = server.DNSServerFactory(config.zones, ca, cl, config["verbose"]) p = dns.DNSDatagramProtocol(f) f.noisy = 0 ret = service.MultiService() for (klass, arg) in [(internet.TCPServer, f), (internet.UDPServer, p)]: s = klass(config["port"], arg, interface=config["interface"]) s.setServiceParent(ret) for svc in config.svcs: svc.setServiceParent(ret) return ret PK y�Z�UG�z! z! $ __pycache__/_rfc1982.cpython-310.pycnu �[��� o �b�# � @ sR d Z ddlZddlmZmZ ddlmZ ddlmZ dZG dd� de�Z dgZ dS ) a� Utilities for handling RFC1982 Serial Number Arithmetic. @see: U{http://tools.ietf.org/html/rfc1982} @var RFC4034_TIME_FORMAT: RRSIG Time field presentation format. The Signature Expiration Time and Inception Time field values MUST be represented either as an unsigned decimal integer indicating seconds since 1 January 1970 00:00:00 UTC, or in the form YYYYMMDDHHmmSS in UTC. See U{RRSIG Presentation Format<https://tools.ietf.org/html/rfc4034#section-3.2>} � N)�datetime� timedelta)� nativeString)� FancyStrMixinz %Y%m%d%H%M%Sc @ s� e Zd ZdZdZd!dd�Zdedd fdd �Zdefd d �Z d d � Z dede fdd�Z dede fdd�Z dede fdd�Zdede fdd�Zdede fdd�Zdedd fdd�Zdd� Zed d � �Zd d � Zd S )"� SerialNumbera� An RFC1982 Serial Number. This class implements RFC1982 DNS Serial Number Arithmetic. SNA is used in DNS and specifically in DNSSEC as defined in RFC4034 in the DNSSEC Signature Expiration and Inception Fields. @see: U{https://tools.ietf.org/html/rfc1982} @see: U{https://tools.ietf.org/html/rfc4034} @ivar _serialBits: See C{serialBits} of L{__init__}. @ivar _number: See C{number} of L{__init__}. @ivar _modulo: The value at which wrapping will occur. @ivar _halfRing: Half C{_modulo}. If another L{SerialNumber} value is larger than this, it would lead to a wrapped value which is larger than the first and comparisons are therefore ambiguous. @ivar _maxAdd: Half C{_modulo} plus 1. If another L{SerialNumber} value is larger than this, it would lead to a wrapped value which is larger than the first. Comparisons with the original value would therefore be ambiguous. ))�_number�number�%d)� _serialBits� serialBitsr � c C sD || _ d| | _d|d | _d|d d | _t|�| j | _dS )a� Construct an L{SerialNumber} instance. @param number: An L{int} which will be stored as the modulo C{number % 2 ^ serialBits} @type number: L{int} @param serialBits: The size of the serial number space. The power of two which results in one larger than the largest integer corresponding to a serial number value. @type serialBits: L{int} � � N)r �_modulo� _halfRing�_maxAdd�intr )�selfr r � r �8/usr/lib/python3/dist-packages/twisted/names/_rfc1982.py�__init__8 s zSerialNumber.__init__�other�returnc C s> t |t�std| �d|����| j|jkr td| |f ��|S )a} Check that a foreign object is suitable for use in the comparison or arithmetic magic methods of this L{SerialNumber} instance. Raise L{TypeError} if not. @param other: The foreign L{object} to be checked. @return: C{other} after compatibility checks and possible coercion. @raise TypeError: If C{other} is not compatible. zcannot compare or combine z and zUcannot compare or combine SerialNumber instances with different serialBits. %r and %r)� isinstancer � TypeErrorr �r r r r r � _convertOtherK s ��zSerialNumber._convertOtherc C s t d| jf �S )zs Return a string representation of this L{SerialNumber} instance. @rtype: L{nativeString} r )r r �r r r r �__str__` s zSerialNumber.__str__c C s | j S )ze @return: The integer value of this L{SerialNumber} instance. @rtype: L{int} )r r r r r �__int__h s zSerialNumber.__int__c C s2 z| � |�}W n ty t Y S w |j| jkS )zW Allow rich equality comparison with another L{SerialNumber} instance. )r r �NotImplementedr r r r r �__eq__o s � zSerialNumber.__eq__c C sb z| � |�}W n ty t Y S w | j|jk o!|j| j | jk p0| j|jko0| j|j | jkS )zV Allow I{less than} comparison with another L{SerialNumber} instance. �r r r r r r r r r �__lt__y � � � �zSerialNumber.__lt__c C sb z| � |�}W n ty t Y S w | j|jk o!|j| j | jkp0| j|jko0| j|j | jk S )zY Allow I{greater than} comparison with another L{SerialNumber} instance. r" r r r r �__gt__� r$ zSerialNumber.__gt__c C s6 z| � |�}W n ty t Y S w | |kp| |k S )zg Allow I{less than or equal} comparison with another L{SerialNumber} instance. �r r r r r r r �__le__� � �zSerialNumber.__le__c C s6 z| � |�}W n ty t Y S w | |kp| |kS )zj Allow I{greater than or equal} comparison with another L{SerialNumber} instance. r& r r r r �__ge__� r( zSerialNumber.__ge__c C sb z| � |�}W n ty t Y S w |j| jkr't| j|j | j | jd�S td|j| jf ��)ab Allow I{addition} with another L{SerialNumber} instance. Serial numbers may be incremented by the addition of a positive integer n, where n is taken from the range of integers [0 .. (2^(SERIAL_BITS - 1) - 1)]. For a sequence number s, the result of such an addition, s', is defined as s' = (s + n) modulo (2 ^ SERIAL_BITS) where the addition and modulus operations here act upon values that are non-negative values of unbounded size in the usual ways of integer arithmetic. Addition of a value outside the range [0 .. (2^(SERIAL_BITS - 1) - 1)] is undefined. @see: U{http://tools.ietf.org/html/rfc1982#section-3.1} @raise ArithmeticError: If C{other} is more than C{_maxAdd} ie more than half the maximum value of this serial number. �r z"value %r outside the range 0 .. %r) r r r r r r r r �ArithmeticErrorr r r r �__add__� s" � ����zSerialNumber.__add__c C s t | j�S )zo Allow L{SerialNumber} instances to be hashed for use as L{dict} keys. @rtype: L{int} )�hashr r r r r �__hash__� s zSerialNumber.__hash__c C s& t �|t�}t�|�� �}| |dd�S )a� Create an L{SerialNumber} instance from a date string in format 'YYYYMMDDHHMMSS' described in U{RFC4034 3.2<https://tools.ietf.org/html/rfc4034#section-3.2>}. The L{SerialNumber} instance stores the date as a 32bit UNIX timestamp. @see: U{https://tools.ietf.org/html/rfc4034#section-3.1.5} @param utcDateString: A UTC date/time string of format I{YYMMDDhhmmss} which will be converted to seconds since the UNIX epoch. @type utcDateString: L{unicode} @return: An L{SerialNumber} instance containing the supplied date as a 32bit UNIX timestamp. r r* )r �strptime�RFC4034_TIME_FORMAT�calendar�timegm� utctimetuple)�cls� utcDateString� parsedDate�secondsSinceEpochr r r �fromRFC4034DateString� s z"SerialNumber.fromRFC4034DateStringc C s& t ddd�t| jd� }t|�t��S )a Calculate a date by treating the current L{SerialNumber} value as a UNIX timestamp and return a date string in the format described in U{RFC4034 3.2<https://tools.ietf.org/html/rfc4034#section-3.2>}. @return: The date string. i� r )�seconds)r r r r �strftimer0 )r �dr r r �toRFC4034DateString� s z SerialNumber.toRFC4034DateStringN)r )�__name__� __module__� __qualname__�__doc__�showAttributesr �objectr �strr r �boolr! r# r% r' r) r, r. � classmethodr8 r< r r r r r s" ) r ) r@ r1 r r �twisted.python.compatr �twisted.python.utilr r0 r �__all__r r r r �<module> s kPK y�Z��8Q� � % __pycache__/secondary.cpython-310.pycnu �[��� o �b� � @ s� d dgZ ddlmZ ddlmZmZ ddlmZmZm Z m Z ddl m Z ddl mZmZ ddlmZ G d d� dej�ZG d d � d e �Zd S ) �SecondaryAuthority�SecondaryAuthorityService� )�service)�defer�task)�client�common�dns�resolve)� FileAuthority)�failure�log)� nativeStringc @ sD e Zd ZdZdZdZdd� Zedd� �Zdd � Z d d � Z d d � Z dS )r a: A service that keeps one or more authorities up to date by doing hourly zone transfers from a master. @ivar primary: IP address of the master. @type primary: L{str} @ivar domains: An authority for each domain mirrored from the master. @type domains: L{list} of L{SecondaryAuthority} N�5 c s" t � �| _� fdd�|D �| _dS )a @param primary: The IP address of the server from which to perform zone transfers. @type primary: L{str} @param domains: A sequence of domain names for which to perform zone transfers. @type domains: L{list} of L{bytes} c s g | ]}t � |��qS � )r ��.0�d��primaryr �9/usr/lib/python3/dist-packages/twisted/names/secondary.py� <listcomp>+ s z6SecondaryAuthorityService.__init__.<locals>.<listcomp>N)r r �domains)�selfr r r r r �__init__ s z"SecondaryAuthorityService.__init__c s0 � \}}| |g �}||_ � fdd�|D �|_|S )a� Construct a new L{SecondaryAuthorityService} from a tuple giving a server address and a C{str} giving the name of a domain for which this is an authority. @param serverAddress: A two-tuple, the first element of which is a C{str} giving an IP address and the second element of which is a C{int} giving a port number. Together, these define where zone transfers will be attempted from. @param domains: Domain names for which to perform zone transfers. @type domains: sequence of L{bytes} @return: A new instance of L{SecondaryAuthorityService}. c s g | ]}t �� |��qS r )r �fromServerAddressAndDomainr �� serverAddressr r r A s ��zISecondaryAuthorityService.fromServerAddressAndDomains.<locals>.<listcomp>)�_portr )�clsr r r �portr r r r �fromServerAddressAndDomains- s �z5SecondaryAuthorityService.fromServerAddressAndDomainsc C s t �| j�S )z_ Get a resolver for the transferred domains. @rtype: L{ResolverChain} )r � ResolverChainr �r r r r � getAuthorityG s z&SecondaryAuthorityService.getAuthorityc C sV t j�| � dd� | jD �| _d}ddlm} | jD ]}|�||jd� |d7 }qd S )Nc S s g | ]}t �|j��qS r )r � LoopingCall�transferr r r r r Q s z:SecondaryAuthorityService.startService.<locals>.<listcomp>r ��reactori � ) r �Service� startServicer �calls�twisted.internetr( � callLater�start)r �ir( �cr r r r+ O s �z&SecondaryAuthorityService.startServicec C s$ t j�| � | jD ]}|�� q d S �N)r r* � stopServicer, �stop)r r1 r r r r3 Z s �z%SecondaryAuthorityService.stopService) �__name__� __module__� __qualname__�__doc__r, r r � classmethodr! r$ r+ r3 r r r r r s c @ sr e Zd ZdZdZd ZZdZdZdd� Z e dd� �Z d d � Z dd d �Z d d� Zdd� Zdd� Zdd� Zdd� ZdS )r a An Authority that keeps itself updated by performing zone transfers. @ivar primary: The IP address of the server from which zone transfers will be attempted. @type primary: L{str} @ivar _port: The port number of the server from which zone transfers will be attempted. @type _port: L{int} @ivar domain: The domain for which this is the secondary authority. @type domain: L{bytes} @ivar _reactor: The reactor to use to perform the zone transfers, or L{None} to use the global reactor. FNr c C s& t j�| � t|�| _t�|�| _dS )z� @param domain: The domain for which this will be the secondary authority. @type domain: L{bytes} or L{str} N)r � ResolverBaser r r r � domainString�domain)r � primaryIPr< r r r r x s zSecondaryAuthority.__init__c C s |\}}| ||�}||_ |S )af Construct a new L{SecondaryAuthority} from a tuple giving a server address and a C{bytes} giving the name of a domain for which this is an authority. @param serverAddress: A two-tuple, the first element of which is a C{str} giving an IP address and the second element of which is a C{int} giving a port number. Together, these define where zone transfers will be attempted from. @param domain: A C{bytes} giving the domain to transfer. @type domain: L{bytes} @return: A new instance of L{SecondaryAuthority}. )r )r r r< r r � secondaryr r r r � s z-SecondaryAuthority.fromServerAddressAndDomainc C s^ | j rdS d| _| j}|du rddlm} tj| j| jfg|d�}|� | j �� | j �� | j�S )z� Attempt a zone transfer. @returns: A L{Deferred} that fires with L{None} when attempted zone transfer has completed. NTr r' )�serversr( )� transferring� transfering�_reactorr- r( r �Resolverr r � lookupZoner< � addCallback�_cbZone� addErrback�_ebZone)r r( �resolverr r r r& � s � �zSecondaryAuthority.transferc C s4 | j r| jst�t�t�|���S t� | ||||�S r2 ) �soa�recordsr �failr �Failurer � DomainErrorr �_lookup)r �namer �type�timeoutr r r rO � s zSecondaryAuthority._lookupc C sf |\}}}i | _ }|D ]$}| js"|jtjkr"|jj�� |jf| _q |�|jj�� g �� |j� q d S r2 ) rK rJ rQ r �SOArP �lower�payload� setdefault�append)r �zone�ans�_�r�recr r r rF � s �zSecondaryAuthority._cbZonec C s$ t �d| j| jf � t �|� d S )Nz/Updating %s from %s failed during zone transfer)r �msgr< r �err�r r r r r rH � s ��zSecondaryAuthority._ebZonec C s | � � �| j| j� d S r2 )r& � addCallbacks�_cbTransferred�_ebTransferredr# r r r �update� s zSecondaryAuthority.updatec C s d| _ d S )NF)r@ )r �resultr r r ra � s z!SecondaryAuthority._cbTransferredc C s* d| _ t�d| j| jf � t�|� d S )NFz2Transferring %s from %s failed after zone transfer)� transferredr r] r< r r^ r_ r r r rb � s ��z!SecondaryAuthority._ebTransferredr2 )r5 r6 r7 r8 r@ rJ rK r rB r r9 r r& rO rF rH rc ra rb r r r r r ` s N)�__all__�twisted.applicationr r- r r � twisted.namesr r r r �twisted.names.authorityr �twisted.pythonr r �twisted.python.compatr r* r r r r r r �<module> s PPK y�ZER\w�R �R " __pycache__/server.cpython-310.pycnu �[��� o �b�V � @ sJ d Z ddlZddlmZ ddlmZmZ ddlmZ G dd� dej �Z dS )a` Async DNS server Future plans: - Better config file format maybe - Make sure to differentiate between different classes - notice truncation bit Important: No additional processing is done on some of the record types. This violates the most basic RFC and is just plain annoying for resolvers to deal with. Fix it. @author: Jp Calderone � N)�protocol)�dns�resolve)�logc @ s� e Zd ZdZejZdZejZ d$dd�Z dd� Z dd � Z d d � Z d d � Zdd� Zejdddfdd�Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd%d d!�Zd"d#� ZdS )&�DNSServerFactorya Server factory and tracker for L{DNSProtocol} connections. This class also provides records for responses to DNS queries. @ivar cache: A L{Cache<twisted.names.cache.CacheResolver>} instance whose C{cacheResult} method is called when a response is received from one of C{clients}. Defaults to L{None} if no caches are specified. See C{caches} of L{__init__} for more details. @type cache: L{Cache<twisted.names.cache.CacheResolver>} or L{None} @ivar canRecurse: A flag indicating whether this server is capable of performing recursive DNS resolution. @type canRecurse: L{bool} @ivar resolver: A L{resolve.ResolverChain} containing an ordered list of C{authorities}, C{caches} and C{clients} to which queries will be dispatched. @type resolver: L{resolve.ResolverChain} @ivar verbose: See L{__init__} @ivar connections: A list of all the connected L{DNSProtocol} instances using this object as their controller. @type connections: C{list} of L{DNSProtocol} instances @ivar protocol: A callable used for building a DNS stream protocol. Called by L{DNSServerFactory.buildProtocol} and passed the L{DNSServerFactory} instance as the one and only positional argument. Defaults to L{dns.DNSProtocol}. @type protocol: L{IProtocolFactory} constructor @ivar _messageFactory: A response message constructor with an initializer signature matching L{dns.Message.__init__}. @type _messageFactory: C{callable} Nr c C sn g }|dur |� |� |dur|� |� |dur |� |� | | _t�|�| _|| _|r2|d | _g | _dS )a� @param authorities: Resolvers which provide authoritative answers. @type authorities: L{list} of L{IResolver} providers @param caches: Resolvers which provide cached non-authoritative answers. The first cache instance is assigned to C{DNSServerFactory.cache} and its C{cacheResult} method will be called when a response is received from one of C{clients}. @type caches: L{list} of L{Cache<twisted.names.cache.CacheResolver>} instances @param clients: Resolvers which are capable of performing recursive DNS lookups. @type clients: L{list} of L{IResolver} providers @param verbose: An integer controlling the verbosity of logging of queries and responses. Default is C{0} which means no logging. Set to C{2} to enable logging of full query and response messages. @type verbose: L{int} N���)�extend� canRecurser � ResolverChain�resolver�verbose�cache� connections)�self� authorities�caches�clientsr � resolvers� r �6/usr/lib/python3/dist-packages/twisted/names/server.py�__init__E s zDNSServerFactory.__init__c O s" | j dkrtj|i |�� dS dS )z� Log a message only if verbose logging is enabled. @param args: Positional arguments which will be passed to C{log.msg} @param kwargs: Keyword arguments which will be passed to C{log.msg} r N)r r �msg)r �args�kwargsr r r � _verboseLogh s �z DNSServerFactory._verboseLogc C s | � | �}| |_|S �N)r �factory)r �addr�pr r r � buildProtocolr s z DNSServerFactory.buildProtocolc C � | j �|� dS )z� Track a newly connected L{DNSProtocol}. @param protocol: The protocol instance to be tracked. @type protocol: L{dns.DNSProtocol} N)r �append�r r r r r �connectionMadew s z DNSServerFactory.connectionMadec C r )z� Stop tracking a no-longer connected L{DNSProtocol}. @param protocol: The tracked protocol instance to be which has been lost. @type protocol: L{dns.DNSProtocol} N)r �remover" r r r �connectionLost� s z DNSServerFactory.connectionLostc C s� | j dkrCd�dd� |jD ��}d�dd� |jD ��}d�dd� |jD ��}|s.t�d� nt�d| � t�d | � t�d | � |d u rM|�|� n|�||� | �d t � � |j � d S ) a] Send a response C{message} to a given C{address} via the supplied C{protocol}. Message payload will be logged if C{DNSServerFactory.verbose} is C{>1}. @param protocol: The DNS protocol instance to which to send the message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The DNS message to be sent. @type message: L{dns.Message} @param address: The address to which the message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} � � c S � g | ]}t |j��qS r ��str�payload��.0�ar r r � <listcomp>� � z.DNSServerFactory.sendReply.<locals>.<listcomp>c S r( r r) r, r r r r/ � r0 c S r( r r) r, r r r r/ � r0 zReplying with no answersz Answers are z Authority is zAdditional is Nz Processed query in %0.3f seconds) r �join�answers� authority� additionalr r � writeMessager �time� timeReceived)r r �message�address�s�auth�addr r r � sendReply� s �zDNSServerFactory.sendReplyc C s� |du rg }|du r g }|du rg }d}|D ] }|� � r d} nqtj| j|| j||d�}t|dd�|_|j|_||_||_ ||_ |S )a+ Generate a L{Message} instance suitable for use as the response to C{message}. C{queries} will be copied from the request to the response. C{rCode}, C{answers}, C{authority} and C{additional} will be assigned to the response, if supplied. The C{recAv} flag will be set on the response if the C{canRecurse} flag on this L{DNSServerFactory} is set to L{True}. The C{auth} flag will be set on the response if *any* of the supplied C{answers} have their C{auth} flag set to L{True}. The response will have the same C{maxSize} as the request. Additionally, the response will have a C{timeReceived} attribute whose value is that of the original request and the @see: L{dns._responseFromMessage} @param message: The request message @type message: L{Message} @param rCode: The response code which will be assigned to the response. @type message: L{int} @param answers: An optional list of answer records which will be assigned to the response. @type answers: L{list} of L{dns.RRHeader} @param authority: An optional list of authority records which will be assigned to the response. @type authority: L{list} of L{dns.RRHeader} @param additional: An optional list of additional records which will be assigned to the response. @type additional: L{list} of L{dns.RRHeader} @return: A response L{Message} instance. @rtype: L{Message} NFT)�responseConstructorr8 �recAv�rCoder; r7 ) �isAuthoritativer �_responseFromMessage�_messageFactoryr �getattrr7 �maxSizer2 r3 r4 ) r r8 r@ r2 r3 r4 �authoritativeAnswer�x�responser r r rB � s2 .�� z%DNSServerFactory._responseFromMessagec C s� |\}}}| j |tj|||d�}| �|||� t|�t|� t|� }| �d||dkr-dp.df � | jrF|rH| j�|jd |||f� dS dS dS )a� A callback used by L{DNSServerFactory.handleQuery} for handling the deferred response from C{self.resolver.query}. Constructs a response message by combining the original query message with the resolved answer, authority and additional records. Marks the response message as authoritative if any of the resolved answers are found to be authoritative. The resolved answers count will be logged if C{DNSServerFactory.verbose} is C{>1}. @param response: Answer records, authority records and additional records @type response: L{tuple} of L{list} of L{dns.RRHeader} instances @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} )r8 r@ r2 r3 r4 zLookup found %d record%sr& r: � r N) rB r �OKr= �lenr r � cacheResult�queries) r rH r r8 r9 �ansr; r< �lr r r �gotResolverResponse s � �z$DNSServerFactory.gotResolverResponsec C sR |� tjtj�r tj}ntj}t�|� | j||d�}| � |||� | � d� dS )a A callback used by L{DNSServerFactory.handleQuery} for handling deferred errors from C{self.resolver.query}. Constructs a response message from the original query message by assigning a suitable error code to C{rCode}. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. @param failure: The reason for the failed resolution (as reported by C{self.resolver.query}). @type failure: L{Failure<twisted.python.failure.Failure>} @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} )r8 r@ z Lookup failedN) �checkr � DomainError�AuthoritativeDomainError�ENAME�ESERVERr �errrB r= r )r �failurer r8 r9 r@ rH r r r �gotResolverError* s z!DNSServerFactory.gotResolverErrorc C s2 |j d }| j�|��| j|||��| j|||�S )a` Called by L{DNSServerFactory.messageReceived} when a query message is received. Takes the first query from the received message and dispatches it to C{self.resolver.query}. Adds callbacks L{DNSServerFactory.gotResolverResponse} and L{DNSServerFactory.gotResolverError} to the resulting deferred. Note: Multiple queries in a single message are not supported because there is no standard way to respond with multiple rCodes, auth, etc. This is consistent with other DNS server implementations. See U{http://tools.ietf.org/html/draft-ietf-dnsext-edns1-03} for a proposed solution. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} @return: A C{deferred} which fires with the resolved result or error of the first query in C{message}. @rtype: L{Deferred<twisted.internet.defer.Deferred>} r )rM r �query� addCallbackrP � addErrbackrX )r r8 r r9 rY r r r � handleQueryO s ! �z DNSServerFactory.handleQueryc C �* t j|_| �|||� | �d|��� dS )a# Called by L{DNSServerFactory.messageReceived} when an inverse query message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} zInverse query from N�r �ENOTIMPr@ r= r �r r8 r r9 r r r �handleInverseQueryx � z#DNSServerFactory.handleInverseQueryc C r] )a Called by L{DNSServerFactory.messageReceived} when a status message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} zStatus request from Nr^ r` r r r � handleStatus� rb z DNSServerFactory.handleStatusc C r] )a Called by L{DNSServerFactory.messageReceived} when a notify message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} zNotify message from Nr^ r` r r r � handleNotify� rb z DNSServerFactory.handleNotifyc C s. t j|_| �|||� | �d|j|f � dS )a0 Called by L{DNSServerFactory.messageReceived} when a message with unrecognised I{OPCODE} is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} z Unknown op code (%d) from %rN)r r_ r@ r= r �opCoder` r r r � handleOther� s z DNSServerFactory.handleOtherc C s< t � � |_| jrE| jdkrd�dd� |jD ��}n d�dd� |jD ��}t|�s6t�d|p1|j� � ��� nt�|� d|pA|j� � ��� | � |||�sYt j |_ | �|||� dS |jt jkrh| �|||� dS |jt jkrw| �|||� dS |jt jkr�| �|||� dS |jt jkr�| �|||� dS | �|||� dS ) a� L{DNSServerFactory.messageReceived} is called by protocols which are under the control of this L{DNSServerFactory} whenever they receive a DNS query message or an unexpected / duplicate / late DNS response message. L{DNSServerFactory.allowQuery} is called with the received message, protocol and origin address. If it returns L{False}, a C{dns.EREFUSED} response is sent back to the client. Otherwise the received message is dispatched to one of L{DNSServerFactory.handleQuery}, L{DNSServerFactory.handleInverseQuery}, L{DNSServerFactory.handleStatus}, L{DNSServerFactory.handleNotify}, or L{DNSServerFactory.handleOther} depending on the I{OPCODE} of the received message. If C{DNSServerFactory.verbose} is C{>0} all received messages will be logged in more or less detail depending on the value of C{verbose}. @param message: The DNS message that was received. @type message: L{dns.Message} @param proto: The DNS protocol instance which received the message @type proto: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param address: The address from which the message was received. Only provided for messages received by datagram protocols. The origin of Messages received from stream protocols can be gleaned from the protocol C{transport} attribute. @type address: L{tuple} or L{None} r& r' c S s g | ]}t |��qS r )r* �r- �qr r r r/ s z4DNSServerFactory.messageReceived.<locals>.<listcomp>c S s g | ] }t j�|jd ��qS )�UNKNOWN)r � QUERY_TYPES�get�typerg r r r r/ s zEmpty query from z query from N)r6 r7 r r1 rM rK r r � transport�getPeer� allowQueryr �EREFUSEDr@ r= re �OP_QUERYr\ � OP_INVERSEra � OP_STATUSrc � OP_NOTIFYrd rf )r r8 �protor9 r: r r r �messageReceived� s, � z DNSServerFactory.messageReceivedc C s t |j�S )a� Called by L{DNSServerFactory.messageReceived} to decide whether to process a received message or to reply with C{dns.EREFUSED}. This default implementation permits anything but empty queries. Override in a subclass to implement alternative policies. @param message: The DNS message that was received. @type message: L{dns.Message} @param protocol: The DNS protocol instance which received the message @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param address: The address from which the message was received. Only provided for messages received by datagram protocols. The origin of Messages received from stream protocols can be gleaned from the protocol C{transport} attribute. @type address: L{tuple} or L{None} @return: L{True} if the received message contained one or more queries, else L{False}. @rtype: L{bool} )rK rM r` r r r ro s zDNSServerFactory.allowQuery)NNNr r )�__name__� __module__� __qualname__�__doc__r � DNSProtocolr r �MessagerC r r r r# r% r= rJ rB rP rX r\ ra rc rd rf rv ro r r r r r s, % # & �R)%) <r ) rz r6 �twisted.internetr � twisted.namesr r �twisted.pythonr � ServerFactoryr r r r r �<module> s PK y�ZKG�&� � $ __pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z7 Twisted Names: DNS server and client implementations. N)�__doc__� r r �8/usr/lib/python3/dist-packages/twisted/names/__init__.py�<module> s PK y�Z3Qb�V �V " __pycache__/client.cpython-310.pycnu �[��� o �b�_ � @ s d Z ddlZddlZddlZddlmZ ddlmZmZm Z m Z ddl m Z ddl mZmZmZmZmZmZ ddlmZmZ ddlmZ dd lmZ dd l m Z ee j � G d d � d ej �Z G d d� d�Z!ddl"m#Z$ G dd� de$�Z#G dd� de j%�Z&dKdd�Z'da(dd� Z)dLdd�Z*dMdd �Z+dMd d �Z,dMd d �Z-dMd!d"�Z.dMd#d$�Z/dMd%d&�Z0dMd'd(�Z1dMd)d*�Z2dMd+d,�Z3dMd-d.�Z4dMd/d0�Z5dMd1d2�Z6dMd3d4�Z7dMd5d6�Z8dMd7d8�Z9dMd9d:�Z:dMd;d<�Z;dMd=d>�Z<dMd?d@�Z=dMdAdB�Z>dMdCdD�Z?dMdEdF�Z@dMdGdH�ZAdMdIdJ�ZBdS )Na� Asynchronous client DNS The functions exposed in this module can be used for asynchronous name resolution and dns queries. If you need to create a resolver with specific requirements, such as needing to do queries against a particular host, the L{createResolver} function will return an C{IResolver}. Future plans: Proper nameserver acquisition on Windows/MacOS, better caching, respect timeouts � N)�moduleProvides)�defer�error� interfaces�protocol)� isIPv6Address)�cache�common�dns�hosts�resolve�root)�failure�log)� nativeString)�FilePath)�platformc @ s� e Zd ZdZdZdZdZdZdZdZ dZ dZ dZ dZ d1dd�Zd d � Zd d � Zd d� Zdd� Zdd� Zdd� Zd2dd�Zdd� Zdd� Zd3d d �Zd d � Zd3d d!�Zd"d#� Zd4d%d&�Z d'd(� Z d)d*� Z d4d+d,�Z d-d.� Z d/d0� Z!dS )5�Resolvera� @ivar _waiting: A C{dict} mapping tuple keys of query name/type/class to Deferreds which will be called back with the result of those queries. This is used to avoid issuing the same query more than once in parallel. This is more efficient on the network and helps avoid a "birthday paradox" attack by keeping the number of outstanding requests for a particular query fixed at one instead of allowing the attacker to raise it to an arbitrary number. @ivar _reactor: A provider of L{IReactorTCP}, L{IReactorUDP}, and L{IReactorTime} which will be used to set up network resources and track timeouts. r N� �< �� � � �- c C s� t j�| � |du rddlm} || _|| _|du r g | _n|| _|| _t | j�s/|s/t d��t | |�| _ d| j _ g | _g | _i | _| �� dS )a� Construct a resolver which will query domain name servers listed in the C{resolv.conf(5)}-format file given by C{resolv} as well as those in the given C{servers} list. Servers are queried in a round-robin fashion. If given, C{resolv} is periodically checked for modification and re-parsed if it is noticed to have changed. @type servers: C{list} of C{(str, int)} or L{None} @param servers: If not None, interpreted as a list of (host, port) pairs specifying addresses of domain name servers to attempt to use for this lookup. Host addresses should be in IPv4 dotted-quad form. If specified, overrides C{resolv}. @type resolv: C{str} @param resolv: Filename to read and parse as a resolver(5) configuration file. @type timeout: Sequence of C{int} @param timeout: Default number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @param reactor: A provider of L{IReactorTime}, L{IReactorUDP}, and L{IReactorTCP} which will be used to establish connections, listen for DNS datagrams, and enforce timeouts. If not provided, the global reactor will be used. @raise ValueError: Raised if no nameserver addresses can be found. Nr ��reactorzNo nameservers specified)r � ResolverBase�__init__�twisted.internetr �_reactor�timeout�servers�resolv�len� ValueError�DNSClientFactory�factory�noisy� connections�pending�_waiting�maybeParseConfig)�selfr# r" r! r r r �6/usr/lib/python3/dist-packages/twisted/names/client.pyr B s" zResolver.__init__c C s | j �� }g |d< d |d< |S )Nr) � _parseCall)�__dict__�copy)r- �dr r r. � __getstate__| s zResolver.__getstate__c C s | j �|� | �� d S �N)r0 �updater, )r- �stater r r. � __setstate__� s zResolver.__setstate__c C s t |��� S )zr Wrapper used for opening files in the class, exists primarily for unit testing purposes. )r �open)r- �pathr r r. � _openFile� s zResolver._openFilec C s� | j d u rd S z| �| j �}W n ty. } z|jtjkr#| �d� n� W Y d }~n5d }~ww |�& t�|�� �j }|| j krPt � | j � d�� || _ | �|� W d � n1 sZw Y | j �| j| j�| _d S )Nr z changed, reparsing)r# r: �OSError�errno�ENOENT� parseConfig�os�fstat�fileno�st_mtime�_lastResolvTimer �msgr � callLater�_resolvReadIntervalr, r/ )r- � resolvConf�e�mtimer r r. r, � s, ��� � � �zResolver.maybeParseConfigc C s� g }|D ]U}|� � }|�d�r)t|�� d �tjf}|�|� t�d|�d�� q|�d�rHz |�� d | _ W n t yC d| _ Y nw d | _ q|�d�rY|�� dd � | _ d | _ q|sd|�dtjf� || _ d S ) Ns nameserverr zResolver added z to server lists domain� s search� 127.0.0.1) �strip� startswithr �splitr �PORT�appendr rD �domain� IndexError�search� dynServers)r- rG r" �L�resolverr r r. r> � s* � � zResolver.parseConfigc C sj | j s| jsdS t| j �}t| j�}| jd7 _| j|| ; _| j|k r-| j | j S | j| j| S )z� Return the address of a nameserver. TODO: Weight servers for response time so faster ones can be preferred. Nr )r" rT r$ �index)r- �serverL�dynLr r r. � pickServer� s zResolver.pickServer� c C s� d}t j| | jd�} z| jjt �� ||d� W |S tjyC } z |d7 }t|jd�r4|jj t j kr4� |dkr9� W Y d}~nd}~ww q ) zg Return a new L{DNSDatagramProtocol} bound to a randomly selected port number. r r T�� interfacer r< i� N) r �DNSDatagramProtocolr � listenUDP� randomSourcer �CannotListenError�hasattr� socketErrorr< �EMFILE)r- r] �failures�protorH r r r. �_connectedProtocol� s$ � � ����zResolver._connectedProtocolc C s@ | j �|� | jD ]\}}}| �||��|� q | jdd�= dS )zV Called by associated L{dns.DNSProtocol} instances when they connect. N)r) rP r* �queryTCP� chainDeferred)r- r r2 �q�tr r r. �connectionMade� s zResolver.connectionMadec C s || j v r | j �|� dS dS )zY Called by associated L{dns.DNSProtocol} instances when they disconnect. N)r) �remove�r- r r r r. �connectionLost� s �zResolver.connectionLostc C s t �d|j|f � d S )Nz(Unexpected message (%d) received from %r)r rD �id)r- �messager �addressr r r. �messageReceived� s zResolver.messageReceivedc sJ t |d d �r| jdd�� n| �� � � j|� }� fdd�}|�|� |S )a� Get a new L{DNSDatagramProtocol} instance from L{_connectedProtocol}, issue a query to it using C{*args}, and arrange for it to be disconnected from its transport after the query completes. @param args: Positional arguments to be passed to L{DNSDatagramProtocol.query}. @return: A L{Deferred} which will be called back with the result of the query. r z::r\ c s � j �� | S r4 )� transport� stopListening)�result�r r r. � cbQueried s z"Resolver._query.<locals>.cbQueried)r rg �query�addBoth)r- �argsr2 rx r rw r. �_query� s zResolver._queryc C sl |du r| j }| jt| j� }|st�td��S |�� |�� }| � |||d �}|� | j ||g||� |S )a� Make a number of DNS queries via UDP. @type queries: A C{list} of C{dns.Query} instances @param queries: The queries to make. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @rtype: C{Deferred} @raise C{twisted.internet.defer.TimeoutError}: When the query times out. N� No domain name servers availabler ) r! r" �listrT r �fail�IOError�reverse�popr| � addErrback�_reissue)r- �queriesr! � addresses�usedr2 r r r. �queryUDP s zResolver.queryUDPc C s� |� tj� |s|}|�� g }|dd � }|s t�t�|��S |�� }|� |� | � |||d |j j �}|� | j||||� |S )Nr r )�trapr �DNSQueryTimeoutErrorr� r �Failurer � TimeoutErrorr� rP r| �valuerp r� r� )r- �reason� addressesLeft� addressesUsedry r! rr r2 r r r. r� 7 s zResolver._reissue� c C sx t | j�s3| �� }|du rt�td��S |\}}| j�||| j� | j � t� � ||f� | j d d S | jd � ||�S )a) Make a number of DNS queries via TCP. @type queries: Any non-zero number of C{dns.Query} instances @param queries: The queries to make. @type timeout: C{int} @param timeout: The number of seconds after which to fail. @rtype: C{Deferred} Nr} ���r ) r$ r) rZ r r r� r � connectTCPr' r* rP �Deferredry )r- r� r! rr �host�portr r r. rh T s zResolver.queryTCPc C sL |j r | �|j��| j�S |jtjkr t� | � |j�|��S |j |j |j fS )a� Extract results from the given message. If the message was truncated, re-attempt the query over TCP and return a Deferred which will fire with the results of that query. If the message's result code is not C{twisted.names.dns.OK}, return a Failure indicating the type of error which occurred. Otherwise, return a three-tuple of lists containing the results from the answers section, the authority section, and the additional section. )�truncrh r� � addCallback� filterAnswers�rCoder �OKr r� �exceptionForCode�answers� authority� additional)r- rq r r r. r� k s zResolver.filterAnswersc s~ |||f� �j �� �}|du r4g �j � < ��t�|||�g|�}� �fdd�}|��j� |�|� |S t� � }|� |� |S )aZ Build a L{dns.Query} for the given parameters and dispatch it via UDP. If this query is already outstanding, it will not be re-issued. Instead, when the outstanding query receives a response, that response will be re-used for this query as well. @type name: C{str} @type type: C{int} @type cls: C{int} @return: A L{Deferred} which fires with a three-tuple giving the answer, authority, and additional sections of the response or with a L{Failure} if the response code is anything other than C{dns.OK}. Nc s �j �� �D ]}|�| � q| S r4 )r+ r� �callback)rv r2 ��keyr- r r. �cbResult� s z"Resolver._lookup.<locals>.cbResult) r+ �getr� r �Queryr� r� rz r r� rP )r- �name�cls�typer! �waitingr2 r� r r� r. �_lookup~ s � zResolver._lookupc s� | � � }|d u rt�td��S |\}}t�� }t||�� t� |�}d|_| j� |||�}| j� |p2d| j |� ||p:d�� _ � fdd�} |j | j| |fd�S )Nr} Fr� c s � j �� d � _ | S r4 )� timeoutCall�cancel)r �� controllerr r. �eliminateTimeout� s z-Resolver.lookupZone.<locals>.eliminateTimeout)� callbackArgs)rZ r r r� r� �AXFRControllerr& r( r r� rE � _timeoutZoner� � addCallbacks� _cbLookupZone) r- r� r! rr r� r� r2 r' � connectorr� r r� r. � lookupZone� s � �zResolver.lookupZonec C s. |� � d |_d |_|�t�d|f �� d S )Nz&Zone lookup timed out after %d seconds)� disconnectr� �deferred�errbackr r� )r- r2 r� r� �secondsr r r. r� � s �zResolver._timeoutZonec C s |� � |g g fS r4 )r� )r- rv r� r r r. r� � s zResolver._cbLookupZone)NNr N)r[ r4 �r� )"�__name__� __module__� __qualname__�__doc__rW r! r' r" rT r* r) r# rC rF r r3 r7 r: r, r> rZ rg rl ro rs r| r� r� rh r� r� r� r� r� r r r r. r & s@ : # r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � ZdS ) r� Nc C s& || _ || _d | _g | _|fg| _d S r4 )r� r� �soa�recordsr* )r- r� r� r r r. r � s zAXFRController.__init__c C s8 t j|�� dd�}t �| jt jt j�g|_|�|� d S )Nr )�recDes) r �Message�pickIDr� r� �AXFR�INr� � writeMessage)r- r rq r r r. rl � s z AXFRController.connectionMadec C � d S r4 r rn r r r. ro � s z AXFRController.connectionLostc C s� | j �|j� | j s d S | js | j d jtjkr | j d | _t| j �dkrL| j d jtjkrN| jd ur;| j� � d | _| j d urP| j � | j � d | _ d S d S d S d S )Nr r r� ) r� �extendr� r� r� r �SOAr$ r� r� r� r� )r- rq r r r r. rs � s �z AXFRController.messageReceived)r� r� r� r� r rl ro rs r r r r. r� � s r� )�ThreadedResolverc @ s e Zd Zddd�ZdS )r� Nc C s4 |d u r ddl m} t�| |� tjdtdd� d S )Nr r zztwisted.names.client.ThreadedResolver is deprecated since Twisted 9.0, use twisted.internet.base.ThreadedResolver instead.� )�category� stacklevel)r r �_ThreadedResolverImplr �warnings�warn�DeprecationWarning)r- r r r r. r � s �zThreadedResolver.__init__r4 )r� r� r� r r r r r. r� � s r� c @ s. e Zd Zd dd�Zdd� Zdd� Zdd � Zd S ) r& r� c C s || _ || _d S r4 )r� r! )r- r� r! r r r. r s zDNSClientFactory.__init__c C r� r4 r )r- r� r� r r r. �clientConnectionLost s z%DNSClientFactory.clientConnectionLostc C s> | j jdd� }| j jdd�= |D ] }|d }|�|� qdS )a Fail all pending TCP DNS queries if the TCP connection attempt fails. @see: L{twisted.internet.protocol.ClientFactory} @param connector: Not used. @type connector: L{twisted.internet.interfaces.IConnector} @param reason: A C{Failure} containing information about the cause of the connection failure. This will be passed as the argument to C{errback} on every pending TCP query C{deferred}. @type reason: L{twisted.python.failure.Failure} Nr )r� r* r� )r- r� r� r* � pendingStater2 r r r. �clientConnectionFailed s �z'DNSClientFactory.clientConnectionFailedc C s t �| j�}| |_|S r4 )r � DNSProtocolr� r' )r- �addr�pr r r. � buildProtocol% s z DNSClientFactory.buildProtocolNr� )r� r� r� r r� r� r� r r r r. r& s r& c C s� t �� dkr |du r d}|du rd}t|| �}t�|�}n |du r#d}ddlm} t|�}t�|�}tj|td�}|t � � |g}t � |�S ) a� Create and return a Resolver. @type servers: C{list} of C{(str, int)} or L{None} @param servers: If not L{None}, interpreted as a list of domain name servers to attempt to use. Each server is a tuple of address in C{str} dotted-quad form and C{int} port number. @type resolvconf: C{str} or L{None} @param resolvconf: If not L{None}, on posix systems will be interpreted as an alternate resolv.conf to use. Will do nothing on windows systems. If L{None}, /etc/resolv.conf will be used. @type hosts: C{str} or L{None} @param hosts: If not L{None}, an alternate hosts file to use. If L{None} on posix systems, /etc/hosts will be used. On windows, C:\windows\hosts will be used. @rtype: C{IResolver} �posixNs /etc/resolv.confs /etc/hostszc:\windows\hostsr r )�resolverFactory) r �getTyper � hostsModuler r r� r � bootstrapr � CacheResolverr � ResolverChain)r" � resolvconfr � theResolver� hostResolverr r� rU r r r. �createResolver+ s r� c C s: t du rzt� a W t S ty tdgd�a Y t S w t S )z� Get a Resolver instance. Create twisted.names.client.theResolver if it is L{None}, and then return that value. @rtype: C{IResolver} N)rK �5 )r" )r� r� r% r r r r. � getResolverX s ��r� r� c C s t � �| ||�S )aL Resolve a name to a valid ipv4 or ipv6 address. Will errback with C{DNSQueryTimeoutError} on a timeout, C{DomainError} or C{AuthoritativeDomainError} (or subclasses) on other errors. @type name: C{str} @param name: DNS name to resolve. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @type effort: C{int} @param effort: How many times CNAME and NS records to follow while resolving this name. @rtype: C{Deferred} )r� � getHostByName)r� r! �effortr r r. r� j s r� c C � t � �| |�S r4 )r� ry )ry r! r r r. ry � � ry c C r� r4 )r� � lookupAddress�r� r! r r r. r� � r� r� c C r� r4 )r� �lookupIPV6Addressr� r r r. r� � r� r� c C r� r4 )r� �lookupAddress6r� r r r. r� � r� r� c C r� r4 )r� �lookupMailExchanger� r r r. r� � r� r� c C r� r4 )r� �lookupNameserversr� r r r. r� � r� r� c C r� r4 )r� �lookupCanonicalNamer� r r r. r� � r� r� c C r� r4 )r� � lookupMailBoxr� r r r. r� � r� r� c C r� r4 )r� �lookupMailGroupr� r r r. r� � r� r� c C r� r4 )r� �lookupMailRenamer� r r r. r� � r� r� c C r� r4 )r� � lookupPointerr� r r r. r� � r� r� c C r� r4 )r� �lookupAuthorityr� r r r. r� � r� r� c C r� r4 )r� � lookupNullr� r r r. r� � r� r� c C r� r4 )r� �lookupWellKnownServicesr� r r r. r� � r� r� c C r� r4 )r� � lookupServicer� r r r. r� � r� r� c C r� r4 )r� �lookupHostInfor� r r r. r� � r� r� c C r� r4 )r� �lookupMailboxInfor� r r r. r� � r� r� c C r� r4 )r� � lookupTextr� r r r. r� � r� r� c C r� r4 )r� �lookupSenderPolicyr� r r r. r� � r� r� c C r� r4 )r� �lookupResponsibilityr� r r r. r� � r� r� c C r� r4 )r� �lookupAFSDatabaser� r r r. r� � r� r� c C r� r4 )r� r� r� r r r. r� � r� r� c C r� r4 )r� �lookupAllRecordsr� r r r. r � r� r c C r� r4 )r� � lookupNamingAuthorityPointerr� r r r. r � r� r )NNN)Nr� r4 )Cr� r< r? r� �zope.interfacer r r r r r �twisted.internet.abstractr � twisted.namesr r r r r� r r �twisted.pythonr r �twisted.python.compatr �twisted.python.filepathr �twisted.python.runtimer � IResolverr r r� �twisted.internet.baser� r� � ClientFactoryr& r� r� r� r� ry r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r. �<module> sb # , (* PK y�Z�?<3�9 �9 % __pycache__/authority.cpython-310.pycnu �[��� o �b+A � @ s� d Z ddlZddlZddlmZ ddlmZmZmZ ddl m Z ddl m Z m Z ddlmZ dd d �ZG d d � d ej�ZG d d� de�ZG dd� de�ZdS )z Authoritative resolvers. � N)�defer)�common�dns�error)�failure)�execfile� nativeString)�FilePath�/tmp/twisted-names.serialc C s t �d�}t�d�}z)tj�| �s-t| d��}|�|d � W d � n1 s(w Y W t�|� nt�|� w t| ��}|�� � � \}}W d � n1 sQw Y ||kr`t |�d pad}t| d��}|�d||f � W d � n1 s{w Y |d |f }|S ) a� Return a monotonically increasing (across program runs) integer. State is stored in the given file. If it does not exist, it is created with rw-/---/--- permissions. This manipulates process-global state by calling C{os.umask()}, so it isn't thread-safe. @param filename: Path to a file that is used to store the state across program runs. @type filename: L{str} @return: a monotonically increasing number @rtype: L{str} z%Y%m%d� �wz 0N� r z%s %dz%02d) �time�strftime�os�umask�path�exists�open�write�readline�split�int)�filename�serial�o�f� serialFile� lastSerial�zoneID� r �9/usr/lib/python3/dist-packages/twisted/names/authority.py� getSerial s$ �� � �r" c @ sp e Zd ZdZejejejfZej ej fZ dZ dZ dd� Zdd� Zdd� Zd d � Zdd d �Zddd�Zdd� ZdS )� FileAuthoritya� An Authority that is loaded from a file. This is an abstract class that implements record search logic. To create a functional resolver, subclass it and override the L{loadFile} method. @ivar _ADDITIONAL_PROCESSING_TYPES: Record types for which additional processing will be done. @ivar _ADDRESS_TYPES: Record types which are useful for inclusion in the additional section generated during additional processing. @ivar soa: A 2-tuple containing the SOA domain name as a L{bytes} and a L{dns.Record_SOA}. @ivar records: A mapping of domains (as lowercased L{bytes}) to records. @type records: L{dict} with L{bytes} keys Nc C s t j�| � | �|� i | _d S �N)r � ResolverBase�__init__�loadFile�_cache��selfr r r r! r& V s zFileAuthority.__init__c C s || _ d S r$ )�__dict__)r* �stater r r! � __setstate__[ s zFileAuthority.__setstate__c C s dS )ab Load DNS records from a file. This method populates the I{soa} and I{records} attributes. It must be overridden in a subclass. It is called once from the initializer. @param filename: The I{filename} parameter that was passed to the initilizer. @returns: L{None} -- the return value is ignored Nr r) r r r! r' ^ s zFileAuthority.loadFilec c sp � || D ]0}|j | jv r5|jjj}| j�|�� d�D ]}|j| jv r4t j ||jt j |j p.||dd�V qqdS )aW Find locally known information that could be useful to the consumer of the response and construct appropriate records to include in the I{additional} section of that response. Essentially, implement RFC 1034 section 4.3.2 step 6. @param answer: A L{list} of the records which will be included in the I{answer} section of the response. @param authority: A L{list} of the records which will be included in the I{authority} section of the response. @param ttl: The default TTL for records for which this is not otherwise specified. @return: A generator of L{dns.RRHeader} instances for inclusion in the I{additional} section. These instances represent extra information about the records in C{answer} and C{authority}. r T��authN) �type� _ADDITIONAL_PROCESSING_TYPES�payload�name�records�get�lower�TYPE�_ADDRESS_TYPESr �RRHeader�IN�ttl)r* �answer� authorityr; �recordr3 �recr r r! �_additionalRecordsk s � ���z FileAuthority._additionalRecordsc C s� g }g }g }g }t | jd j| jd j�} | j�|�� �} | r�| D ]_} | jdur,| j} n| } | jt j krP|�� | jd �� krP|� t j || jt j | | dd�� n| j|ksZ|t jkrj|� t j || jt j | | dd�� | jt jkr�|� t j || jt j | | dd�� q!|s�|}| �||| �} |r�|�| � n|�| � |s�|s�|� t j | jd t jt j | | jd dd�� t�|||f�S t �|| jd �r�t�t�t �|���S t�t�t�|���S )a� Determine a response to a particular DNS query. @param name: The name which is being queried and for which to lookup a response. @type name: L{bytes} @param cls: The class which is being queried. Only I{IN} is implemented here and this value is presently disregarded. @type cls: L{int} @param type: The type of records being queried. See the types defined in L{twisted.names.dns}. @type type: L{int} @param timeout: All processing is done locally and a result is available immediately, so the timeout value is ignored. @return: A L{Deferred} that fires with a L{tuple} of three sets of response records (to comprise the I{answer}, I{authority}, and I{additional} sections of a DNS response) or with a L{Failure} if there is a problem processing the query. r Nr Fr. T) �max�soa�minimum�expirer4 r5 r6 r; r7 r �NS�appendr9 r: � ALL_RECORDS�CNAMEr@ �extend�SOAr �succeed�_isSubdomainOf�failr �Failure�AuthoritativeDomainErrorr � DomainError)r* r3 �clsr0 �timeout�cnames�resultsr= � additional� default_ttl�domain_recordsr> r; �additionalInformationr r r! �_lookup� sT "�� ��� ��zFileAuthority._lookup� c C s t �|�}| jd �� |�� kr�t| jd j| jd j�}| jd jd ur,| jd j}n|}t j| jd t j t j || jd dd�g}| j � � D ]*\}}|D ]#}|jd urX|j} n|} |j t j krp|�t j||j t j | |dd�� qMqG|�|d � t�|ddf�S t�t�t �|���S )Nr r Tr. r )r � domainStringrB r6 rA rC rD r; r9 rJ r: r4 �itemsr7 rF r rK rM r rN rP ) r* r3 rR rV �soa_ttlrT �k�rr? r; r r r! � lookupZone� s0 �� ��� zFileAuthority.lookupZonec C sb g g g }}}|D ]!}|d r+|� |d d � |� |d d � |� |d d � q |||fS )Nr r � )rI )r* rT �ansr/ �add�resr r r! � _cbAllRecords� s � zFileAuthority._cbAllRecordsr$ )rZ )�__name__� __module__� __qualname__�__doc__r rH �MXrE r1 �A�AAAAr8 rB r4 r& r- r' r@ rY r` re r r r r! r# ; s Y r# c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �PySourceAuthorityzC A FileAuthority that is built up from Python source code. c C s| | � � i }}t|||� d|vrtd| ��i | _|d D ] }t|d tj�r+|| _| j�|d � � g �� |d � q d S )N�zonezNo zone defined in r r ) �setupConfigNamespacer � ValueErrorr4 � isinstancer � Record_SOArB � setdefaultr6 rF )r* r �g�l�rrr r r! r' s "�zPySourceAuthority.loadFilec s � fdd�}|S )Nc s t �| �� |i |��fS r$ )r r[ )r3 �arg�kw�r0 r r! �wrapRecordFunc s z4PySourceAuthority.wrapRecord.<locals>.wrapRecordFuncr )r* r0 rz r ry r! � wrapRecord s z PySourceAuthority.wrapRecordc C sN i }t j�� }dd� |D �D ]}tt |�}| �|�}|||td�d � < q|S )Nc S s g | ] }|� d �r|�qS )�Record_)� startswith)�.0�xr r r! � <listcomp>" s z:PySourceAuthority.setupConfigNamespace.<locals>.<listcomp>r| )r r+ �keys�getattrr{ �len)r* r_ r\ r> r0 r r r r! ro s z&PySourceAuthority.setupConfigNamespaceN)rf rg rh ri r' r{ ro r r r r! rm s rm c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )� BindAuthorityz� An Authority that loads U{BIND zone files <https://en.wikipedia.org/wiki/Zone_file>}. Supports only C{$ORIGIN} and C{$TTL} directives. c C sJ t |�}t|�� d �| _|�� �d�}| �|�}| �|�}| �|� dS )z} Load records from C{filename}. @param filename: file to read from @type filename: L{bytes} � .TN) r r �basename�origin� getContent� splitlines� stripComments�collapseContinuations� parseLines)r* r �fp�linesr r r! r' 1 s zBindAuthority.loadFilec C s dd� dd� |D �D �S )z� Strip comments from C{lines}. @param lines: lines to work on @type lines: iterable of L{bytes} @return: C{lines} sans comments. c s s4 � | ]}|� d �dkr |p|d|� d �� V qdS )� ;���N)�find)r~ �ar r r! � <genexpr>K s � "� �z.BindAuthority.stripComments.<locals>.<genexpr>c S s g | ]}|� � �qS r )�strip)r~ �br r r! r� M s z/BindAuthority.stripComments.<locals>.<listcomp>r )r* r� r r r! r� B s �zBindAuthority.stripCommentsc C s� g }d}|D ]G}|dkr(|� d�dkr|�|� q|�|d|� d�� � d}q|� d�dkrC|d d|d|� d�� 7 < d}q|d d| 7 < qtddd � |D ��S ) z� Transform multiline statements into single lines. @param lines: lines to work on @type lines: iterable of L{bytes} @return: iterable of continuous lines r � (r� Nr � )� c s s � | ]}|� � V qd S r$ )r )r~ �liner r r! r� h s � z6BindAuthority.collapseContinuations.<locals>.<genexpr>)r� rF �filter)r* r� ru r, r� r r r! r� P s "z#BindAuthority.collapseContinuationsc C s� d}| j }i | _|D ]6}|d dkrt�|d �}q |d dkr%|d }q |d dkr/td��|d dkr9td ��| �|||� q || _ d S ) zs Parse C{lines}. @param lines: lines to work on @type lines: iterable of L{bytes} i0* r s $TTLr s $ORIGINs $INCLUDEz"$INCLUDE directive not implementeds $GENERATEz#$GENERATE directive not implementedN)r� r4 r �str2time�NotImplementedError�parseRecordLine)r* r� r; r� r� r r r! r� j s zBindAuthority.parseLinesc C sd |� d�s|d |dd� }n|dd� }t| d|� �d�}|r*|||||� dS td|�d���)a Add a record to our authority. Expand domain with origin if necessary. @param owner: origin? @type owner: L{bytes} @param ttl: time to live for the record @type ttl: L{int} @param domain: the domain for which the record is to be added @type domain: L{bytes} @param type: record type @type type: L{str} @param cls: record class @type cls: L{str} @param rdata: record data @type rdata: L{list} of L{bytes} r� Nr� �class_z Record class � not supported)�endswithr� r� )r* �ownerr; r0 �domainrQ �rdatar r r r! � addRecord� s zBindAuthority.addRecordc C sn t tdt|�� �d�}|r-||� }||_| j�|�� g ��|� |dkr+||f| _dS dS t dt|��d���)a> Simulate a class IN and recurse into the actual class. @param ttl: time to live for the record @type ttl: L{int} @param type: record type @type type: str @param domain: the domain @type domain: bytes @param rdata: @type rdata: bytes r| NrJ z Record type r� ) r� r r r; r4 rs r6 rF rB r� )r* r; r0 r� r� r> r_ r r r! �class_IN� s ��zBindAuthority.class_INc C sv dd� t j�� D �}dd� t j�� D �}||B }d}|}|d dkr+|dd� }|}n|d �� sA|d |vrA|d }|dd� }|d �� sM|d |v rR|} |}n |d } |dd� }|d |v r|d }|dd� }|d �� r~t|d �}|dd� }n"|d �� r�t|d �}|dd� }|d |v r�|d }|dd� }|d } |dd� } | �||t| �| t|�| � dS ) a� Parse a C{line} from a zone file respecting C{origin} and C{ttl}. Add resulting records to authority. @param origin: starting point for the zone @type origin: L{bytes} @param ttl: time to live for the record @type ttl: L{int} @param line: zone file line to parse; split by word @type line: L{list} of L{bytes} c S � h | ]}|� d ��qS ��ascii��encode)r~ �qcr r r! � <setcomp>� � z0BindAuthority.parseRecordLine.<locals>.<setcomp>c S r� r� r� )r~ �qtr r r! r� � r� s INr � @r N)r � QUERY_CLASSES�values� QUERY_TYPES�isdigitr r� r ) r* r� r; r� � queryClasses� queryTypes�markersrQ r� r� r0 r� r r r! r� � s@ � z BindAuthority.parseRecordLineN) rf rg rh ri r' r� r� r� r� r� r� r r r r! r� ) s r� )r )ri r r �twisted.internetr � twisted.namesr r r �twisted.pythonr �twisted.python.compatr r �twisted.python.filepathr r" r% r# rm r� r r r r! �<module> s ' N!PK y�Z��� � ! __pycache__/hosts.cpython-310.pycnu �[��� o �b� � @ sz d Z ddlmZ ddlmZmZ ddlmZmZ ddl m Z ddl m Z ddl mZ dd � Zd d � ZG d d � d ej�ZdS )z hosts(5) support. � )�defer)� isIPAddress� isIPv6Address)�common�dns)�failure)� nativeString)�FilePathc C s� g }z| � � �� }W n ty | Y S w |�� }|D ]F}|�d�}|dkr-|d|� }|s0q |�� }|�� dd� |dd� D �v rbzt|d �}W n tyT Y q w t|�s]t |�rb|� |� q |S )a� Search the given file, which is in hosts(5) standard format, for addresses associated with a given name. @param hostsFile: The name of the hosts(5)-format file to search. @type hostsFile: L{FilePath} @param name: The name to search for. @type name: C{bytes} @return: L{None} if the name is not found in the file, otherwise a C{str} giving the address in the file associated with the name. � #���Nc S s g | ]}|� � �qS � )�lower)�.0�sr r �5/usr/lib/python3/dist-packages/twisted/names/hosts.py� <listcomp>/ s z$searchFileForAll.<locals>.<listcomp>� r ) � getContent� splitlines� BaseExceptionr �find�splitr � ValueErrorr r �append)� hostsFile�name�results�lines�line�idx�parts�maybeIPr r r �searchFileForAll s0 � � �r" c C s t t| �|�}|r |d S dS )a� Grep given file, which is in hosts(5) standard format, for an address entry with a given name. @param file: The name of the hosts(5)-format file to search. @type file: C{str} or C{bytes} @param name: The name to search for. @type name: C{bytes} @return: L{None} if the name is not found in the file, otherwise a C{str} giving the first address in the file associated with the name. r N)r" r )�filer � addressesr r r � searchFileFor9 s r% c @ sJ e Zd ZdZddd�Zdd� Zdd � Zd d � Zdd d�Zddd�Z eZ d S )�Resolverz9 A resolver that services hosts(5) format files. � /etc/hosts� c C s t j�| � || _|| _d S �N)r � ResolverBase�__init__r# �ttl)�selfr# r, r r r r+ S s zResolver.__init__c �$ t � �fdd�tt�j�� �D ��S )zv Return a tuple of L{dns.RRHeader} instances for all of the IPv4 addresses in the hosts file. c 3 �: � | ]}t |�rt�� tjtj�jt�|�j��V qd S r) )r r �RRHeader�A�INr, �Record_A�r �addr�r r- r r � <genexpr>] s � � �z%Resolver._aRecords.<locals>.<genexpr>��tupler" r r# �r- r r r6 r � _aRecordsX s �zResolver._aRecordsc r. )zv Return a tuple of L{dns.RRHeader} instances for all of the IPv6 addresses in the hosts file. c 3 r/ r) )r r r0 �AAAAr2 r, � Record_AAAAr4 r6 r r r7 h s � �� �z(Resolver._aaaaRecords.<locals>.<genexpr>r8 r: r r6 r � _aaaaRecordsc s �zResolver._aaaaRecordsc C s* |r t �|ddf�S t �t�t�|���S )aF Generate a response for the given name containing the given result records, or a failure if there are no result records. @param name: The DNS name the response is for. @type name: C{str} @param records: A tuple of L{dns.RRHeader} instances giving the results that will go into the response. @return: A L{Deferred} which will fire with a three-tuple of result records, authority records, and additional records, or which will fail with L{dns.DomainError} if there are no result records. r )r �succeed�failr �Failurer � DomainError)r- r �recordsr r r �_respondp s zResolver._respondNc C � t �|�}| �|| �|��S )zm Read any IPv4 addresses from C{self.file} and return them as L{Record_A} instances. )r � domainStringrD r; �r- r �timeoutr r r � lookupAddress� � zResolver.lookupAddressc C rE )zp Read any IPv6 addresses from C{self.file} and return them as L{Record_AAAA} instances. )r rF rD r> rG r r r �lookupIPV6Address� rJ zResolver.lookupIPV6Address)r' r( r) ) �__name__� __module__� __qualname__�__doc__r+ r; r> rD rI rK �lookupAllRecordsr r r r r& N s r& N)rO �twisted.internetr �twisted.internet.abstractr r � twisted.namesr r �twisted.pythonr �twisted.python.compatr �twisted.python.filepathr r" r% r* r& r r r r �<module> s 'PK y�ZNB<�� � __pycache__/tap.cpython-310.pycnu �[��� o �b� � @ sn d Z ddlZddlZddlmZmZ ddlmZmZm Z m Z ddl m Z G dd� de j �Z dd � Zd d � ZdS ) z Domain Name Server � N)�internet�service)� authority�dns� secondary�server)�usagec @ s� e Zd Zg d�g d�g d�g d�gZg d�g d�g d�gZejde�� id �Zd Z d Z d d � Z d d� Z dd� Z dd� Zdd� Zdd� Zd S )�Options)� interface�i� z The interface to which to bind)�port�p�53zThe port on which to listen)� resolv-confNNz6Override location of resolv.conf (implies --recursive))� hosts-fileNNz!Perform lookups with a hosts file)�cache�czEnable record caching)� recursive�rzPerform recursive lookups)�verbose�vz Log verboselyr )� optActionsNc C s* t j�| � d| d< g | _g | _g | _d S )Nr r )r r �__init__� bindfiles� zonefiles� secondaries��self� r �3/usr/lib/python3/dist-packages/twisted/names/tap.pyr + s zOptions.__init__c C �* t j�|�s t�|d ��| j�|� dS )z7Specify the filename of a Python syntax zone definition�: No such fileN)�os�path�existsr � UsageErrorr �append�r �filenamer r r � opt_pyzone2 � zOptions.opt_pyzonec C r! )z6Specify the filename of a BIND9 syntax zone definitionr" N)r# r$ r% r r& r r' r( r r r � opt_bindzone8 r+ zOptions.opt_bindzonec C s� |� dd�}t|�dkrt�d��|d � d�}t|�dkr&|d tjf}n zt|d �}W n ty? t�d|d ����w |d |f}| j� ||d gf� dS ) zwAct as secondary for the specified domain, performing zone transfers from the specified IP (IP/domain) �/� � z-Argument must be of the form IP[:port]/domainr �:z$Specify an integer port number, not N) �split�lenr r& r �PORT�int� ValueErrorr r' )r � ip_domain�args�addressr r r r � opt_secondary> s �� zOptions.opt_secondaryc C s | d d7 < dS )zIncrement verbosity levelr r. Nr r r r r � opt_verboseR s zOptions.opt_verbosec C s | d rd| d< g | _ g | _| jD ] }z | j�t�|�� W q ty0 t�� t � d| ��w | j D ] }z | j�t� |�� W q4 tyS t�� t � d| ��w | j D ]}tjj|� }| j �|� | j�| j d �� � qWz t| d �| d< W d S ty� t � d�| d ���w )Nr Tr zInvalid syntax in ���r zInvalid port: {!r})�svcs�zonesr r' r �PySourceAuthority� Exception� traceback� print_excr r& r � BindAuthorityr r �SecondaryAuthorityService�fromServerAddressAndDomains� getAuthorityr4 r5 �format)r �f�svcr r r � postOptionsV s6 � � �zOptions.postOptions)�__name__� __module__� __qualname__� optParameters�optFlagsr � Completions�CompleteNetInterfaces�compDatar= r r r* r, r9 r: rI r r r r r s* � � � r c C s� ddl m}m}m} g g }}| d r |�|j| d d�� | d r-|�|j| d d�� | d r<|�|j| d d �� ||fS ) a% Build DNS resolver instances in an order which leaves recursive resolving as a last resort. @type config: L{Options} instance @param config: Parsed command-line configuration @return: Two-item tuple of a list of cache resovers and a list of client resolvers r )r �client�hostsr r )r r )�filer r )� resolvconf)� twisted.namesr rR rS r' � CacheResolver�Resolver�createResolver)�configr rR rS �ca�clr r r �_buildResolversr s r] c C s� t | �\}}t�| j||| d �}t�|�}d|_t�� }t j |ft j |ffD ]\}}|| d || d d�}|� |� q'| j D ]} | � |� q?|S )Nr r r r )r )r] r �DNSServerFactoryr= r �DNSDatagramProtocol�noisyr � MultiServicer � TCPServer� UDPServer�setServiceParentr< ) rZ r[ r\ rG r �ret�klass�arg�srH r r r � makeService� s ri )�__doc__r# r@ �twisted.applicationr r rV r r r r �twisted.pythonr r r] ri r r r r �<module> s a PK y�Z��U�p p __pycache__/dns.cpython-310.pycnu �[��� o �b�� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m Z m Z m Z ddl mZmZmZ ddlmZmZ ddlmZ dd lmZmZmZmZ dd l m Z m Z m Z g d �Z ej!Z!d d � Z"dd� Z#dd� Z$dd� Z%dZ&e'dd�\Z(Z)Z*Z+Z,Z-Z.Z/Z0Z1Z2Z3Z4Z5Z6Z7Z8Z9dZ:dZ;dZ<dZ=dZ>d Z?d Z@d ZAd ZBd ZCi e(d!�e)d"�e*d#�e+d$�e,d%�e-d&�e.d'�e/d(�e0d)�e1d*�e2d+�e3d,�e4d-�e5d.�e6d/�e7d0�e8d1�e9d2e:d3e;d4e<d5e=d6e>d7e?d8e@d9eAd:eBd;eCd<i �ZDe'd=d>�\ZEZFZGZHZIeEd?eFd@eGdAeHdBeIdCiZJdDdE� eeD�K� eJ�K� �D �ZLe'ddF�\ZMZNZOZPdGZQeMdHeNdIeOdJePdKeQdLiZRdMdE� eR�K� D �ZSe'dN�\ZTZUZVdOZWdFZXe'dP�\ZYZZZ[Z\Z]Z^dQZ_e'dQd�\Z`ZaZbG dRdS� dSe�ZcddTldmeZemfZfmgZg dUdV� ZhdWdX� ZidYdZ� Zjd[d\� Zkd]d^� ZlG d_d`� d`e�ZmG dadb� dbemec�Zneem�G dcdd� dd��Zoeem�G dedf� df��Zpe eem�G dgdh� dh���Zqeem�G didj� djejrejs��Zteem�G dkdl� dlejrejs��Zueem�G dmdn� dnejs��Zveen�G dodp� dpejrejs��ZwG dqdr� drew�ZxG dsdt� dtew�ZyG dudv� dvew�ZzG dwdx� dxew�Z{G dydz� dzew�Z|G d{d|� d|ew�Z}G d}d~� d~ew�Z~G dd�� d�ew�ZG d�d�� d�ew�Z�een�G d�d�� d�ejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejsejr��Z�G d�d�� d�e��Z�een�G d�d�� d�ejsejr��Z�d�d�� Z�d�d�� Z� d�d�d��Z�G d�d�� d�ejs�Z�G d�d�� d�ejs�Z�G d�d�� d��Z�G d�d�� d�e�ej��Z�G d�d�� d�e�ej��Z�dS )�zU DNS protocol implementation. Future Plans: - Get rid of some toplevels, maybe. � N)�BytesIO)�chain)�Optional� SupportsInt�Union)� Attribute� Interface� implementer)�defer�protocol)�CannotListenError)�failure�log� randbytes�util)�cmp� comparable� nativeString)d� IEncodable�IRecord�IEncodableRecord�A�A6�AAAA�AFSDB�CNAME�DNAME�HINFO�MAILA�MAILB�MB�MD�MF�MG�MINFO�MR�MX�NAPTR�NS�NULL�OPT�PTR�RP�SOA�SPF�SRV�TXT�SSHFP�TSIG�WKS�ANY�CH�CS�HS�IN� ALL_RECORDS�AXFR�IXFR�EFORMAT�ENAME�ENOTIMP�EREFUSED�ESERVER� EBADVERSION�EBADSIG�EBADKEY�EBADTIME�Record_A� Record_A6� Record_AAAA� Record_AFSDB� Record_CNAME� Record_DNAME� Record_HINFO� Record_MB� Record_MD� Record_MF� Record_MG� Record_MINFO� Record_MR� Record_MX� Record_NAPTR� Record_NS� Record_NULL� Record_PTR� Record_RP� Record_SOA� Record_SPF� Record_SRV� Record_SSHFP� Record_TSIG� Record_TXT� Record_WKS� UnknownRecord� QUERY_CLASSES� QUERY_TYPES� REV_CLASSES� REV_TYPES� EXT_QUERIES�Charstr�Message�Name�Query�RRHeader� SimpleRecord�DNSDatagramProtocol�DNSMixin� DNSProtocol�OK� OP_INVERSE� OP_NOTIFY�OP_QUERY� OP_STATUS� OP_UPDATE�PORT�AuthoritativeDomainError�DNSQueryTimeoutError� DomainErrorc C s t | g�S )z� Construct a bytes object representing a single byte with the given ordinal value. @type ordinal: L{int} @rtype: L{bytes} ��bytes)�ordinal� r{ �3/usr/lib/python3/dist-packages/twisted/names/dns.py� _ord2bytes� s r} c C s t | �dd� S )z� Represent a mostly textful bytes object in a way suitable for presentation to an end user. @param bytes: The bytes to represent. @rtype: L{str} � N)�reprrx r{ r{ r| � _nicebytes� s r� c C s d� d�dd� | D ���S )z� Represent a list of mostly textful bytes objects in a way suitable for presentation to an end user. @param list: The list of bytes to represent. @rtype: L{str} z[{}]�, c S s g | ]}t |��qS r{ )r� )�.0�br{ r{ r| � <listcomp>� s z"_nicebyteslist.<locals>.<listcomp>)�format�join)�listr{ r{ r| �_nicebyteslist� s r� c C s t �dtjddd��d S )z� Wrapper around L{twisted.python.randbytes.RandomFactory.secureRandom} to return 2 random bytes. @rtype: L{bytes} �H� T)�fallbackr )�struct�unpackr � secureRandomr{ r{ r{ r| � randomSource� s r� �5 r~ � � �! �# �& �' �) �, �c � � r r( r! r" r r- r r# r% r) r3 r+ r r$ r& r0 r, r r r/ r' r r r* r1 r. �TKEYr2 � � r; r: r r r9 c C � i | ]\}}||�qS r{ r{ �r� �k�vr{ r{ r| � <dictcomp> � r� � � r8 r6 r5 r7 r4 c C r� r{ r{ r� r{ r{ r| r� r� � � � � c @ s e Zd ZdZed�ZdS )r z0 A single entry in a zone of authority. z,An indicator of what kind of record this is.N)�__name__� __module__� __qualname__�__doc__r �TYPEr{ r{ r{ r| r s r )ru rv rw c C s2 | dv rdgS | � d�}|d dkr|�d� |S )a2 Split a domain name into its constituent labels. @type name: L{bytes} @param name: A fully qualified domain name (with or without a trailing dot). @return: A L{list} of labels ending with an empty label representing the DNS root zone. @rtype: L{list} of L{bytes} )� � .r� r� ���)�split�append)�name�labelsr{ r{ r| � _nameToLabels* s r� c C s> t | t�r | �d�} t | t�s td�tjtj| t| ����| S )a� Coerce a domain name string to bytes. L{twisted.names} represents domain names as L{bytes}, but many interfaces accept L{bytes} or a text string (L{unicode} on Python 2, L{str} on Python 3). This function coerces text strings using IDNA encoding --- see L{encodings.idna}. Note that DNS is I{case insensitive} but I{case preserving}. This function doesn't normalize case, so you'll still need to do that whenever comparing the strings it returns. @param domain: A domain name. If passed as a text string it will be C{idna} encoded. @type domain: L{bytes} or L{str} @returns: L{bytes} suitable for network transmission. @rtype: L{bytes} @since: Twisted 20.3.0 �idnaz+Expected {} or {} but found {!r} of type {})� isinstance�str�encodery � TypeErrorr� r� �type)�domainr{ r{ r| � domainString> s ��r� c C s. t | �� �}t |�� �}|t|� d� |kS )a) Test whether C{descendantName} is equal to or is a I{subdomain} of C{ancestorName}. The names are compared case-insensitively. The names are treated as byte strings containing one or more DNS labels separated by B{.}. C{descendantName} is considered equal if its sequence of labels exactly matches the labels of C{ancestorName}. C{descendantName} is considered a I{subdomain} if its sequence of labels ends with the labels of C{ancestorName}. @type descendantName: L{bytes} @param descendantName: The DNS subdomain name. @type ancestorName: L{bytes} @param ancestorName: The DNS parent or ancestor domain name. @return: C{True} if C{descendantName} is equal to or if it is a subdomain of C{ancestorName}. Otherwise returns C{False}. N)r� �lower�len)�descendantName� ancestorName�descendantLabels�ancestorLabelsr{ r{ r| �_isSubdomainOf_ s r� c C s� d}t | t�r | �d�} t | t�rF| �� �� } |D ]\}}| �|�r0tt| dd� �| � S qzt| �} W | S t yE t d| ��w | S )aE Parse a string description of an interval into an integer number of seconds. @param s: An interval definition constructed as an interval duration followed by an interval unit. An interval duration is a base ten representation of an integer. An interval unit is one of the following letters: S (seconds), M (minutes), H (hours), D (days), W (weeks), or Y (years). For example: C{"3S"} indicates an interval of three seconds; C{"5D"} indicates an interval of five days. Alternatively, C{s} may be any non-string and it will be returned unmodified. @type s: text string (L{bytes} or L{str}) for parsing; anything else for passthrough. @return: an L{int} giving the interval represented by the string C{s}, or whatever C{s} is if it is not a string. ))�Sr~ )�M�< )r� i )�Di�Q )�Wi�: )�Yi�3��asciiNr� z!Invalid time interval specifier: ) r� ry �decoder� �upper�strip�endswith�int�float� ValueError)�s�suffixes�suff�multr{ r{ r| �str2time} s � � �r� c C s | � |�}t|�|k r t�|S �N)�readr� �EOFError)�file�l�buffr{ r{ r| � readPrecisely� s r� c @ s$ e Zd ZdZddd�Zddd�ZdS )r z� Interface for something which can be encoded to and decoded to the DNS wire format. A binary-mode file object (such as L{io.BytesIO}) is used as a buffer when encoding or decoding. Nc C � dS )a� Write a representation of this object to the given file object. @type strio: File-like object @param strio: The buffer to write to. It must have a C{tell()} method. @type compDict: L{dict} of L{bytes} to L{int} r L{None} @param compDict: A mapping of names to byte offsets that have already been written to the buffer, which may be used for compression (see RFC 1035 section 4.1.4). When L{None}, encode without compression. Nr{ )�strio�compDictr{ r{ r| r� � � zIEncodable.encodec C r� )a� Reconstruct an object from data read from the given file object. @type strio: File-like object @param strio: A seekable buffer from which bytes may be read. @type length: L{int} or L{None} @param length: The number of bytes in this RDATA field. Most implementations can ignore this value. Only in the case of records similar to TXT where the total length is in no way encoded in the data is it necessary. Nr{ )r� �lengthr{ r{ r| r� � r� zIEncodable.decoder� )r� r� r� r� r� r� r{ r{ r{ r| r � s r c @ s e Zd ZdZdS )r z` Interface for DNS records that can be encoded and decoded. @since: Twisted 21.2.0 N)r� r� r� r� r{ r{ r{ r| r � s r c @ sR e Zd Zddd�Zddd�Zddd�Zd ed efd d �Zd d� Z d e fdd�Z dS )re r� c C s" t |t�s t|�d���|| _d S )Nz is not a byte string)r� ry r� �string)�selfr� r{ r{ r| �__init__� s zCharstr.__init__Nc C s* | j }t|�}|�t|�� |�|� dS )z� Encode this Character string into the appropriate byte format. @type strio: file @param strio: The byte representation of this Charstr will be written to this file. N)r� r� �writer} )r� r� r� r� �indr{ r{ r| r� � s zCharstr.encodec C s$ d| _ tt|d��}t||�| _ dS )a Decode a byte string into this Charstr. @type strio: file @param strio: Bytes will be read from this file until the full string is decoded. @raise EOFError: Raised when there are not enough bytes available from C{strio}. r� r~ N)r� �ordr� )r� r� r� r� r{ r{ r| r� � s zCharstr.decode�other�returnc C s t |t�r | j|jkS tS r� )r� re r� �NotImplemented�r� r� r{ r{ r| �__eq__� s zCharstr.__eq__c C � t | j�S r� )�hashr� �r� r{ r{ r| �__hash__ � zCharstr.__hash__c C r� )zI Represent this L{Charstr} instance by its string value. )r r� r� r{ r{ r| �__str__ � zCharstr.__str__�r� r� ) r� r� r� r� r� r� �object�boolr� r� r� r� r{ r{ r{ r| re � s re c @ sV e Zd ZdZddd�Zddd�Zddd �Zd ed efd d �Z dd� Z d e fdd�Z dS )rg z� A name in the domain name system, made up of multiple labels. For example, I{twistedmatrix.com}. @ivar name: A byte string giving the name. @type name: L{bytes} r� c C s t |�| _dS )zM @param name: A name. @type name: L{bytes} or L{str} N)r� r� )r� r� r{ r{ r| r� s z Name.__init__Nc C s� | j }|rT|dur%||v r |�t�dd|| B �� dS |�� tj ||< |�d�}|dkr>|d|� ||d d� }}n|}d}t|�}|�t |�� |�|� |s|�d� dS )a� Encode this Name into the appropriate byte format. @type strio: file @param strio: The byte representation of this Name will be written to this file. @type compDict: dict @param compDict: dictionary of Names that have already been encoded and whose addresses may be backreferenced by this Name (for the purpose of reducing the message size). N�!Hi � r� r r~ � ) r� r� r� �pack�tellrf � headerSize�findr� r} )r� r� r� r� r� �labelr{ r{ r| r� s" �z Name.encodec C s� t � }d| _d} tt|d��}|dkr |dkr |�|� dS |d? dkrM|d@ d> tt|d��B }||v r:td ��|�|� |dkrG|�� }|�|� qt||�}| jdkr[|| _n| jd | | _q ) a� Decode a byte string into this Name. @type strio: file @param strio: Bytes will be read from this file until the full Name is decoded. @raise EOFError: Raised when there are not enough bytes available from C{strio}. @raise ValueError: Raised when the name cannot be decoded (for example, because it contains a loop). r� r r~ Nr� r� �? � z Compression loop in encoded namer� )�setr� r� r� �seekr� �addr� )r� r� r� �visited�offr� �new_offr r{ r{ r| r� ? s. �z Name.decoder� r� c C s" t |t�r| j�� |j�� kS tS r� )r� rg r� r� r� r� r{ r{ r| r� e s z Name.__eq__c C r� r� �r� r� r� r{ r{ r| r� j r� z Name.__hash__c C r� )zE Represent this L{Name} instance by its string name. �r r� r� r{ r{ r| r� m r� z Name.__str__r� r� ) r� r� r� r� r� r� r� r� r� r� r� r� r� r{ r{ r{ r| rg s !&rg c @ sv e Zd ZdZdeefdeeef de de fdd�Z dd d �Z dd d �Z d d� Z dd� Zdefdd�Zdefdd�ZdS )rh z� Represent a single DNS query. @ivar name: The name about which this query is requesting information. @type name: L{Name} @ivar type: The query type. @type type: L{int} @ivar cls: The query class. @type cls: L{int} r� r� r� �clsc C s t |�| _|| _|| _dS )z� @type name: L{bytes} or L{str} @param name: See L{Query.name} @type type: L{int} @param type: The query type. @type cls: L{int} @param cls: The query class. N)rg r� r� r �r� r� r� r r{ r{ r| r� � s zQuery.__init__Nc C s* | j �||� |�t�d| j| j�� d S �N�!HH)r� r� r� r� r� r� r �r� r� r� r{ r{ r| r� � s z Query.encodec C s. | j �|� t|d�}t�d|�\| _| _d S )Nr� r )r� r� r� r� r� r� r )r� r� r� r� r{ r{ r| r� � s z Query.decodec C s t | jj�� | j| jf�S r� )r� r� r� r� r r� r{ r{ r| r� � s zQuery.__hash__c C s< t |t�r t| jj�� | j| jf|jj�� |j|jf�S tS r� )r� rh r r� r� r� r r� r� r{ r{ r| �__cmp__� s �z Query.__cmp__r� c C sL t �| jt�| jd| j ��}t�| jd| j �}d| j� d|� d|� d�S )N� UNKNOWN (%d)z<Query � �>)ra �getr� rd r` r r� �r� �t�cr{ r{ r| r� � s �z Query.__str__c C s d| j j �d| j�d| j�d�S )NzQuery(r� �))r� r� r r� r{ r{ r| �__repr__� � zQuery.__repr__r� )r� r� r� r� r r8 r ry r� r� r� r� r� r� r r� r r{ r{ r{ r| rh t s & rh c @ sz e Zd ZdZddd� fddddd d fZd Z d dd�Zedd� �Zedd� �Z d dd�Z d dd�Z e dd� �Z dS ) � _OPTHeaderaZ An OPT record header. @ivar name: The DNS name associated with this record. Since this is a pseudo record, the name is always an L{Name} instance with value b'', which represents the DNS root zone. This attribute is a readonly property. @ivar type: The DNS record type. This is a fixed value of 41 C{dns.OPT} for OPT Record. This attribute is a readonly property. @see: L{_OPTHeader.__init__} for documentation of other public instance attributes. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2} @since: 13.2 r� c C r� r� r )�nr{ r{ r| �<lambda>� s z_OPTHeader.<lambda>r� �udpPayloadSize� extendedRCODE�version�dnssecOK�options)r� r� r r r! r" r# � r FNc C s. || _ || _|| _|| _|du rg }|| _dS )a� @type udpPayloadSize: L{int} @param udpPayloadSize: The number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type extendedRCODE: L{int} @param extendedRCODE: Forms the upper 8 bits of extended 12-bit RCODE (together with the 4 bits defined in [RFC1035]. Note that EXTENDED-RCODE value 0 indicates that an unextended RCODE is in use (values 0 through 15). @type version: L{int} @param version: Indicates the implementation level of the setter. Full conformance with this specification is indicated by version C{0}. @type dnssecOK: L{bool} @param dnssecOK: DNSSEC OK bit as defined by [RFC3225]. @type options: L{list} @param options: A L{list} of 0 or more L{_OPTVariableOption} instances. N�r r r! r" r# )r� r r r! r" r# r{ r{ r| r� � s z_OPTHeader.__init__c C s t d�S )a/ A readonly property for accessing the C{name} attribute of this record. @return: The DNS name associated with this record. Since this is a pseudo record, the name is always an L{Name} instance with value b'', which represents the DNS root zone. r� )rg r� r{ r{ r| r� s z_OPTHeader.namec C s t S )z� A readonly property for accessing the C{type} attribute of this record. @return: The DNS record type. This is a fixed value of 41 (C{dns.OPT} for OPT Record. )r* r� r{ r{ r| r� s z_OPTHeader.typec C sh t � }| jD ]}|�|� q|�� }t| jj| j| j| jd> | j d> B | j d> B t |�d��||� dS )a� Encode this L{_OPTHeader} instance to bytes. @type strio: file @param strio: the byte representation of this L{_OPTHeader} will be written to this file. @type compDict: L{dict} or L{None} @param compDict: A dictionary of backreference addresses that have already been written to this stream and that may be used for DNS name compression. � r� � )r� r� r �ttl�payloadN) r r# r� �getvalueri r� r� r r r! r" r_ )r� r� r� r� �o� optionBytesr{ r{ r| r� s �z_OPTHeader.encodec C sX t � }|�||� tt||j��|_| �|�}| jD ]}|dvr)t| |t ||�� qdS )a Decode bytes into an L{_OPTHeader} instance. @type strio: file @param strio: Bytes will be read from this file until the full L{_OPTHeader} is decoded. @type length: L{int} or L{None} @param length: Not used. )r� r� N) ri r� r_ r� �rdlengthr) � fromRRHeader�compareAttributes�setattr�getattr)r� r� r� �h� newOptHeader�attrNamer{ r{ r| r� 6 s ��z_OPTHeader.decodec C s� d}|j dur.g }t|j j�}t|j j�}|�� |k r.t� }|�|� |�|� |�� |k s| |j|j d? |j d? d@ |j d@ d? |d�S )ai A classmethod for constructing a new L{_OPTHeader} from the attributes and payload of an existing L{RRHeader} instance. @type rrHeader: L{RRHeader} @param rrHeader: An L{RRHeader} instance containing an L{UnknownRecord} payload. @return: An instance of L{_OPTHeader}. @rtype: L{_OPTHeader} Nr& r� r� i�� r' r% ) r) r �datar� r� �_OPTVariableOptionr� r� r r( )r �rrHeaderr# � optionsBytes�optionsBytesLengthr+ r{ r{ r| r. L s" � �z_OPTHeader.fromRRHeader)r$ r r FNr� )r� r� r� r� �showAttributesr/ r� �propertyr� r� r� r� � classmethodr. r{ r{ r{ r| r � s2 � �) r c @ sB e Zd ZdZddeffZdZdZddd �Zdd d �Z dd d�Z d S )r6 z� A class to represent OPT record variable options. @see: L{_OPTVariableOption.__init__} for documentation of public instance attributes. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2} @since: 13.2 �coder5 �r= r5 r r r� c C s || _ || _dS )z� @type code: L{int} @param code: The option code @type data: L{bytes} @param data: The option data Nr> )r� r= r5 r{ r{ r| r� s z_OPTVariableOption.__init__Nc C s( |� t�| j| jt| j��| j � dS )a� Encode this L{_OPTVariableOption} to bytes. @type strio: file @param strio: the byte representation of this L{_OPTVariableOption} will be written to this file. @type compDict: L{dict} or L{None} @param compDict: A dictionary of backreference addresses that have already been written to this stream and that may be used for DNS name compression. N)r� r� r� �_fmtr= r� r5 r r{ r{ r| r� � s ( z_OPTVariableOption.encodec C s: t �| j�}t||�}t �| j|�\| _}t||�| _dS )a Decode bytes into an L{_OPTVariableOption} instance. @type strio: file @param strio: Bytes will be read from this file until the full L{_OPTVariableOption} is decoded. @type length: L{int} or L{None} @param length: Not used. N)r� �calcsizer? r� r� r= r5 )r� r� r� r� r� r{ r{ r| r� � s z_OPTVariableOption.decode)r r� r� ) r� r� r� r� r r: r/ r? r� r� r� r{ r{ r{ r| r6 m s r6 c @ s� e Zd ZdZdZdZdZdZdee dddfde e e f d e d e d ed ee d ef dd�Zddd�Zddd�Zdd� Zde fdd�ZeZdS )ri ak A resource record header. @cvar fmt: L{str} specifying the byte format of an RR. @ivar name: The name about which this reply contains information. @type name: L{Name} @ivar type: The query type of the original request. @type type: L{int} @ivar cls: The query class of the original request. @ivar ttl: The time-to-live for this record. @type ttl: L{int} @ivar payload: The record described by this header. @type payload: L{IEncodableRecord} or L{None} @ivar auth: A L{bool} indicating whether this C{RRHeader} was parsed from an authoritative message. )r� r� r r( r) �authz!HHIHNr� r Fr� r� r r( r) rA c C s� |du rdn|j }|dur!||kr!tdt�||�t�||�f ��t|�}|dk r-td��t|�| _|| _|| _|| _ || _ || _ dS )a� @type name: L{bytes} or L{str} @param name: See L{RRHeader.name} @type type: L{int} @param type: The query type. @type cls: L{int} @param cls: The query class. @type ttl: L{int} @param ttl: Time to live for this record. This will be converted to an L{int}. @type payload: L{IEncodableRecord} or L{None} @param payload: An optional Query Type specific data object. @raises TypeError: if the ttl cannot be converted to an L{int}. @raises ValueError: if the ttl is negative. @raises ValueError: if the payload type is not equal to the C{type} argument. Nz0Payload type (%s) does not match given type (%s)r zTTL cannot be negative) r� r� ra r r� rg r� r� r r( r) rA ) r� r� r� r r( r) rA � payloadType� integralTTLr{ r{ r| r� � s$ ��� zRRHeader.__init__c C s� | j �||� |�t�| j| j| j| jd�� | j rD|� � }| j �||� |� � }|� |d d� |�t�d|| �� |� |d� d S d S )Nr r� r� ) r� r� r� r� r� �fmtr� r r( r) r� r )r� r� r� �prefix�aftr{ r{ r| r� s �zRRHeader.encodec C sH | j �|� t�| j�}t||�}t�| j|�}|\| _| _| _ | _ d S r� ) r� r� r� r@ rD r� r� r� r r( r- )r� r� r� r� r� �rr{ r{ r| r� s zRRHeader.decodec C s | j S r� �rA r� r{ r{ r| �isAuthoritative s zRRHeader.isAuthoritativer� c C sR t �| jt�| jd| j ��}t�| jd| j �}d| j||| j| jr%dp&df S )Nr z-<RR name=%s type=%s class=%s ttl=%ds auth=%s>�True�False) ra r r� rd r` r r� r( rA r r{ r{ r| r� s � �zRRHeader.__str__r� )r� r� r� r� r/ rD r- �cachedResponser r8 r ry r� r� r r r r� r� r� r� rI r� r r{ r{ r{ r| ri � s< � ����� � 5 ri c @ sT e Zd ZU dZdZdZdZee e d< dZ ddd�Z dd d �Z dd d �Z d d� ZdS )rj a A Resource Record which consists of a single RFC 1035 domain-name. @type name: L{Name} @ivar name: The name associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. )�r� r� �%sr( )r� r( Nr� r� c C s t |�| _t|�| _dS )z^ @param name: See L{SimpleRecord.name} @type name: L{bytes} or L{str} N)rg r� r� r( )r� r� r( r{ r{ r| r� 8 s zSimpleRecord.__init__c C s | j �||� d S r� )r� r� r r{ r{ r| r� @ s zSimpleRecord.encodec C s t � | _| j�|� d S r� )rg r� r� �r� r� r� r{ r{ r| r� C s zSimpleRecord.decodec C r� r� r r� r{ r{ r| r� G r� zSimpleRecord.__hash__�r� Nr� )r� r� r� r� r: r/ r� r r� �__annotations__r� r� r� r� r� r{ r{ r{ r| rj % s rj c @ � e Zd ZdZeZdZdS )rT z& An authoritative nameserver. r( N)r� r� r� r� r( r� � fancybasenamer{ r{ r{ r| rT L � rT c @ rR )rM zX A mail destination. This record type is obsolete. @see: L{Record_MX} r! N)r� r� r� r� r! r� rS r{ r{ r{ r| rM U � rM c @ rR )rN zV A mail forwarder. This record type is obsolete. @see: L{Record_MX} r" N)r� r� r� r� r" r� rS r{ r{ r{ r| rN b rU rN c @ rR )rI z* The canonical name for an alias. r N)r� r� r� r� r r� rS r{ r{ r{ r| rI o rT rI c @ rR )rL zJ A mailbox domain name. This is an experimental record type. r N)r� r� r� r� r r� rS r{ r{ r{ r| rL x � rL c @ rR )rO zH A mail group member. This is an experimental record type. r# N)r� r� r� r� r# r� rS r{ r{ r{ r| rO � rV rO c @ rR )rQ zN A mail rename domain name. This is an experimental record type. r% N)r� r� r� r� r% r� rS r{ r{ r{ r| rQ � rV rQ c @ rR )rV z A domain name pointer. r+ N)r� r� r� r� r+ r� rS r{ r{ r{ r| rV � rT rV c @ rR )rJ a[ A non-terminal DNS name redirection. This record type provides the capability to map an entire subtree of the DNS name space to another domain. It differs from the CNAME record which maps a single node of the name space. @see: U{http://www.faqs.org/rfcs/rfc2672.html} @see: U{http://www.faqs.org/rfcs/rfc3363.html} r N)r� r� r� r� r r� rS r{ r{ r{ r| rJ � s rJ c @ s\ e Zd ZdZdZeZdZddd�Zddd�Z dd d �Z d d � Z d e fdd�Z e Zdd� ZdS )rE a An IPv4 host address. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv4 address associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. ��addressr( N�0.0.0.0c C s2 t |t�r |�d�}t�|�}|| _t|�| _dS )�� @type address: L{bytes} or L{str} @param address: The IPv4 address associated with this record, in quad-dotted notation. r� N)r� ry r� �socket� inet_atonrX r� r( �r� rX r( r{ r{ r| r� � s zRecord_A.__init__c C � |� | j� d S r� �r� rX r r{ r{ r| r� � � zRecord_A.encodec C � t |d�| _d S )Nr� �r� rX rO r{ r{ r| r� � r` zRecord_A.decodec C r� r� �r� rX r� r{ r{ r| r� � r� zRecord_A.__hash__r� c C s d| � � � d| j� d�S )Nz <A address=z ttl=r )� dottedQuadr( r� r{ r{ r| r� � � zRecord_A.__str__c C � t �| j�S r� �r[ � inet_ntoarX r� r{ r{ r| rd � s zRecord_A.dottedQuad)rY Nr� )r� r� r� r� r/ r r� rX r� r� r� r� r� r� r rd r{ r{ r{ r| rE � s rE c @ sV e Zd ZdZdZdZdZeZ ddd �Z dd d �Z dd d �Z dd� Z dS )rX aA Marks the start of a zone of authority. This record describes parameters which are shared by all records within a particular zone. @type mname: L{Name} @ivar mname: The domain-name of the name server that was the original or primary source of data for this zone. @type rname: L{Name} @ivar rname: A domain-name which specifies the mailbox of the person responsible for this zone. @type serial: L{int} @ivar serial: The unsigned 32 bit version number of the original copy of the zone. Zone transfers preserve this value. This value wraps and should be compared using sequence space arithmetic. @type refresh: L{int} @ivar refresh: A 32 bit time interval before the zone should be refreshed. @type minimum: L{int} @ivar minimum: The unsigned 32 bit minimum TTL field that should be exported with any RR from this zone. @type expire: L{int} @ivar expire: A 32 bit time value that specifies the upper limit on the time interval that can elapse before the zone is no longer authoritative. @type retry: L{int} @ivar retry: A 32 bit time interval that should elapse before a failed refresh should be retried. @type ttl: L{int} @ivar ttl: The default TTL to use for records served from this zone. r- )�serial�mname�rname�refresh�expire�retry�minimumr( ))rj rj rN )rk rk rN ri rl rn rm ro r( r� r Nc C sZ t |�t |�| _| _t|�t|�| _| _t|�t|�| _| _t|�| _t|�| _ dS )z� @param mname: See L{Record_SOA.mname} @type mname: L{bytes} or L{str} @param rname: See L{Record_SOA.rname} @type rname: L{bytes} or L{str} N) rg rj rk r� ri rl ro rm rn r( ) r� rj rk ri rl rn rm ro r( r{ r{ r| r� % s zRecord_SOA.__init__c C sD | j �||� | j�||� |�t�d| j| j| j| j | j �� d S )N�!LlllL) rj r� rk r� r� r� ri rl rn rm ro r r{ r{ r| r� = s ��zRecord_SOA.encodec C sX t � t � | _| _| j�|� | j�|� t�dt|d��}|\| _| _| _ | _ | _ d S )Nrp � ) rg rj rk r� r� r� r� ri rl rn rm ro �r� r� r� rG r{ r{ r| r� K s zRecord_SOA.decodec C � t | j| j| j| j| j| jf�S r� )r� ri rj rk rl rm rn r� r{ r{ r| r� R s �zRecord_SOA.__hash__)r� r� r r r r r Nr� ) r� r� r� r� rS r/ r: r- r� r� r� r� r� r{ r{ r{ r| rX � s$ ' � rX c @ sN e Zd ZdZdZdefdfZdZeZ ddd�Z dd d �Z dd d �Z d d� Z dS )rU z� A null record. This is an experimental record type. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r) r) r( )r) r( Nc C � || _ t|�| _d S r� )r) r� r( )r� r) r( r{ r{ r| r� j � zRecord_NULL.__init__c C r^ r� )r� r) r r{ r{ r| r� n r` zRecord_NULL.encodec C s t ||�| _d S r� )r� r) rO r{ r{ r| r� q r` zRecord_NULL.decodec C r� r� )r� r) r� r{ r{ r| r� t r� zRecord_NULL.__hash__)NNr� )r� r� r� r� rS r� r: r/ r) r� r� r� r� r� r{ r{ r{ r| rU X s rU c @ sV e Zd ZdZdZdZg d�ZeZe dd� �Z dd d �Z dd d�Z ddd�Z dd� Zd S )r^ aX A well known service description. This record type is obsolete. See L{Record_SRV}. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv4 address associated with this record. @type protocol: L{int} @ivar protocol: The 8 bit IP protocol number for which this service map is relevant. @type map: L{bytes} @ivar map: A bitvector indicating the services available at the specified address. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r3 )rX r �mapr( )��_addressrX rN r r( c C rf r� rg r� r{ r{ r| rx � s zRecord_WKS._addressrY r r� Nc C s< t |t�r |�d�}t�|�| _||| _| _t|�| _ dS )rZ r� N) r� ry r� r[ r\ rX r rv r� r( )r� rX r rv r( r{ r{ r| r� � s zRecord_WKS.__init__c C s0 |� | j� |� t�d| j�� |� | j� d S �N�!B)r� rX r� r� r rv r r{ r{ r| r� � s zRecord_WKS.encodec C s8 t |d�| _t�dt |d��d | _t ||d �| _d S )Nr� rz r~ r r� )r� rX r� r� r rv rO r{ r{ r| r� � s zRecord_WKS.decodec C � t | j| j| jf�S r� )r� rX r rv r� r{ r{ r| r� � � zRecord_WKS.__hash__)rY r r� Nr� )r� r� r� r� rS r/ r: r3 r� r; rx r� r� r� r� r{ r{ r{ r| r^ x s r^ c @ sR e Zd ZdZeZdZdZdZe dd� �Z dd d �Z dd d �Z dd d�Z dd� ZdS )rG aT An IPv6 host address. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv6 address associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1886.html} r )rw r( rW c C � t �t| j�S r� )r[ � inet_ntop�AF_INET6rX r� r{ r{ r| rx � � zRecord_AAAA._address�::Nc C s0 t |t�r |�d�}t�t|�| _t|�| _dS )z @type address: L{bytes} or L{str} @param address: The IPv6 address for this host, in RFC 2373 format. r� N) r� ry r� r[ � inet_ptonr rX r� r( r] r{ r{ r| r� � s zRecord_AAAA.__init__c C r^ r� r_ r r{ r{ r| r� � r` zRecord_AAAA.encodec C ra )Nr� rb rO r{ r{ r| r� � r` zRecord_AAAA.decodec C r� r� rc r� r{ r{ r| r� � r� zRecord_AAAA.__hash__)r� Nr� )r� r� r� r� r r� rS r: r/ r; rx r� r� r� r� r{ r{ r{ r| rG � s rG c @ sr e Zd ZdZeZdZdZdZe dd� �Z dd d �Z dd d�Z ddd�Z dedefdd�Zdd� Zdefdd�Zd S )rF a� An IPv6 address. This is an experimental record type. @type prefixLen: L{int} @ivar prefixLen: The length of the suffix. @type suffix: L{bytes} @ivar suffix: An IPv6 address suffix in network order. @type prefix: L{Name} @ivar prefix: If specified, a name which will be used as a prefix for other A6 records. @type bytes: L{int} @ivar bytes: The length of the prefix. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2874.html} @see: U{http://www.faqs.org/rfcs/rfc3363.html} @see: U{http://www.faqs.org/rfcs/rfc3364.html} r ))�_suffix�suffixrN )rE rE rN r( )� prefixLenrE r� r( c C r} r� )r[ r~ r r� r� r{ r{ r| r� r� zRecord_A6._suffixr r� r� Nc C sT t |t�r |�d�}|| _t�t|�| _t|�| _ t d| j d �| _t |�| _ dS )z� @param suffix: An IPv6 address suffix in in RFC 2373 format. @type suffix: L{bytes} or L{str} @param prefix: An IPv6 address prefix for other A6 records. @type prefix: L{bytes} or L{str} r� � � @N) r� ry r� r� r[ r� r r� rg rE r� r� r( )r� r� r� rE r( r{ r{ r| r� s zRecord_A6.__init__c C sN |� t�d| j�� | jr|� | j| j d � � | jr%| j�|d � d S d S ry )r� r� r� r� ry r� rE r� r r{ r{ r| r� s �zRecord_A6.encodec C sh t �dt|d��d | _td| j d �| _| jr'dd| j t|| j� | _| jr2| j�|� d S d S )Nrz r~ r r� r� r� r� ) r� r� r� r� r� ry r� rE r� rO r{ r{ r| r� $ s �zRecord_A6.decoder� r� c C sV t |t�r)| j|jko(| j| j d � |j| j d � ko(| j|jko(| j|jkS tS r� )r� rF r� r� ry rE r( r� r� r{ r{ r| r� , s "� � �zRecord_A6.__eq__c C s t | j| j| j d � | jf�S r� )r� r� r� ry rE r� r{ r{ r| r� 6 r zRecord_A6.__hash__c C s d| j t�t| j�| j| jf S )Nz<A6 %s %s (%d) ttl=%s>)rE r[ r~ r r� r� r( r� r{ r{ r| r� 9 s �zRecord_A6.__str__)r r� r� Nr� )r� r� r� r� r r� rS r: r/ r; r� r� r� r� r� r� r� r� r� r� r{ r{ r{ r| rF � s rF c @ �F e Zd ZdZeZdZdZdZddd �Z dd d �Z dd d �Z dd� Z dS )rZ a: The location of the server(s) for a specific protocol and domain. This is an experimental record type. @type priority: L{int} @ivar priority: The priority of this target host. A client MUST attempt to contact the target host with the lowest-numbered priority it can reach; target hosts with the same priority SHOULD be tried in an order defined by the weight field. @type weight: L{int} @ivar weight: Specifies a relative weight for entries with the same priority. Larger weights SHOULD be given a proportionately higher probability of being selected. @type port: L{int} @ivar port: The port on this target host of this service. @type target: L{Name} @ivar target: The domain name of the target host. There MUST be one or more address records for this name, the name MUST NOT be an alias (in the sense of RFC 1034 or RFC 2181). Implementors are urged, but not required, to return the address record(s) in the Additional Data section. Unless and until permitted by future standards action, name compression is not to be used for this field. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2782.html} r/ )�priority�weight�target�portr( )r� r� )r� r� rN r� r( r r� Nc C s6 t |�| _t |�| _t |�| _t|�| _t|�| _dS )zb @param target: See L{Record_SRV.target} @type target: L{bytes} or L{str} N)r� r� r� r� rg r� r� r( )r� r� r� r� r� r( r{ r{ r| r� l s zRecord_SRV.__init__c C s. |� t�d| j| j| j�� | j�|d � d S �N�!HHH)r� r� r� r� r� r� r� r� r r{ r{ r| r� w s zRecord_SRV.encodec C s@ t �dt|t �d���}|\| _| _| _t� | _| j� |� d S r� ) r� r� r� r@ r� r� r� rg r� r� rr r{ r{ r| r� | s zRecord_SRV.decodec C � t | j| j| j| jf�S r� )r� r� r� r� r� r� r{ r{ r| r� � re zRecord_SRV.__hash__)r r r r� Nr� ) r� r� r� r� r/ r� rS r/ r: r� r� r� r� r{ r{ r{ r| rZ B s " rZ c @ sT e Zd ZdZeZdZdZdZ ddd �Z dd d �Z dd d �Z dd� Z dS )rS a The location of the server(s) for a specific protocol and domain. @type order: L{int} @ivar order: An integer specifying the order in which the NAPTR records MUST be processed to ensure the correct ordering of rules. Low numbers are processed before high numbers. @type preference: L{int} @ivar preference: An integer that specifies the order in which NAPTR records with equal "order" values SHOULD be processed, low numbers being processed before high numbers. @type flag: L{Charstr} @ivar flag: A <character-string> containing flags to control aspects of the rewriting and interpretation of the fields in the record. Flags are single characters from the set [A-Z0-9]. The case of the alphabetic characters is not significant. At this time only four flags, "S", "A", "U", and "P", are defined. @type service: L{Charstr} @ivar service: Specifies the service(s) available down this rewrite path. It may also specify the particular protocol that is used to talk with a service. A protocol MUST be specified if the flags field states that the NAPTR is terminal. @type regexp: L{Charstr} @ivar regexp: A STRING containing a substitution expression that is applied to the original string held by the client in order to construct the next domain name to lookup. @type replacement: L{Name} @ivar replacement: The next NAME to query for NAPTR, SRV, or address records depending on the value of the flags field. This MUST be a fully qualified domain-name. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2915.html} )�order� preference�flags�service�regexp� replacementr' )r� r� )r� r� rN )r� r� rN )r� r� rN )r� r� rN r( r r� Nc C sJ t |�| _t |�| _t|�| _t|�| _t|�| _t|�| _t |�| _ dS )zs @param replacement: See L{Record_NAPTR.replacement} @type replacement: L{bytes} or L{str} N) r� r� r� re r� r� r� rg r� r� r( )r� r� r� r� r� r� r� r( r{ r{ r| r� � s zRecord_NAPTR.__init__c C sT |� t�d| j| j�� | j�|d � | j�|d � | j�|d � | j �|d � d S r ) r� r� r� r� r� r� r� r� r� r� r r{ r{ r| r� � s zRecord_NAPTR.encodec C sx t �dt|t �d���}|\| _| _t� | _t� | _t� | _ t � | _ | j� |� | j� |� | j � |� | j � |� d S r ) r� r� r� r@ r� r� re r� r� r� rg r� r� rr r{ r{ r| r� � s zRecord_NAPTR.decodec C rs r� )r� r� r� r� r� r� r� r� r{ r{ r| r� � s ��zRecord_NAPTR.__hash__)r r r� r� r� r� Nr� ) r� r� r� r� r' r� r/ rS r: r� r� r� r� r{ r{ r{ r| rS � s" , � rS c @ r� )rH a� Map from a domain name to the name of an AFS cell database server. @type subtype: L{int} @ivar subtype: In the case of subtype 1, the host has an AFS version 3.0 Volume Location Server for the named AFS cell. In the case of subtype 2, the host has an authenticated name server holding the cell-root directory node for the named DCE/NCA cell. @type hostname: L{Name} @ivar hostname: The domain name of a host that has a server for the cell named by this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1183.html} r )�subtype�hostnamer( )r� )r� r� rN r( r r� Nc C s" t |�| _t|�| _t|�| _dS )zj @param hostname: See L{Record_AFSDB.hostname} @type hostname: L{bytes} or L{str} N)r� r� rg r� r� r( )r� r� r� r( r{ r{ r| r� s zRecord_AFSDB.__init__c C �& |� t�d| j�� | j�||� d S �Nr� )r� r� r� r� r� r� r r{ r{ r| r� & � zRecord_AFSDB.encodec C s0 t �dt|t �d���}|\| _| j�|� d S r� )r� r� r� r@ r� r� r� rr r{ r{ r| r� * � zRecord_AFSDB.decodec C � t | j| jf�S r� )r� r� r� r� r{ r{ r| r� / r` zRecord_AFSDB.__hash__�r r� Nr� ) r� r� r� r� r r� rS r/ r: r� r� r� r� r{ r{ r{ r| rH s rH c @ sF e Zd ZdZeZdZdZdZddd�Z dd d �Z dd d �Z d d� Z dS )rW a� The responsible person for a domain. @type mbox: L{Name} @ivar mbox: A domain name that specifies the mailbox for the responsible person. @type txt: L{Name} @ivar txt: A domain name for which TXT RR's exist (indirection through which allows information sharing about the contents of this RP record). @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1183.html} r, )�mbox�txtr( ))r� r� rN )r� r� rN r( r� Nc C s" t |�| _t |�| _t|�| _dS )z� @param mbox: See L{Record_RP.mbox}. @type mbox: L{bytes} or L{str} @param txt: See L{Record_RP.txt} @type txt: L{bytes} or L{str} N)rg r� r� r� r( )r� r� r� r( r{ r{ r| r� M s zRecord_RP.__init__c C � | j �||� | j�||� d S r� )r� r� r� r r{ r{ r| r� Y � zRecord_RP.encodec C s, t � | _t � | _| j�|� | j�|� d S r� )rg r� r� r� rO r{ r{ r| r� ] s zRecord_RP.decodec C r� r� )r� r� r� r� r{ r{ r| r� c r` zRecord_RP.__hash__�r� r� Nr� ) r� r� r� r� r, r� rS r/ r: r� r� r� r� r{ r{ r{ r| rW 3 s rW c @ sf e Zd ZdZeZdZdefdefdfZdZ dd d �Z dd d �Z dd d�Z de defdd�Zdd� ZdS )rK a Host information. @type cpu: L{bytes} @ivar cpu: Specifies the CPU type. @type os: L{bytes} @ivar os: Specifies the OS. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r �cpu�osr( )r� r� r( r� Nc C s ||| _ | _t|�| _d S r� )r� r� r� r( )r� r� r� r( r{ r{ r| r� } s zRecord_HINFO.__init__c C s@ |� t�dt| j��| j � |� t�dt| j��| j � d S ry )r� r� r� r� r� r� r r{ r{ r| r� � s "zRecord_HINFO.encodec C sH t �dt|d��d }t||�| _t �dt|d��d }t||�| _d S )Nrz r~ r )r� r� r� r� r� )r� r� r� r� r� r{ r{ r| r� � s zRecord_HINFO.decoder� r� c C sB t |t�r | j�� |j�� ko | j�� |j�� ko | j|jkS tS r� )r� rK r� r� r� r( r� r� r{ r{ r| r� � s � �zRecord_HINFO.__eq__c C s t | j�� | j�� f�S r� )r� r� r� r� r� r{ r{ r| r� � re zRecord_HINFO.__hash__r� r� )r� r� r� r� r r� rS r� r: r/ r� r� r� r� r� r� r� r{ r{ r{ r| rK g s rK c @ sN e Zd ZdZeZdZdZdZdZ dZ ddd�Z dd d �Z dd d �Z d d� ZdS )rP a� Mailbox or mail list information. This is an experimental record type. @type rmailbx: L{Name} @ivar rmailbx: A domain-name which specifies a mailbox which is responsible for the mailing list or mailbox. If this domain name names the root, the owner of the MINFO RR is responsible for itself. @type emailbx: L{Name} @ivar emailbx: A domain-name which specifies a mailbox which is to receive error messages related to the mailing list or mailbox specified by the owner of the MINFO record. If this domain name names the root, errors should be returned to the sender of the message. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. Nr$ )�rmailbx�emailbxr( ))r� �responsibilityrN )r� �errorsrN r( r� c C s$ t |�t |�| _| _t|�| _dS )z� @param rmailbx: See L{Record_MINFO.rmailbx}. @type rmailbx: L{bytes} or L{str} @param emailbx: See L{Record_MINFO.rmailbx}. @type emailbx: L{bytes} or L{str} N)rg r� r� r� r( )r� r� r� r( r{ r{ r| r� � s zRecord_MINFO.__init__c C r� r� )r� r� r� r r{ r{ r| r� � r� zRecord_MINFO.encodec C s. t � t � | _| _| j�|� | j�|� d S r� )rg r� r� r� rO r{ r{ r| r� � s zRecord_MINFO.decodec C r� r� )r� r� r� r� r{ r{ r| r� � r` zRecord_MINFO.__hash__r� r� )r� r� r� r� r$ r� r� r� rS r/ r: r� r� r� r� r{ r{ r{ r| rP � s rP c @ r� )rR a� Mail exchange. @type preference: L{int} @ivar preference: Specifies the preference given to this RR among others at the same owner. Lower values are preferred. @type name: L{Name} @ivar name: A domain-name which specifies a host willing to act as a mail exchange. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r& )r� r� r( )r� rM r( r r� Nc K s* t |�| _t|�d|��| _t|�| _dS )z\ @param name: See L{Record_MX.name}. @type name: L{bytes} or L{str} �exchangeN)r� r� rg r r� r� r( )r� r� r� r( �kwargsr{ r{ r| r� � s zRecord_MX.__init__c C r� r� )r� r� r� r� r� r� r r{ r{ r| r� � r� zRecord_MX.encodec C s0 t �dt|d��d | _t� | _| j�|� d S )Nr� r� r )r� r� r� r� rg r� r� rO r{ r{ r| r� � r� zRecord_MX.decodec C r� r� )r� r� r� r� r{ r{ r| r� � r` zRecord_MX.__hash__r� r� ) r� r� r� r� r& r� rS r/ r: r� r� r� r� r{ r{ r{ r| rR � s rR c @ s^ e Zd ZdZdZdZdZeZdZ dZ dZ dZ dZ dZdd d �Zddd�Zddd�Zdd� Zd S )r[ ab A record containing the fingerprint of an SSH key. @type algorithm: L{int} @ivar algorithm: The SSH key's algorithm, such as L{ALGORITHM_RSA}. Note that the numbering used for SSH key algorithms is specific to the SSHFP record, and is not the same as the numbering used for KEY or SIG records. @type fingerprintType: L{int} @ivar fingerprintType: The fingerprint type, such as L{FINGERPRINT_TYPE_SHA256}. @type fingerprint: L{bytes} @ivar fingerprint: The key's fingerprint, e.g. a 32-byte SHA-256 digest. @cvar ALGORITHM_RSA: The algorithm value for C{ssh-rsa} keys. @cvar ALGORITHM_DSS: The algorithm value for C{ssh-dss} keys. @cvar ALGORITHM_ECDSA: The algorithm value for C{ecdsa-sha2-*} keys. @cvar ALGORITHM_Ed25519: The algorithm value for C{ed25519} keys. @cvar FINGERPRINT_TYPE_SHA1: The type for SHA-1 fingerprints. @cvar FINGERPRINT_TYPE_SHA256: The type for SHA-256 fingerprints. @see: U{RFC 4255 <https://tools.ietf.org/html/rfc4255>} and U{RFC 6594 <https://tools.ietf.org/html/rfc6594>} r1 �� algorithm�fingerprintType� fingerprintr( )r� r� r� r~ r� r� r� r r� c C s || _ || _|| _|| _d S r� r� )r� r� r� r� r( r{ r{ r| r� / s zRecord_SSHFP.__init__Nc C s( |� t�d| j| j�� |� | j� d S )N�!BB)r� r� r� r� r� r� r r{ r{ r| r� 5 s zRecord_SSHFP.encodec C s2 t �dt|d��}|\| _| _t||d �| _d S )Nr� r� )r� r� r� r� r� r� rr r{ r{ r| r� 9 s zRecord_SSHFP.decodec C r{ r� )r� r� r� r� r� r{ r{ r| r� > r| zRecord_SSHFP.__hash__)r r r� r r� )r� r� r� r� rS r/ r: r1 r� � ALGORITHM_RSA� ALGORITHM_DSS�ALGORITHM_ECDSA�ALGORITHM_Ed25519�FINGERPRINT_TYPE_SHA1�FINGERPRINT_TYPE_SHA256r� r� r� r� r{ r{ r{ r| r[ s r[ c @ sL e Zd ZdZeZdZdefdfZdZ dd� Z dd d �Z dd d �Z d d� Z dS )r] z� Freeform text. @type data: L{list} of L{bytes} @ivar data: Freeform text which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r0 r5 r( �r5 r( c O s t |�| _t|�dd ��| _d S )Nr( )r� r5 r� r r( )r� r5 �kwr{ r{ r| r� T s zRecord_TXT.__init__Nc C s* | j D ]}|�t�dt|��| � qd S ry )r5 r� r� r� r� )r� r� r� �dr{ r{ r| r� Y s �zRecord_TXT.encodec C st d}g | _ ||k r't�dt|d��d }| j �t||�� ||d 7 }||k s ||kr8t�d|| j|f � d S d S )Nr rz r~ z1Decoded %d bytes in %s record, but rdlength is %d)r5 r� r� r� r� r �msgrS )r� r� r� �soFar�Lr{ r{ r| r� ] s � ���zRecord_TXT.decodec C s t t| j��S r� )r� �tupler5 r� r{ r{ r| r� j s zRecord_TXT.__hash__r� )r� r� r� r� r0 r� rS r� r: r/ r� r� r� r� r{ r{ r{ r| r] B s r] c @ sN e Zd ZdZdZdZdZdefdfZddd �Z dd d �Z dd d �Z dd� Z dS )r_ a> Encapsulate the wire data for unknown record types so that they can pass through the system unchanged. @type data: L{bytes} @ivar data: Wire data which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @since: 11.1 N�UNKNOWNr� r5 r( r� c C rt r� )r5 r� r( )r� r5 r( r{ r{ r| r� � ru zUnknownRecord.__init__c C s |� | j� dS )zc Write the raw bytes corresponding to this record's payload to the stream. N)r� r5 r r{ r{ r| r� � � zUnknownRecord.encodec C s |du rt d��t||�| _dS )z~ Load the bytes which are part of this record from the stream and store them unparsed and unmodified. Nz)must know length for unknown record types)� Exceptionr� r5 rO r{ r{ r| r� � s zUnknownRecord.decodec C r� r� )r� r5 r( r� r{ r{ r| r� � r` zUnknownRecord.__hash__rP r� ) r� r� r� r� r� rS r/ r� r: r� r� r� r� r{ r{ r{ r| r_ n s r_ c @ rR )rY ao Structurally, freeform text. Semantically, a policy definition, formatted as defined in U{rfc 4408<http://www.faqs.org/rfcs/rfc4408.html>}. @type data: L{list} of L{bytes} @ivar data: Freeform text which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r. N)r� r� r� r� r. r� rS r{ r{ r{ r| rY � s rY c @ sZ e Zd ZdZdZdZg d�ZeZddddde ddfd d �Z dd d �Z dd d�Z dd� Z dS )r\ a� A transaction signature, encapsulated in a RR, as described in U{RFC 2845 <https://tools.ietf.org/html/rfc2845>}. @type algorithm: L{Name} @ivar algorithm: The name of the signature or MAC algorithm. @type timeSigned: L{int} @ivar timeSigned: Signing time, as seconds from the POSIX epoch. @type fudge: L{int} @ivar fudge: Allowable time skew, in seconds. @type MAC: L{bytes} @ivar MAC: The message digest or signature. @type originalID: L{int} @ivar originalID: A message ID. @type error: L{int} @ivar error: An error code (extended C{RCODE}) carried in exceptional cases. @type otherData: L{bytes} @ivar otherData: Other data carried in exceptional cases. r2 )r� � timeSigned�fudge�MAC� originalID�error� otherDatar( )r� r� r� r� r� Nr� r r� c C sH |d u rd nt |�| _|| _t|�| _|| _|| _|| _|| _|| _ d S r� ) rg r� r� r� r� r� r� r� r� r( ) r� r� r� r� r� r� r� r� r( r{ r{ r| r� � s zRecord_TSIG.__init__c C s� | j �||� |�t�d| j�dd � � |�t�d| jt| j��� |�| j� |�t�d| j | j t| j ��� |�| j � d S )Nz!Qr� r r� ) r� r� r� r� r� r� r� r� r� r� r� r� r r{ r{ r| r� � s �zRecord_TSIG.encodec C sv t � }|�|� || _t�ddt|d� �}|\| _| _}t||�| _t�dt|d��}|\| _ | _ }t||�| _ d S )Nz!QHHs � r� r� ) rg r� r� r� r� r� r� r� r� r� r� r� )r� r� r� r� �fields� macLength� otherLengthr{ r{ r| r� � s zRecord_TSIG.decodec C r� r� )r� r� r� r� r� r� r{ r{ r| r� re zRecord_TSIG.__hash__r� )r� r� r� r� rS r/ r: r2 r� rn r� r� r� r� r{ r{ r{ r| r\ � s$ � r\ c K s* | d|j dd�|��}|jdd� |_|S )a� Generate a L{Message} like instance suitable for use as the response to C{message}. The C{queries}, C{id} attributes will be copied from C{message} and the C{answer} flag will be set to L{True}. @param responseConstructor: A response message constructor with an initializer signature matching L{dns.Message.__init__}. @type responseConstructor: C{callable} @param message: A request message. @type message: L{Message} @param kwargs: Keyword arguments which will be passed to the initialiser of the response message. @type kwargs: L{dict} @return: A L{Message} like response instance. @rtype: C{responseConstructor} T)�id�answerNr{ )r� �queries)�responseConstructor�messager� �responser{ r{ r| �_responseFromMessage s r� c C s^ g }t �| jj�}|D ]!}|j| j}t| ||�}||v s!||kr,|�d|� d|��� q |S )a� Inspect the function signature of C{obj}'s constructor, and get a list of which arguments should be displayed. This is a helper function for C{_compactRepr}. @param obj: The instance whose repr is being generated. @param alwaysShow: A L{list} of field names which should always be shown. @param fieldNames: A L{list} of field attribute names which should be shown if they have non-default values. @return: A L{list} of displayable arguments. r �=)�inspect� signature� __class__r� � parameters�defaultr1 r� )�obj� alwaysShow� fieldNames�displayableArgsr� r� � defaultValue� fieldValuer{ r{ r| �_getDisplayableArguments& s �r� c C s� |du rg }|du r g }|du rg }|du rg }g }|D ]}||v s*t | |d�dkr/|�|� q t| ||�}d| jjg| }|rK|�d�d�|��� |D ]}t | |g �} | rb|�d|� d| ��� qM|�d � d �|�S ) a� Return a L{str} representation of C{obj} which only shows fields with non-default values, flags which are True and sections which have been explicitly set. @param obj: The instance whose repr is being generated. @param alwaysShow: A L{list} of field names which should always be shown. @param flagNames: A L{list} of flag attribute names which should be shown if they are L{True}. @param fieldNames: A L{list} of field attribute names which should be shown if they have non-default values. @param sectionNames: A L{list} of section attribute names which should be shown if they have been assigned a value. @return: A L{str} representation of C{obj}. NFT�<z flags={}�,r r� r � )r1 r� r� r� r� r� r� ) r� r� � flagNamesr� � sectionNames�setFlagsr� r� �out�sectionr{ r{ r| � _compactRepr> s0 � � r� c @ s� e Zd ZdZdZdZe�e�Zd Z Z Z Z dddddde ddddf dd�Zd efd d �Zeefd d �Zdd� Zddd�Zdd� Zi Ze� D ]Ze�d�rYe� e ee� e j< qG[dd� Z dd� Z dd� Z dS ) rf ah L{Message} contains all the information represented by a single DNS request or response. @ivar id: See L{__init__} @ivar answer: See L{__init__} @ivar opCode: See L{__init__} @ivar recDes: See L{__init__} @ivar recAv: See L{__init__} @ivar auth: See L{__init__} @ivar rCode: See L{__init__} @ivar trunc: See L{__init__} @ivar maxSize: See L{__init__} @ivar authenticData: See L{__init__} @ivar checkingDisabled: See L{__init__} @ivar queries: The queries which are being asked of or answered by DNS server. @type queries: L{list} of L{Query} @ivar answers: Records containing the answers to C{queries} if this is a response message. @type answers: L{list} of L{RRHeader} @ivar authority: Records containing information about the authoritative DNS servers for the names in C{queries}. @type authority: L{list} of L{RRHeader} @ivar additional: Records containing IP addresses of host names in C{answers} and C{authority}. @type additional: L{list} of L{RRHeader} @ivar _flagNames: The names of attributes representing the flag header fields. @ivar _fieldNames: The names of attributes representing non-flag fixed header fields. @ivar _sectionNames: The names of attributes representing the record sections of this message. )r� r� �opCode�recDes�recAvrA �rCode�trunc�maxSize� authenticData�checkingDisabledr� �answers� authority� additionalz!H2B4HNr � c C s^ | | _ || _|| _|| _|| _|| _|| _|| _|| _| | _ | | _ g | _ g | _ g | _ g | _dS )a� @param id: A 16 bit identifier assigned by the program that generates any kind of query. This identifier is copied to the corresponding reply and can be used by the requester to match up replies to outstanding queries. @type id: L{int} @param answer: A one bit field that specifies whether this message is a query (0), or a response (1). @type answer: L{int} @param opCode: A four bit field that specifies kind of query in this message. This value is set by the originator of a query and copied into the response. @type opCode: L{int} @param recDes: Recursion Desired - this bit may be set in a query and is copied into the response. If RD is set, it directs the name server to pursue the query recursively. Recursive query support is optional. @type recDes: L{int} @param recAv: Recursion Available - this bit is set or cleared in a response and denotes whether recursive query support is available in the name server. @type recAv: L{int} @param auth: Authoritative Answer - this bit is valid in responses and specifies that the responding name server is an authority for the domain name in question section. @type auth: L{int} @ivar rCode: A response code, used to indicate success or failure in a message which is a response from a server to a client request. @type rCode: C{0 <= int < 16} @param trunc: A flag indicating that this message was truncated due to length greater than that permitted on the transmission channel. @type trunc: L{int} @param maxSize: The requestor's UDP payload size is the number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type maxSize: L{int} @param authenticData: A flag indicating in a response that all the data included in the answer and authority portion of the response has been authenticated by the server according to the policies of that server. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{int} @param checkingDisabled: A flag indicating in a query that pending (non-authenticated) data is acceptable to the resolver sending the query. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{int} N)r� r� r� r� rA r� r� r� r� r� r� r� r� r� r� ) r� r� r� r� r� r� rA r� r� r� r� r� r{ r{ r| r� � s J zMessage.__init__r� c C � t | ddddd�S )z� Generate a repr of this L{Message}. Only includes the non-default fields and sections and only includes flags which are set. The C{id} is always shown. @return: The native string repr. )r� rA r� r� r� r� r� )r� r� r� r� �r� r� r� r� �r� �r� r� r� r� �r� r� r{ r{ r| r s �zMessage.__repr__c C s | j �t|||�� dS )z� Add another query to this Message. @type name: L{bytes} @param name: The name to query. @type type: L{int} @param type: Query type @type cls: L{int} @param cls: Query class N)r� r� rh r r{ r{ r| �addQuery' s zMessage.addQueryc C sh i }t � }| jD ]}|�||� q| jD ]}|�||� q| jD ]}|�||� q | jD ]}|�||� q,|�� }t|�| j }| j rU|| j krUd| _ |d | j | j � }| j d@ d> | j d@ d> B | j d@ d> B | j d@ d> B | jd@ B }| jd@ d> | jd@ d> B | jd@ d> B | jd@ B }|�t�| j| j||t| j�t| j�t| j�t| j��� |�|� d S )Nr~ � r' r� r� r� r� )r r� r� r� r� r� r* r� r� r� r� r� r� rA r� r� r� r� r� r� r� r� � headerFmtr� ) r� r� r� �body_tmp�q�body�size�byte3�byte4r{ r{ r| r� 6 s\ � � ��� � ����� zMessage.encodec C s2 d| _ t|| j�}t�| j|�}|\| _}}}}} } |d? d@ | _|d? d@ | _|d? d@ | _ |d? d@ | _ |d@ | _ |d? d@ | _ |d? d@ | _ |d? d@ | _|d@ | _g | _t|�D ] } t� } z| �|� W n tys Y d S w | j�| � q\| j|f| j| f| j| ff} | D ] \}}| �|||� q�d S ) Nr r� r~ r� r' r� r� r� )r� r� r� r� r� r� r� r� r� rA r� r� r� r� r� r� r� �rangerh r� r� r� r� r� r� � parseRecords)r� r� r� �headerrG r� r �nqueries�nans�nns�nadd�ir� �itemsr� r r{ r{ r| r� b s4 � �zMessage.decodec C s� t |�D ]F}t| jd�}z|�|� W n ty Y d S w | �|j�}|s(q||jd�|_z |j�||j � W n tyD Y d S w |� |� qd S )NrH )r( ) r ri rA r� r� �lookupRecordTyper� r( r) r- r� )r� r� �numr� r r r r{ r{ r| r s$ � � �zMessage.parseRecords�Record_c C s | j �|t�S )aC Retrieve the L{IRecord} implementation for the given record type. @param type: A record type, such as C{A} or L{NS}. @type type: L{int} @return: An object which implements L{IRecord} or L{None} if none can be found for the given type. @rtype: C{Type[IRecord]} )� _recordTypesr r_ )r� r� r{ r{ r| r � s zMessage.lookupRecordTypec C s t � }| �|� |�� S )z� Encode this L{Message} into a byte string in the format described by RFC 1035. @rtype: L{bytes} )r r� r* )r� r� r{ r{ r| �toStr� s z Message.toStrc C s t |�}| �|� dS )z� Decode a byte string in the format described by RFC 1035 into this L{Message}. @param str: L{bytes} N)r r� )r� r� r� r{ r{ r| �fromStr� s zMessage.fromStrr� ) r� r� r� r� r/ r� r� r@ r� r� r� r �nsrn r� r� r r9 r8 r� r� r� r r �globalsr� � startswithr� r r r r{ r{ r{ r| rf r s@ ( �[ , � rf c @ sv e Zd ZdZdZeZddeddddddddddddddfdd�Zd e fd d �Z d d � Z dd� Z e dd� �Zdd� ZdS )� _EDNSMessagea� An I{EDNS} message. Designed for compatibility with L{Message} but with a narrower public interface. Most importantly, L{_EDNSMessage.fromStr} will interpret and remove I{OPT} records that are present in the additional records section. The I{OPT} records are used to populate certain I{EDNS} specific attributes. L{_EDNSMessage.toStr} will add suitable I{OPT} records to the additional section to represent the extended EDNS information. @see: U{https://tools.ietf.org/html/rfc6891} @ivar id: See L{__init__} @ivar answer: See L{__init__} @ivar opCode: See L{__init__} @ivar auth: See L{__init__} @ivar trunc: See L{__init__} @ivar recDes: See L{__init__} @ivar recAv: See L{__init__} @ivar rCode: See L{__init__} @ivar ednsVersion: See L{__init__} @ivar dnssecOK: See L{__init__} @ivar authenticData: See L{__init__} @ivar checkingDisabled: See L{__init__} @ivar maxSize: See L{__init__} @ivar queries: See L{__init__} @ivar answers: See L{__init__} @ivar authority: See L{__init__} @ivar additional: See L{__init__} @ivar _messageFactory: A constructor of L{Message} instances. Called by C{_toMessage} and C{_fromMessage}. �r� r� r� rA r� r� r� r� � ednsVersionr" r� r� r� r� r� r� r� r Fr� Nc C s� || _ || _|| _|| _|| _|| _|| _|| _| | _| | _ | | _ | | _ | | _ |du r-g }|| _ |du r6g }|| _|du r?g }|| _|du rHg }|| _dS )a+ Construct a new L{_EDNSMessage} @see: U{RFC1035 section-4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>} @see: U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>} @see: U{RFC3225 section-3<https://tools.ietf.org/html/rfc3225#section-3>} @see: U{RFC6891 section-6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>} @param id: A 16 bit identifier assigned by the program that generates any kind of query. This identifier is copied the corresponding reply and can be used by the requester to match up replies to outstanding queries. @type id: L{int} @param answer: A one bit field that specifies whether this message is a query (0), or a response (1). @type answer: L{bool} @param opCode: A four bit field that specifies kind of query in this message. This value is set by the originator of a query and copied into the response. @type opCode: L{int} @param auth: Authoritative Answer - this bit is valid in responses, and specifies that the responding name server is an authority for the domain name in question section. @type auth: L{bool} @param trunc: Truncation - specifies that this message was truncated due to length greater than that permitted on the transmission channel. @type trunc: L{bool} @param recDes: Recursion Desired - this bit may be set in a query and is copied into the response. If set, it directs the name server to pursue the query recursively. Recursive query support is optional. @type recDes: L{bool} @param recAv: Recursion Available - this bit is set or cleared in a response, and denotes whether recursive query support is available in the name server. @type recAv: L{bool} @param rCode: Extended 12-bit RCODE. Derived from the 4 bits defined in U{RFC1035 4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>} and the upper 8bits defined in U{RFC6891 6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>}. @type rCode: L{int} @param ednsVersion: Indicates the EDNS implementation level. Set to L{None} to prevent any EDNS attributes and options being added to the encoded byte string. @type ednsVersion: L{int} or L{None} @param dnssecOK: DNSSEC OK bit as defined by U{RFC3225 3<https://tools.ietf.org/html/rfc3225#section-3>}. @type dnssecOK: L{bool} @param authenticData: A flag indicating in a response that all the data included in the answer and authority portion of the response has been authenticated by the server according to the policies of that server. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{bool} @param checkingDisabled: A flag indicating in a query that pending (non-authenticated) data is acceptable to the resolver sending the query. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{bool} @param maxSize: The requestor's UDP payload size is the number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type maxSize: L{int} @param queries: The L{list} of L{Query} associated with this message. @type queries: L{list} of L{Query} @param answers: The L{list} of answers associated with this message. @type answers: L{list} of L{RRHeader} @param authority: The L{list} of authority records associated with this message. @type authority: L{list} of L{RRHeader} @param additional: The L{list} of additional records associated with this message. @type additional: L{list} of L{RRHeader} Nr )r� r� r� r� rA r� r� r� r� r r" r� r� r� r� r� r� r� r{ r{ r| r� � s2 m z_EDNSMessage.__init__r� c C r� )N)r� rA r� r� r� r� r� r" )r� r� r� r� r r� r� r� r� r� r{ r{ r| r � s �z_EDNSMessage.__repr__c C s� | j | j| j| j| j| j| j| j| jd@ | j | j d� }| j dd� |_ | j dd� |_ | j dd� |_ | jdd� |_| jdurTt| j| j| j| jd? d�}|j�|� |S )a= Convert to a standard L{dns.Message}. If C{ednsVersion} is not None, an L{_OPTHeader} instance containing all the I{EDNS} specific attributes and options will be appended to the list of C{additional} records. @return: A L{dns.Message} @rtype: L{dns.Message} r' ) r� r� r� rA r� r� r� r� r� r� Nr� )r! r" r r )�_messageFactoryr� r� r� rA r� r� r� r� r� r� r� r� r� r� r r r" r� r� )r� �mr+ r{ r{ r| � _toMessage� s2 � � z_EDNSMessage._toMessagec C s | � � �� S )z~ Encode to wire format by first converting to a standard L{dns.Message}. @return: A L{bytes} string. )r r r� r{ r{ r| r � s z_EDNSMessage.toStrc C s g }g }|j D ]}|jtkr|�t�|�� q|�|� q| di d|j�d|j�d|j�d|j �d|j �d|j �d|j �d|j �d |j�d |j�d d �d d�d|jd d � �d|jd d � �d|jd d � �d|��}t|�dkr�|d }|j|_|j|_|j|_|jd> |j B |_ |S )a� Construct and return a new L{_EDNSMessage} whose attributes and records are derived from the attributes and records of C{message} (a L{Message} instance). If present, an C{OPT} record will be extracted from the C{additional} section and its attributes and options will be used to set the EDNS specific attributes C{extendedRCODE}, C{ednsVersion}, C{dnssecOK}, C{ednsOptions}. The C{extendedRCODE} will be combined with C{message.rCode} and assigned to C{self.rCode}. @param message: The source L{Message}. @type message: L{Message} @return: A new L{_EDNSMessage} @rtype: L{_EDNSMessage} r� r� r� rA r� r� r� r� r� r� r Nr" Fr� r� r� r� r~ r r� r{ )r� r� r* r� r r. r� r� r� rA r� r� r� r� r� r� r� r� r� r� r! r r" r r� r )r r� r� � optRecordsrG � newMessage�optr{ r{ r| � _fromMessage� s\ �������� � � ������ z_EDNSMessage._fromMessagec C s> | � � }|�|� | �|�}| jD ] }t| |t||�� qdS )z� Decode from wire format, saving flags, values and records to this L{_EDNSMessage} instance in place. @param bytes: The full byte string to be decoded. @type bytes: L{bytes} N)r r r r/ r0 r1 )r� ry r � ednsMessager4 r{ r{ r| r s �z_EDNSMessage.fromStr)r� r� r� r� r/ rf r rq r� r� r r r r< r r r{ r{ r{ r| r � s: ' � * <r c @ sB e Zd ZdZdZdZd dd�Zdd� Zdd� Zd d � Z d d � Z dS )rl z� DNS protocol mixin shared by UDP and TCP implementations. @ivar _reactor: A L{IReactorTime} and L{IReactorUDP} provider which will be used to issue DNS queries and manage request timeouts. Nc C s2 || _ t�dd�| _|d u rddlm} || _d S )Ni i � r )�reactor)� controller�random� randranger� �twisted.internetr �_reactor)r� r r r{ r{ r| r� % s zDNSMixin.__init__c C s t � }|| jvr |S q)z1 Return a unique ID for queries. )r� � liveMessages�r� r� r{ r{ r| �pickID, s �zDNSMixin.pickIDc G s | j j||g|�R � S )zL Wrapper around reactor.callLater, mainly for test purpose. )r# � callLater)r� �period�func�argsr{ r{ r| r' 5 s zDNSMixin.callLaterc C sf t |dd�}||_z||� W n ty t�� Y S w t�� }| �|| j||�}||f| j|< |S )a� Send out a message with the given queries. @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @type timeout: L{int} or C{float} @param timeout: How long to wait before giving up @type id: L{int} @param id: Unique key for this request @type writeMessage: C{callable} @param writeMessage: One-parameter callback which writes the message @rtype: C{Deferred} @return: a C{Deferred} which will be fired with the result of the query, or errbacked with any errors that could happen (exceptions during writing of the query, timeout errors, ...). r~ )r� ) rf r� � BaseExceptionr �fail�Deferredr' � _clearFailedr$ )r� r� �timeoutr� � writeMessager �resultDeferred� cancelCallr{ r{ r| �_query; s �zDNSMixin._queryc C s8 z| j |= W n ty Y nw |�t�t|��� dS )z5 Clean the Deferred after a timeout. N)r$ �KeyError�errbackr �Failurerv )r� �deferredr� r{ r{ r| r. ^ s �zDNSMixin._clearFailedr� ) r� r� r� r� r� r$ r� r& r' r3 r. r{ r{ r{ r| rl s #rl c @ sN e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z ddd�Z dS )rk z DNS protocol over UDP. Nc C s i | _ i | _d| _dS )z7 Stop protocol: reset state variables. N)r$ �resends� transportr� r{ r{ r| � stopProtocolp s z DNSDatagramProtocol.stopProtocolc C s i | _ i | _dS )z3 Upon start, reset internal state. N)r$ r8 r� r{ r{ r| � startProtocolx s z!DNSDatagramProtocol.startProtocolc C s | j �|�� |� dS )�X Send a message holding DNS queries. @type message: L{Message} N)r9 r� r )r� r� rX r{ r{ r| r0 s z DNSDatagramProtocol.writeMessagec C s | j jd| dd� d S )Nr r� )� maxPacketSize)r# � listenUDPr� r{ r{ r| �startListening� s z"DNSDatagramProtocol.startListeningc C s� t � }z|�|� W n& ty t�dt|�|f � Y dS ty0 t�t� � d� Y dS w |j | j v r_| j |j \}}| j |j = |� � z|� |� W dS ty^ t�� Y dS w |j | jvro| j�|| |� dS dS )zi Read a datagram, extract the message in it and trigger the associated Deferred. z#Truncated packet (%d bytes) from %sNzUnexpected decoding error)rf r r� r r� r� r+ �errr r6 r� r$ �cancel�callbackr8 r �messageReceived)r� r5 �addrr r� � cancellerr{ r{ r| �datagramReceived� s, � � �z$DNSDatagramProtocol.datagramReceivedc C s$ z| j |= W dS ty Y dS w )zN Mark message ID as no longer having duplication suppression. N)r8 r4 r% r{ r{ r| � removeResend� s �z DNSDatagramProtocol.removeResendr� c sh �j sz��� W n ty t�� Y S w |du r ��� }nd�j|< � �fdd�}��||||�S )a4 Send out a message with the given queries. @type address: L{tuple} of L{str} and L{int} @param address: The address to which to send the query @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @rtype: C{Deferred} Nr~ c s �� | � � d S r� )r0 )r �rX r� r{ r| r0 � r` z/DNSDatagramProtocol.query.<locals>.writeMessage)r9 r? r r r, r& r8 r3 )r� rX r� r/ r� r0 r{ rH r| �query� s � zDNSDatagramProtocol.query)r� N) r� r� r� r� r8 r: r; r0 r? rF rG rI r{ r{ r{ r| rk i s rk c @ sB e Zd ZdZdZdZdd� Zdd� Zdd � Zd d � Z dd d�Z dS )rm z DNS protocol over TCP. Nr� c C s( |� � }| j�t�dt|��| � dS )r< r� N)r r9 r� r� r� r� )r� r� r� r{ r{ r| r0 � s zDNSProtocol.writeMessagec C s i | _ | j�| � dS )zV Connection is made: reset internal state, and notify the controller. N)r$ r �connectionMader� r{ r{ r| rJ � s zDNSProtocol.connectionMadec C s | j �| � dS )zZ Notify the controller that this protocol is no longer connected. N)r �connectionLost)r� �reasonr{ r{ r| rK � r� zDNSProtocol.connectionLostc C s& | j |7 _ | j r�| jd u r,t| j �dkr,t�d| j d d� �d | _| j dd � | _ t| j �| jkr�| j d | j� }t� }|�|� z | j|j \}}W n t y^ | j � || � Y n w | j|j= |� � z|� |� W n ty| t�� Y nw | j | jd � | _ d | _nd S | j s d S d S )Nr� r� r )�bufferr� r� r� r� rf r r$ r� r4 r rC rA rB r+ r r@ )r� r5 �myChunkr r� rE r{ r{ r| � dataReceived� s2 � ��zDNSProtocol.dataReceivedr� c C s | � � }| �|||| j�S )z� Send out a message with the given queries. @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @rtype: C{Deferred} )r& r3 r0 )r� r� r/ r� r{ r{ r| rI s zDNSProtocol.query)r� ) r� r� r� r� r� rM r0 rJ rK rO rI r{ r{ r{ r| rm � s rm )NNNN)�r� r� r r[ r� �ior � itertoolsr �typingr r r �zope.interfacer r r r" r r �twisted.internet.errorr �twisted.pythonr r r r �tputil�twisted.python.compatr r r �__all__r r} r� r� r� rt r r r( r! r" r r- r r# r% r) r3 r+ r r$ r& r0 r, r r r/ r' r r r* r1 r. r� r2 ra r; r: r r r9 rd r rc r8 r6 r5 r7 r4 r` rb rq ro rr rp rs rn r< r@ r= r> r? rA rB rC rD r �twisted.names.errorru rv rw r� r� r� r� r� r r re rg rh � FancyStrMixin� FancyEqMixinr r6 ri rj rT rM rN rI rL rO rQ rV rJ rE rX rU r^ rG rF rZ rS rH rW rK rP rR r[ r] r_ rY r\ r� r� r� rf r rl �DatagramProtocolrk �Protocolrm r{ r{ r{ r| �<module> s� h ��������� � � � � ������ � ! ('1f< ;<z& 1s <.]Cz130;-?+,^ �4 P \OhPK y�Z��>�+ + ! __pycache__/cache.cpython-310.pycnu �[��� o �b� � @ sF d Z ddlmZ ddlmZmZ ddlmZmZ G dd� dej �Z dS )z An in-memory caching resolver. � )�defer)�common�dns)�failure�logc @ sR e Zd ZdZdZddd�Zdd� Zdd � Zd d � Zdd d �Z ddd�Z dd� Z dS )� CacheResolverz� A resolver that serves records from a local, memory cache. @ivar _reactor: A provider of L{interfaces.IReactorTime}. Nr c C sh t j�| � i | _|| _i | _|d u rddlm} || _|r0|� � D ]\}\}}| � |||� q"d S d S )Nr )�reactor) r � ResolverBase�__init__�cache�verbose�cancel�twisted.internetr �_reactor�items� cacheResult)�selfr r r �query�seconds�payload� r �5/usr/lib/python3/dist-packages/twisted/names/cache.pyr s �zCacheResolver.__init__c C sb || _ | j�� }| j�� D ]!\}\}\}}}|| }|| | D ] } | j|k r-| j|= nq q d S �N)�__dict__r r r r �ttl) r �state�now�k�when�ans�add�ns�diff�recr r r � __setstate__& s ���zCacheResolver.__setstate__c C s( | j �� D ]}|� � q| j �� | jS r )r �values�clearr )r �cr r r � __getstate__1 s zCacheResolver.__getstate__c s | j �� }t�|||�}z | j| \}\}} } W n" ty: | jdkr-t�dt |� � t � t � t�|��� Y S w | jrGt�dt |� � || � z � fdd�|D �� fdd�| D �� fdd�| D �f} W n ty{ t � t � t�|��� Y S w t �| �S )N� zCache miss for zCache hit for c �. g | ]}t �|jj|j|j|j� |j��qS r �r �RRHeader�name�type�clsr r ��.0�r�r" r r � <listcomp>G � ���z)CacheResolver._lookup.<locals>.<listcomp>c r* r r+ r0 r3 r r r4 M r5 c r* r r+ r0 r3 r r r4 S r5 )r r r �Queryr �KeyErrorr r �msg�reprr �failr �Failure� DomainError� ValueError�succeed) r r- r/ r. �timeoutr �qr r �authr �resultr r3 r �_lookup7 s6 � � � �� � zCacheResolver._lookupc C s t �t�t�|���S r )r r: r r; r r< )r r- r? r r r �lookupAllRecords_ s z CacheResolver.lookupAllRecordsc C s� | j dkr t�d| � |p| j�� |f| j|< || jv r$| j| �� t|d �t|d � t|d � }|rI|d j}|D ]}t ||j�}q?nd}| j� || j |�| j|< dS )a� Cache a DNS entry. @param query: a L{dns.Query} instance. @param payload: a 3-tuple of lists of L{dns.RRHeader} records, the matching result of the query (answers, authority and additional). @param cacheTime: The time (seconds since epoch) at which the entry is considered to have been added to the cache. If L{None} is given, the current time is used. r) zAdding %r to cacher � N) r r r8 r r r r �listr �min� callLater� clearEntry)r r r � cacheTime�s�mr2 r r r r b s $ � zCacheResolver.cacheResultc C s | j |= | j|= d S r )r r )r r r r r rI � s zCacheResolver.clearEntry)Nr Nr ) �__name__� __module__� __qualname__�__doc__r r r$ r( rC rD r rI r r r r r s ( r N) rP r r � twisted.namesr r �twisted.pythonr r r r r r r r �<module> s PK y�Z��g�! �! & __pycache__/srvconnect.cpython-310.pycnu �[��� o �b�# � @ sv d dl Z d dlmZ d dlmZmZ d dlmZmZ d dl m Z d dl m Z G dd� d�Z eej�G d d � d ��ZdS ) � N)� implementer)�error� interfaces)�client�dns)� DNSNameError)� nativeStringc @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �"_SRVConnector_ClientFactoryWrapperc C s || _ || _d S �N)�-_SRVConnector_ClientFactoryWrapper__connector�2_SRVConnector_ClientFactoryWrapper__wrappedFactory)�self� connector�wrappedFactory� r �:/usr/lib/python3/dist-packages/twisted/names/srvconnect.py�__init__ s z+_SRVConnector_ClientFactoryWrapper.__init__c C s | j �| j� d S r )r �startedConnectingr )r r r r r r s z4_SRVConnector_ClientFactoryWrapper.startedConnectingc C � | j �|� d S r )r �connectionFailed�r r �reasonr r r �clientConnectionFailed � z9_SRVConnector_ClientFactoryWrapper.clientConnectionFailedc C r r )r �connectionLostr r r r �clientConnectionLost r z7_SRVConnector_ClientFactoryWrapper.clientConnectionLostc C s t | j|�S r )�getattrr )r �keyr r r � __getattr__ s z._SRVConnector_ClientFactoryWrapper.__getattr__N)�__name__� __module__� __qualname__r r r r r r r r r r s r c @ s� e Zd ZdZdZdddi dfdd�Zd d � Zd d � Zd d� Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd � Zd d � ZdS ) � SRVConnectoraD A connector that looks up DNS SRV records. RFC 2782 details how SRV records should be interpreted and selected for subsequent connection attempts. The algorithm for using the records' priority and weight is implemented in L{pickServer}. @ivar servers: List of candidate server records for future connection attempts. @type servers: L{list} of L{dns.Record_SRV} @ivar orderedServers: List of server records that have already been tried in this round of connection attempts. @type orderedServers: L{list} of L{dns.Record_SRV} r �tcp� connectTCPr Nc C s^ || _ || _|du r dnt�|�| _|| _|| _|| _|| _|| _ | | _ d| _ d| _ d| _ dS )a� @param domain: The domain to connect to. If passed as a text string, it will be encoded using C{idna} encoding. @type domain: L{bytes} or L{str} @param defaultPort: Optional default port number to be used when SRV lookup fails and the service name is unknown. This should be the port number associated with the service name as defined by the IANA registry. @type defaultPort: L{int} N)�reactor�servicer � domainString�domain�factory�protocol�connectFuncName�connectFuncArgs�connectFuncKwArgs� _defaultPortr �servers�orderedServers) r r% r& r( r) r* r+ r, r- � defaultPortr r r r 6 s zSRVConnector.__init__c C s� | j �� | j �| � | jsR| jdu r | �t�d�� dS t� dt | j �t | j �t | j�f �}|� | j| j� |�| fdd�� | jrJ|�| j� |�| j� dS | jdu r]| �� dS | j�� dS )z"Start connection to remote server.NzDomain is not defined.z _%s._%s.%sc S s |� � S r )�_reallyConnect)�xr r r r �<lambda>q s z&SRVConnector.connect.<locals>.<lambda>)r) �doStartr r/ r( r r �DNSLookupErrorr � lookupServicer r& r* � addCallbacks� _cbGotServers� _ebGotServers� addCallbackr. � addErrback�_ebServiceUnknownr r2 �connect)r �dr r r r> ] s0 ���� zSRVConnector.connectc C s |� t� g | _g | _d S r )�trapr r/ r0 �r �failurer r r r: z s zSRVConnector._ebGotServersc C s� |\}}}t |�dkr2|d jtjkr2|d jr2|d jjt�d�kr2t�dt | j �t | j �f ��g | _ g | _ |D ]}|jtjksE|jsFq:| j �|j� q:d S )N� r � .z'Service %s not available for domain %s.)�len�typer �SRV�payload�target�Namer r6 �reprr& r( r/ r0 �append)r �result�answers�auth�add�ar r r r9 � s$ ����zSRVConnector._cbGotServersc C s6 |� tj� t�dd| j| j�g| _g | _| � � dS )a. Connect to the default port when the service name is unknown. If no SRV records were found, the service name will be passed as the port. If resolving the name fails with L{error.ServiceNameUnknownError}, a final attempt is done using the default port. r N) r@ r �ServiceNameUnknownErrorr � Record_SRVr. r( r/ r0 r> rA r r r r= � s z SRVConnector._ebServiceUnknownc C s$ | j dusJ �| jdusJ �| j s | js t| j�| jfS | j s)| jr)| j| _ g | _| j s.J �| j jdd� d� | j d j}d}d}g }| j D ]}|j|kr]||j7 }|�||f� |d7 }qFt � d|�}|D ]!\}}||kr�| j | }| j |= | j�|� t |j �|j f S qftd| jj� d���) a; Pick the next server. This selects the next server from the list of SRV records according to their priority and weight values, as set out by the default algorithm specified in RFC 2782. At the beginning of a round, L{servers} is populated with L{orderedServers}, and the latter is made empty. L{servers} is the list of candidates, and L{orderedServers} is the list of servers that have already been tried. First, all records are ordered by priority and weight in ascending order. Then for each priority level, a running sum is calculated over the sorted list of records for that priority. Then a random value between 0 and the final sum is compared to each record in order. The first record that is greater than or equal to that random value is chosen and removed from the list of candidates for this round. @return: A tuple of target hostname and port from the chosen DNS SRV record. @rtype: L{tuple} of native L{str} and L{int} Nc S s | j | jfS r )�priority�weight)�recordr r r r4 � s z)SRVConnector.pickServer.<locals>.<lambda>)r r rC z Impossible z pickServer result.)r/ r0 r r( r& �sortrT rU rL �random�randint�strrI �port� RuntimeError� __class__r ) r � minPriority�index� weightSum� weightIndexr3 �randrU �chosenr r r � pickServer� s8 � �zSRVConnector.pickServerc C s� | j rd| _ d S | �� \| _| _| jd usJ d��| jd us"J d��t| j| j�}|| j| jt| | j�g| j �R i | j ��| _ d S )Nr z Must have a host to connect to.z Must have a port to connect to.) � stopAfterDNSrd �hostr[ r r% r+ r r) r, r- r )r � connectFuncr r r r2 � s �� �zSRVConnector._reallyConnectc C s | j r | j �� dS d| _dS )zStop attempting to connect.rC N)r �stopConnectingre �r r r r rh � s zSRVConnector.stopConnectingc C s$ | j dur | j �� dS | �� dS )z%Disconnect whatever our are state is.N)r � disconnectrh ri r r r rj � s zSRVConnector.disconnectc C s | j sJ �| j �� S r )r �getDestinationri r r r rk s zSRVConnector.getDestinationc C � | j �| |� | j �� d S r )r) r �doStop�r r r r r r � z SRVConnector.connectionFailedc C rl r )r) r rm rn r r r r ro zSRVConnector.connectionLost)r r r! �__doc__re r r> r: r9 r= rd r2 rh rj rk r r r r r r r" " s( �' = r" )rX �zope.interfacer �twisted.internetr r � twisted.namesr r �twisted.names.errorr �twisted.python.compatr r � IConnectorr" r r r r �<module> s PK y�Z{T;�. �. __pycache__/root.cpython-310.pycnu �[��� o �b�0 � @ st d Z ddlmZ ddlmZmZmZ ddlmZ G dd� d�Z G dd� dej �Z d d � Z G d d � d �Z ddd�Zd S )z� Resolver implementation for querying successive authoritative servers to lookup a record, starting from the root nameservers. @author: Jp Calderone todo:: robustify it documentation � )�defer)�common�dns�error)�Failurec @ s e Zd ZdZdd� ZdS )�_DummyControllerz� A do-nothing DNS controller. This is useful when all messages received will be responses to previously issued queries. Anything else received will be ignored. c G s d S �N� )�self�argsr r �4/usr/lib/python3/dist-packages/twisted/names/root.py�messageReceived s z _DummyController.messageReceivedN)�__name__� __module__� __qualname__�__doc__r r r r r r s r c @ sB e Zd ZdZddd�Zdd� Zdd � Zd d � Zd d � Zdd� Z dS )�Resolverao L{Resolver} implements recursive lookup starting from a specified list of root servers. @ivar hints: See C{hints} parameter of L{__init__} @ivar _maximumQueries: See C{maximumQueries} parameter of L{__init__} @ivar _reactor: See C{reactor} parameter of L{__init__} @ivar _resolverFactory: See C{resolverFactory} parameter of L{__init__} � Nc C s< t j�| � || _|| _|| _|du rddlm} || _dS )a� @param hints: A L{list} of L{str} giving the dotted quad representation of IP addresses of root servers at which to begin resolving names. @type hints: L{list} of L{str} @param maximumQueries: An optional L{int} giving the maximum number of queries which will be attempted to resolve a single name. @type maximumQueries: L{int} @param reactor: An optional L{IReactorTime} and L{IReactorUDP} provider to use to bind UDP ports and manage timeouts. @type reactor: L{IReactorTime} and L{IReactorUDP} provider @param resolverFactory: An optional callable which accepts C{reactor} and C{servers} arguments and returns an instance that provides a C{queryUDP} method. Defaults to L{twisted.names.client.Resolver}. @type resolverFactory: callable Nr �r ) r � ResolverBase�__init__�hints�_maximumQueries�_reactor�twisted.names.clientr �_resolverFactory)r r �maximumQueries�reactor�resolverFactoryr r r r + s zResolver.__init__c C s dd� | j D �S )z� Return a list of two-tuples representing the addresses of the root servers, as defined by C{self.hints}. c S s g | ]}|t jf�qS r )r �PORT)�.0�ipr r r � <listcomp>M s z#Resolver._roots.<locals>.<listcomp>)r )r r r r �_rootsH s zResolver._rootsc C s2 | j || jd�}|�|g|�}|r|�|j� |S )a� Issue one query and return a L{Deferred} which fires with its response. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A timeout on how long to wait for the response. @type timeout: L{tuple} of L{int} @param filter: A flag indicating whether to filter the results. If C{True}, the returned L{Deferred} will fire with a three-tuple of lists of L{twisted.names.dns.RRHeader} (like the return value of the I{lookup*} methods of L{IResolver}. IF C{False}, the result will be a L{Message} instance. @type filter: L{bool} @return: A L{Deferred} which fires with the response or a timeout error. @rtype: L{Deferred} )�serversr )r r �queryUDP� addCallback� filterAnswers)r �queryr$ �timeout�filter�r�dr r r �_queryO s zResolver._queryc C s, |du rd}| � t�|||�| �� || j�S )z� Implement name lookup by recursively discovering the authoritative server for the name and then asking it, starting at one of the servers in C{self.hints}. N)� � � �- )�_discoverAuthorityr �Queryr# r )r �name�cls�typer) r r r �_lookupn s �zResolver._lookupc C s@ |dkr t t�d��S | �|||d�}|�| j|||d � |S )a# Issue a query to a server and follow a delegation if necessary. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A C{tuple} of C{int} giving the timeout to use for this query. @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response, or with a L{Failure} if there is a timeout or response error. r z"Query limit reached without resultFr. )r r � ResolverErrorr- r& �_discoveredAuthority)r r( r$ r) � queriesLeftr, r r r r2 | s zResolver._discoverAuthorityc s� |j tjkrt��|j �|��S i �|jD ] }��|jg ��|� q�fdd�}t � }�j}d} |� |� | � ||�j �j �} | du rj|�jkrJn>�� t�t|��j �j ���� ���} � fdd�} | �| � | S | j �j krx|j|j|jfS | jj|v r�t�d��| jj}q1i } |jD ]} | j tjkr�| j�� | | jj< q�g }g }|jD ]!} | j tjkr�| jjj}|| v r�|�| | tjf� q�|�|� q�|r҈� �|���S |r��|d ��} d d � }| �|� | �����fd d �� | S tt�d ��S )as Interpret the response to a query, checking for error codes and following delegations if necessary. @param response: The L{Message} received in response to issuing C{query}. @type response: L{Message} @param query: The L{dns.Query} which was issued. @type query: L{dns.Query}. @param timeout: The timeout to use if another query is indicated by this response. @type timeout: L{tuple} of L{int} @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Failure} indicating a response error, a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response to C{query} or a L{Deferred} which will fire with one of those. c sF d }� � | g �D ]}|j|kr |j|kr| S |jtjkr |}q|S r )�getr5 r6 r �CNAME)r4 r6 r5 �cname�record)�recordsr r �findAnswerOrCName� s �z8Resolver._discoveredAuthority.<locals>.findAnswerOrCNameNTc s | \}}}|� d� � |||fS �Nr )�insert��results�answers� authority� additional)�previousr r � cbResolved� s z1Resolver._discoveredAuthority.<locals>.cbResolvedzCycle in CNAME processingr c S s | \}}}|d j �� S rA )�payload� dottedQuadrC r r r � getOneAddress s z4Resolver._discoveredAuthority.<locals>.getOneAddressc s �� �| tjfg�� d �S )Nr. )r2 r r )�hint)r: r( r r) r r �<lambda> s �z/Resolver._discoveredAuthority.<locals>.<lambda>z/Stuck at response without answers or delegation) �rCoder �OKr �exceptionForCoderE � setdefaultr4 �append�set�addr6 r5 r2 r3 �strr# r& rF rG rJ r r8 �ArK �NSr � lookupAddress)r �responser( r) r: �answerr@ �seenr4 r> r, rI � addresses�rrr �traps�nsrL r )rH r: r( r? r r) r r9 � st � �% � � ��z Resolver._discoveredAuthority)r NN) r r r r r r# r- r7 r2 r9 r r r r r s r c s � �fdd�}|S )Nc s �� � ��fdd�� �S )Nc s t | ��� i ���S r )�getattr)r+ )r �kwr4 r r rN s z6makePlaceholder.<locals>.placeholder.<locals>.<lambda>)r& �r rb ��deferredr4 rc r � placeholder s z$makePlaceholder.<locals>.placeholderr )re r4 rf r rd r �makePlaceholder s rg c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�DeferredResolverc C s g | _ |�| j� d S r )�waitingr& �gotRealResolver)r �resolverDeferredr r r r s zDeferredResolver.__init__c C s. | j }|j| _|j| _|D ]}|�|� q d S r )ri �__dict__� __class__�callback)r �resolver�wr, r r r rj s �z DeferredResolver.gotRealResolverc C s: |� d�s |dv r| j�t�� � t| jd |�S t|��)N�lookup)� getHostByNamer( ���)� startswithri rS r �Deferredrg �AttributeError)r r4 r r r � __getattr__% s z DeferredResolver.__getattr__N)r r r r rj rw r r r r rh s rh Nc sP dd� t d�D �}� fdd�|D �}tj|dd�}�fdd�}|�|� t|�S ) a� Lookup the root nameserver addresses using the given resolver Return a Resolver which will eventually become a C{root.Resolver} instance that has references to all the root servers that we were able to look up. @param resolver: The resolver instance which will be used to lookup the root nameserver addresses. @type resolver: L{twisted.internet.interfaces.IResolverSimple} @param resolverFactory: An optional callable which returns a resolver instance. It will passed as the C{resolverFactory} argument to L{Resolver.__init__}. @type resolverFactory: callable @return: A L{DeferredResolver} which will be dynamically replaced with L{Resolver} when the root nameservers have been looked up. c S s g | ] }t td �| ��qS )�a)�chr�ord)r �ir r r r" @ � z bootstrap.<locals>.<listcomp>� c s g | ] }� � d | ��qS )z%s.root-servers.net)rr )r r, )ro r r r" A s T)� consumeErrorsc s t dd� | D �� d�S )Nc S s g | ] }|d r|d �qS )r r. r )r �er r r r" F r| z4bootstrap.<locals>.buildResolver.<locals>.<listcomp>)r r r )�res)r r r � buildResolverD s �z bootstrap.<locals>.buildResolver)�ranger � DeferredListr& rh )ro r �domains�Lr, r� r )ro r r � bootstrap, s r� r )r �twisted.internetr � twisted.namesr r r �twisted.python.failurer r r r rg rh r� r r r r �<module> s rPK y�Z��S�� � ! __pycache__/error.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ G dd� de�ZG dd� de�ZG dd� de�ZG d d � d e�ZG d d � d e�ZG d d� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G dd� de �Zg d�ZdS )z0 Exception class definitions for Twisted Names. � )� TimeoutErrorc @ � e Zd ZdZdS )� DomainErrorzu Indicates a lookup failed because there were no records matching the given C{name, class, type} triple. N��__name__� __module__� __qualname__�__doc__� r r �5/usr/lib/python3/dist-packages/twisted/names/error.pyr � r c @ r )�AuthoritativeDomainErrorz� Indicates a lookup failed for a name for which this server is authoritative because there were no records matching the given C{name, class, type} triple. Nr r r r r r r r c @ s e Zd ZdZdd� ZdS )�DNSQueryTimeoutErrorzk Indicates a lookup failed due to a timeout. @ivar id: The id of the message which timed out. c C s t �| � || _d S )N)r �__init__�id)�selfr r r r r # s z DNSQueryTimeoutError.__init__N)r r r r r r r r r r s r c @ r )�DNSFormatErrorzQ Indicates a query failed with a result of C{twisted.names.dns.EFORMAT}. Nr r r r r r ( r r c @ r )�DNSServerErrorzQ Indicates a query failed with a result of C{twisted.names.dns.ESERVER}. Nr r r r r r . r r c @ r )� DNSNameErrorzO Indicates a query failed with a result of C{twisted.names.dns.ENAME}. Nr r r r r r 4 r r c @ r )�DNSNotImplementedErrorzQ Indicates a query failed with a result of C{twisted.names.dns.ENOTIMP}. Nr r r r r r : r r c @ r )�DNSQueryRefusedErrorzR Indicates a query failed with a result of C{twisted.names.dns.EREFUSED}. Nr r r r r r @ r r c @ r )�DNSUnknownErrorz: Indicates a query failed with an unknown result. Nr r r r r r F r r c @ r )� ResolverErrorz_ Indicates a query failed because of a decision made by the local resolver object. Nr r r r r r L r r ) r r r r r r r r r r N)r �twisted.internet.deferr � ValueErrorr r r r r r r r r � Exceptionr �__all__r r r r �<module> s PK y�ZDž7 7 # __pycache__/resolve.cpython-310.pycnu �[��� o �b� � @ sb d Z ddlmZ ddlmZmZ ddlmZmZm Z G dd� d�Z eej �G dd� dej ��Z d S ) z� Lookup a name using multiple resolvers. Future Plans: This needs someway to specify which resolver answered the query, or someway to specify (authority|ttl|cache behavior|more?) � )� implementer)�defer� interfaces)�common�dns�errorc @ s e Zd Zdd� Zdd� ZdS )�FailureHandlerc C s || _ || _|| _d S �N)�resolver�query�timeout)�selfr r r � r �7/usr/lib/python3/dist-packages/twisted/names/resolve.py�__init__ s zFailureHandler.__init__c C s" |� tjtjt� | �| j| j�S r ) �trapr � DomainErrorr � TimeoutError�NotImplementedErrorr r r )r �failurer r r �__call__ s zFailureHandler.__call__N)�__name__� __module__� __qualname__r r r r r r r s r c @ s* e Zd ZdZdd� Zdd� Zd dd�ZdS ) � ResolverChainz8 Lookup an address using multiple L{IResolver}s c C s t j�| � || _dS )zi @type resolvers: L{list} @param resolvers: A L{list} of L{IResolver} providers. N)r � ResolverBaser � resolvers)r r r r r r % s zResolverChain.__init__c C s` | j s t�t�� �S t�|||�}| j d �||�}| j dd� D ] }|�t |j||��}q!|S )aN Build a L{dns.Query} for the given parameters and dispatch it to each L{IResolver} in C{self.resolvers} until an answer or L{error.AuthoritativeDomainError} is returned. @type name: C{str} @param name: DNS name to resolve. @type type: C{int} @param type: DNS record type. @type cls: C{int} @param cls: DNS record class. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @rtype: L{Deferred} @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. r � N) r r �failr r r �Queryr � addErrbackr )r �name�cls�typer �q�d�rr r r �_lookup- s zResolverChain._lookupNc C sR | j s t�t�� �S | j d �||�}| j dd � D ] }|�t|j||��}q|S )Nr r )r r r r r �lookupAllRecordsr r )r r! r r% r& r r r r( Q s z ResolverChain.lookupAllRecordsr )r r r �__doc__r r' r( r r r r r s $r N)r) �zope.interfacer �twisted.internetr r � twisted.namesr r r r � IResolverr r r r r r �<module> s PK y�Z%�%�# �# " __pycache__/common.cpython-310.pycnu �[��� o �b�$ � @ sP d Z ddlZddlmZ ddlmZmZmZ ddlm Z ddl m Z ddl m Z mZmZmZmZmZ ed�\ZZZd Zeej�G d d � d ��Zd&d d�Zi e jd�e j d�e j d�e j d�e j d�e j d�e j!d�e j"d�e j#d�e j$d�e j%d�e j&d�e j'd�e j(d �e j)d �e j*d �e j+d �e j,d e j-d!e j.d"e j/d#e j0d$e j1d%i�Z2dS )'z> Base functionality useful to various parts of Twisted Names. � N)� implementer)�defer�error� interfaces)�Logger)�dns)�DNSFormatError� DNSNameError�DNSNotImplementedError�DNSQueryRefusedError�DNSServerError�DNSUnknownError� )� r r c @ sV e Zd ZdZe� Zejeej e ej e ej eejeiZdZdd� Zdd� Zd>dd�Zd d � Zd>d d �Zd>d d�Zd>dd�Zd>dd�Zd>dd�Zd>dd�Z d>dd�Z d>dd�Z d>dd �Z d>d d �Z d>d d �Z!d>d!d"�Z"d>d#d$�Z#d>d%d&�Z$d>d'd(�Z%d>d)d*�Z&d>d+d,�Z'd>d-d.�Z(d>d/d0�Z)d>d1d2�Z*d>d3d4�Z+d>d5d6�Z,d>d7d8�Z-d?d:d;�Z.d<d=� Z/dS )@� ResolverBaseaN L{ResolverBase} is a base class for implementations of L{interfaces.IResolver} which deals with a lot of the boilerplate of implementing all of the lookup methods. @cvar _errormap: A C{dict} mapping DNS protocol failure response codes to exception classes which will be used to represent those failures. Nc C s, i | _ t �� D ] \}}t| |�| j |< qd S �N)� typeToMethod�items�getattr)�self�k�vr r �6/usr/lib/python3/dist-packages/twisted/names/common.py�__init__7 s �zResolverBase.__init__c C s | j �|t�S )z� Convert a response code (one of the possible values of L{dns.Message.rCode} to an exception instance representing it. @since: 10.0 )� _errormap�getr )r � responseCoder r r �exceptionForCode< s z ResolverBase.exceptionForCodec C sb z| j |j }W n ty' | jjd|d� t�| j|jjt j |j|� Y S w t�||jj|�S )Nz:Query of unknown type {query.type} for {query.name.name!r})�query) r �type�KeyError�_log�debugr � maybeDeferred�_lookup�namer �IN)r r �timeout�methodr r r r E s ��� zResolverBase.queryc C s t �td��S )N�ResolverBase._lookup)r �fail�NotImplementedError)r r% �clsr r' r r r r$ S s r) c C � | � t�|�tjtj|�S r )r$ r � domainStringr& �A�r r% r' r r r � lookupAddressV � zResolverBase.lookupAddressc C r- r )r$ r r. r& �AAAAr0 r r r �lookupIPV6AddressY r2 z ResolverBase.lookupIPV6Addressc C r- r )r$ r r. r& �A6r0 r r r �lookupAddress6\ r2 zResolverBase.lookupAddress6c C r- r )r$ r r. r& �MXr0 r r r �lookupMailExchange_ r2 z ResolverBase.lookupMailExchangec C r- r )r$ r r. r& �NSr0 r r r �lookupNameserversb r2 z ResolverBase.lookupNameserversc C r- r )r$ r r. r& �CNAMEr0 r r r �lookupCanonicalNamee r2 z ResolverBase.lookupCanonicalNamec C r- r )r$ r r. r& �MBr0 r r r � lookupMailBoxh r2 zResolverBase.lookupMailBoxc C r- r )r$ r r. r& �MGr0 r r r �lookupMailGroupk r2 z ResolverBase.lookupMailGroupc C r- r )r$ r r. r& �MRr0 r r r �lookupMailRenamen r2 z ResolverBase.lookupMailRenamec C r- r )r$ r r. r& �PTRr0 r r r � lookupPointerq r2 zResolverBase.lookupPointerc C r- r )r$ r r. r& �SOAr0 r r r �lookupAuthorityt r2 z ResolverBase.lookupAuthorityc C r- r )r$ r r. r& �NULLr0 r r r � lookupNullw r2 zResolverBase.lookupNullc C r- r )r$ r r. r& �WKSr0 r r r �lookupWellKnownServicesz r2 z$ResolverBase.lookupWellKnownServicesc C r- r )r$ r r. r& �SRVr0 r r r � lookupService} r2 zResolverBase.lookupServicec C r- r )r$ r r. r& �HINFOr0 r r r �lookupHostInfo� r2 zResolverBase.lookupHostInfoc C r- r )r$ r r. r& �MINFOr0 r r r �lookupMailboxInfo� r2 z ResolverBase.lookupMailboxInfoc C r- r )r$ r r. r& �TXTr0 r r r � lookupText� r2 zResolverBase.lookupTextc C r- r )r$ r r. r& �SPFr0 r r r �lookupSenderPolicy� r2 z ResolverBase.lookupSenderPolicyc C r- r )r$ r r. r& �RPr0 r r r �lookupResponsibility� r2 z!ResolverBase.lookupResponsibilityc C r- r )r$ r r. r& �AFSDBr0 r r r �lookupAFSDatabase� r2 z ResolverBase.lookupAFSDatabasec C r- r )r$ r r. r& �AXFRr0 r r r � lookupZone� r2 zResolverBase.lookupZonec C r- r )r$ r r. r& �NAPTRr0 r r r � lookupNamingAuthorityPointer� r2 z)ResolverBase.lookupNamingAuthorityPointerc C r- r )r$ r r. r& � ALL_RECORDSr0 r r r �lookupAllRecords� r2 z ResolverBase.lookupAllRecords� c C s* t �|�}| �||�}|�| j||� |S r )r r. r^ � addCallback� _cbRecords)r r% r' �effort�dr r r � getHostByName� s zResolverBase.getHostByNamec C s8 |\}}}t | t�|�|| | |�}|st�|��|S r )� extractRecordr �Namer �DNSLookupError)r �recordsr% rb �ans�auth�add�resultr r r ra � s zResolverBase._cbRecordsr )Nr_ )0�__name__� __module__� __qualname__�__doc__r r! r �EFORMATr �ESERVERr �ENAMEr �ENOTIMPr �EREFUSEDr r r r r r r$ r1 r4 r6 r8 r: r< r> r@ rB rD rF rH rJ rL rN rP rR rT rV rX rZ r\ r^ rd ra r r r r r ! sN � r r_ c s~ � sdS t td�r?|D ]}|j�kr#|jtjkr#t�tj|jj � S q |D ]}|j�kr>|jtj kr>t�tj|jj � S q&|D ]}|j�krY|jtj krYt�tj |jj � S qA|D ],}|j�kr�|jtj kr�t| |jj|� d �}|s�| j|jjj� d d� S | S q\|D ]1}|jtjkr�q�ddlm} |j|jjj�d�tjfgd��� ��fd d �}���j��|� S dS ) am Resolve a name to an IP address, following I{CNAME} records and I{NS} referrals recursively. This is an implementation detail of L{ResolverBase.getHostByName}. @param resolver: The resolver to use for the next query (unless handling an I{NS} referral). @type resolver: L{IResolver} @param name: The name being looked up. @type name: L{dns.Name} @param answers: All of the records returned by the previous query (answers, authority, and additional concatenated). @type answers: L{list} of L{dns.RRHeader} @param level: Remaining recursion budget. This is decremented at each recursion. The query returns L{None} when it reaches 0. @type level: L{int} @returns: The first IPv4 or IPv6 address (as a dotted quad or colon quibbles), or L{None} when no result is found. @rtype: native L{str} or L{None} N� inet_ntop� )rb r )�client�ascii)�serversc s$ | \}}}t ��|| | � d �S )Nrw )re )rh ri rj rk ��levelr% � nsResolverr r � queryAgain� s z!extractRecord.<locals>.queryAgain)�hasattr�socketr% r r r5 rv �AF_INET6�payload�addressr3 r/ �AF_INETr; re rd r9 � twisted.namesrx �Resolver�decode�PORTr1 r` )�resolverr% �answersr| �rrl rx r~ r r{ r re � sB ��� � ���re r1 r4 r6 r: r< rF r> r@ rB rH rJ rD rN rP r8 rR rT rV rX rL r\ rZ r^ )r_ )3rp r� �zope.interfacer �twisted.internetr r r �twisted.loggerr r� r �twisted.names.errorr r r r r r �range�_ANS�_AUTH�_ADD� EMPTY_RESULT� IResolverr re r/ r3 r5 r9 r; rE r= r? rA rG rI rC rM rO r7 rQ rS rU rW rK r[ rY r] r r r r r �<module> sn B�������� � � � � ����� �PK y�Z�z���# �# _rfc1982.pynu �[��� # -*- test-case-name: twisted.names.test.test_rfc1982 -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Utilities for handling RFC1982 Serial Number Arithmetic. @see: U{http://tools.ietf.org/html/rfc1982} @var RFC4034_TIME_FORMAT: RRSIG Time field presentation format. The Signature Expiration Time and Inception Time field values MUST be represented either as an unsigned decimal integer indicating seconds since 1 January 1970 00:00:00 UTC, or in the form YYYYMMDDHHmmSS in UTC. See U{RRSIG Presentation Format<https://tools.ietf.org/html/rfc4034#section-3.2>} """ import calendar from datetime import datetime, timedelta from twisted.python.compat import nativeString from twisted.python.util import FancyStrMixin RFC4034_TIME_FORMAT = "%Y%m%d%H%M%S" class SerialNumber(FancyStrMixin): """ An RFC1982 Serial Number. This class implements RFC1982 DNS Serial Number Arithmetic. SNA is used in DNS and specifically in DNSSEC as defined in RFC4034 in the DNSSEC Signature Expiration and Inception Fields. @see: U{https://tools.ietf.org/html/rfc1982} @see: U{https://tools.ietf.org/html/rfc4034} @ivar _serialBits: See C{serialBits} of L{__init__}. @ivar _number: See C{number} of L{__init__}. @ivar _modulo: The value at which wrapping will occur. @ivar _halfRing: Half C{_modulo}. If another L{SerialNumber} value is larger than this, it would lead to a wrapped value which is larger than the first and comparisons are therefore ambiguous. @ivar _maxAdd: Half C{_modulo} plus 1. If another L{SerialNumber} value is larger than this, it would lead to a wrapped value which is larger than the first. Comparisons with the original value would therefore be ambiguous. """ showAttributes = ( ("_number", "number", "%d"), ("_serialBits", "serialBits", "%d"), ) def __init__(self, number, serialBits=32): """ Construct an L{SerialNumber} instance. @param number: An L{int} which will be stored as the modulo C{number % 2 ^ serialBits} @type number: L{int} @param serialBits: The size of the serial number space. The power of two which results in one larger than the largest integer corresponding to a serial number value. @type serialBits: L{int} """ self._serialBits = serialBits self._modulo = 2 ** serialBits self._halfRing = 2 ** (serialBits - 1) self._maxAdd = 2 ** (serialBits - 1) - 1 self._number = int(number) % self._modulo def _convertOther(self, other: object) -> "SerialNumber": """ Check that a foreign object is suitable for use in the comparison or arithmetic magic methods of this L{SerialNumber} instance. Raise L{TypeError} if not. @param other: The foreign L{object} to be checked. @return: C{other} after compatibility checks and possible coercion. @raise TypeError: If C{other} is not compatible. """ if not isinstance(other, SerialNumber): raise TypeError(f"cannot compare or combine {self!r} and {other!r}") if self._serialBits != other._serialBits: raise TypeError( "cannot compare or combine SerialNumber instances with " "different serialBits. %r and %r" % (self, other) ) return other def __str__(self) -> str: """ Return a string representation of this L{SerialNumber} instance. @rtype: L{nativeString} """ return nativeString("%d" % (self._number,)) def __int__(self): """ @return: The integer value of this L{SerialNumber} instance. @rtype: L{int} """ return self._number def __eq__(self, other: object) -> bool: """ Allow rich equality comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return other._number == self._number def __lt__(self, other: object) -> bool: """ Allow I{less than} comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return ( self._number < other._number and (other._number - self._number) < self._halfRing ) or ( self._number > other._number and (self._number - other._number) > self._halfRing ) def __gt__(self, other: object) -> bool: """ Allow I{greater than} comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return ( self._number < other._number and (other._number - self._number) > self._halfRing ) or ( self._number > other._number and (self._number - other._number) < self._halfRing ) def __le__(self, other: object) -> bool: """ Allow I{less than or equal} comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return self == other or self < other def __ge__(self, other: object) -> bool: """ Allow I{greater than or equal} comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return self == other or self > other def __add__(self, other: object) -> "SerialNumber": """ Allow I{addition} with another L{SerialNumber} instance. Serial numbers may be incremented by the addition of a positive integer n, where n is taken from the range of integers [0 .. (2^(SERIAL_BITS - 1) - 1)]. For a sequence number s, the result of such an addition, s', is defined as s' = (s + n) modulo (2 ^ SERIAL_BITS) where the addition and modulus operations here act upon values that are non-negative values of unbounded size in the usual ways of integer arithmetic. Addition of a value outside the range [0 .. (2^(SERIAL_BITS - 1) - 1)] is undefined. @see: U{http://tools.ietf.org/html/rfc1982#section-3.1} @raise ArithmeticError: If C{other} is more than C{_maxAdd} ie more than half the maximum value of this serial number. """ try: other = self._convertOther(other) except TypeError: return NotImplemented if other._number <= self._maxAdd: return SerialNumber( (self._number + other._number) % self._modulo, serialBits=self._serialBits, ) else: raise ArithmeticError( "value %r outside the range 0 .. %r" % ( other._number, self._maxAdd, ) ) def __hash__(self): """ Allow L{SerialNumber} instances to be hashed for use as L{dict} keys. @rtype: L{int} """ return hash(self._number) @classmethod def fromRFC4034DateString(cls, utcDateString): """ Create an L{SerialNumber} instance from a date string in format 'YYYYMMDDHHMMSS' described in U{RFC4034 3.2<https://tools.ietf.org/html/rfc4034#section-3.2>}. The L{SerialNumber} instance stores the date as a 32bit UNIX timestamp. @see: U{https://tools.ietf.org/html/rfc4034#section-3.1.5} @param utcDateString: A UTC date/time string of format I{YYMMDDhhmmss} which will be converted to seconds since the UNIX epoch. @type utcDateString: L{unicode} @return: An L{SerialNumber} instance containing the supplied date as a 32bit UNIX timestamp. """ parsedDate = datetime.strptime(utcDateString, RFC4034_TIME_FORMAT) secondsSinceEpoch = calendar.timegm(parsedDate.utctimetuple()) return cls(secondsSinceEpoch, serialBits=32) def toRFC4034DateString(self): """ Calculate a date by treating the current L{SerialNumber} value as a UNIX timestamp and return a date string in the format described in U{RFC4034 3.2<https://tools.ietf.org/html/rfc4034#section-3.2>}. @return: The date string. """ # Can't use datetime.utcfromtimestamp, because it seems to overflow the # signed 32bit int used in the underlying C library. SNA is unsigned # and capable of handling all timestamps up to 2**32. d = datetime(1970, 1, 1) + timedelta(seconds=self._number) return nativeString(d.strftime(RFC4034_TIME_FORMAT)) __all__ = ["SerialNumber"] PK y�Z�B��1 1 test/test_resolve.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names.resolve}. """ from twisted.names.error import DomainError from twisted.names.resolve import ResolverChain from twisted.trial.unittest import TestCase class ResolverChainTests(TestCase): """ Tests for L{twisted.names.resolve.ResolverChain} """ def test_emptyResolversList(self): """ L{ResolverChain._lookup} returns a L{DomainError} failure if its C{resolvers} list is empty. """ r = ResolverChain([]) d = r.lookupAddress("www.example.com") f = self.failureResultOf(d) self.assertIs(f.trap(DomainError), DomainError) def test_emptyResolversListLookupAllRecords(self): """ L{ResolverChain.lookupAllRecords} returns a L{DomainError} failure if its C{resolvers} list is empty. """ r = ResolverChain([]) d = r.lookupAllRecords("www.example.com") f = self.failureResultOf(d) self.assertIs(f.trap(DomainError), DomainError) PK y�Z\�)wǢ Ǣ test/test_server.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.names.server}. """ from zope.interface.verify import verifyClass from twisted.internet import defer from twisted.internet.interfaces import IProtocolFactory from twisted.names import dns, error, resolve, server from twisted.python import failure, log from twisted.trial import unittest class RaisedArguments(Exception): """ An exception containing the arguments raised by L{raiser}. """ def __init__(self, args, kwargs): self.args = args self.kwargs = kwargs def raiser(*args, **kwargs): """ Raise a L{RaisedArguments} exception containing the supplied arguments. Used as a fake when testing the call signatures of methods and functions. """ raise RaisedArguments(args, kwargs) class NoResponseDNSServerFactory(server.DNSServerFactory): """ A L{server.DNSServerFactory} subclass which does not attempt to reply to any received messages. Used for testing logged messages in C{messageReceived} without having to fake or patch the preceding code which attempts to deliver a response message. """ def allowQuery(self, message, protocol, address): """ Deny all queries. @param message: See L{server.DNSServerFactory.allowQuery} @param protocol: See L{server.DNSServerFactory.allowQuery} @param address: See L{server.DNSServerFactory.allowQuery} @return: L{False} @rtype: L{bool} """ return False def sendReply(self, protocol, message, address): """ A noop send reply. @param protocol: See L{server.DNSServerFactory.sendReply} @param message: See L{server.DNSServerFactory.sendReply} @param address: See L{server.DNSServerFactory.sendReply} """ class RaisingDNSServerFactory(server.DNSServerFactory): """ A L{server.DNSServerFactory} subclass whose methods raise an exception containing the supplied arguments. Used for stopping L{messageReceived} and testing the arguments supplied to L{allowQuery}. """ class AllowQueryArguments(Exception): """ Contains positional and keyword arguments in C{args}. """ def allowQuery(self, *args, **kwargs): """ Raise the arguments supplied to L{allowQuery}. @param args: Positional arguments which will be recorded in the raised exception. @type args: L{tuple} @param kwargs: Keyword args which will be recorded in the raised exception. @type kwargs: L{dict} """ raise self.AllowQueryArguments(args, kwargs) class RaisingProtocol: """ A partial fake L{IProtocol} whose methods raise an exception containing the supplied arguments. """ class WriteMessageArguments(Exception): """ Contains positional and keyword arguments in C{args}. """ def writeMessage(self, *args, **kwargs): """ Raises the supplied arguments. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} """ raise self.WriteMessageArguments(args, kwargs) class NoopProtocol: """ A partial fake L{dns.DNSProtocolMixin} with a noop L{writeMessage} method. """ def writeMessage(self, *args, **kwargs): """ A noop version of L{dns.DNSProtocolMixin.writeMessage}. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} """ class RaisingResolver: """ A partial fake L{IResolver} whose methods raise an exception containing the supplied arguments. """ class QueryArguments(Exception): """ Contains positional and keyword arguments in C{args}. """ def query(self, *args, **kwargs): """ Raises the supplied arguments. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} """ raise self.QueryArguments(args, kwargs) class RaisingCache: """ A partial fake L{twisted.names.cache.Cache} whose methods raise an exception containing the supplied arguments. """ class CacheResultArguments(Exception): """ Contains positional and keyword arguments in C{args}. """ def cacheResult(self, *args, **kwargs): """ Raises the supplied arguments. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} """ raise self.CacheResultArguments(args, kwargs) def assertLogMessage(testCase, expectedMessages, callable, *args, **kwargs): """ Assert that the callable logs the expected messages when called. XXX: Put this somewhere where it can be re-used elsewhere. See #6677. @param testCase: The test case controlling the test which triggers the logged messages and on which assertions will be called. @type testCase: L{unittest.SynchronousTestCase} @param expectedMessages: A L{list} of the expected log messages @type expectedMessages: L{list} @param callable: The function which is expected to produce the C{expectedMessages} when called. @type callable: L{callable} @param args: Positional arguments to be passed to C{callable}. @type args: L{list} @param kwargs: Keyword arguments to be passed to C{callable}. @type kwargs: L{dict} """ loggedMessages = [] log.addObserver(loggedMessages.append) testCase.addCleanup(log.removeObserver, loggedMessages.append) callable(*args, **kwargs) testCase.assertEqual([m["message"][0] for m in loggedMessages], expectedMessages) class DNSServerFactoryTests(unittest.TestCase): """ Tests for L{server.DNSServerFactory}. """ def test_resolverType(self): """ L{server.DNSServerFactory.resolver} is a L{resolve.ResolverChain} instance """ self.assertIsInstance(server.DNSServerFactory().resolver, resolve.ResolverChain) def test_resolverDefaultEmpty(self): """ L{server.DNSServerFactory.resolver} is an empty L{resolve.ResolverChain} by default. """ self.assertEqual(server.DNSServerFactory().resolver.resolvers, []) def test_authorities(self): """ L{server.DNSServerFactory.__init__} accepts an C{authorities} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. """ dummyResolver = object() self.assertEqual( server.DNSServerFactory(authorities=[dummyResolver]).resolver.resolvers, [dummyResolver], ) def test_caches(self): """ L{server.DNSServerFactory.__init__} accepts a C{caches} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. """ dummyResolver = object() self.assertEqual( server.DNSServerFactory(caches=[dummyResolver]).resolver.resolvers, [dummyResolver], ) def test_clients(self): """ L{server.DNSServerFactory.__init__} accepts a C{clients} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. """ dummyResolver = object() self.assertEqual( server.DNSServerFactory(clients=[dummyResolver]).resolver.resolvers, [dummyResolver], ) def test_resolverOrder(self): """ L{server.DNSServerFactory.resolver} contains an ordered list of authorities, caches and clients. """ # Use classes here so that we can see meaningful names in test results class DummyAuthority: pass class DummyCache: pass class DummyClient: pass self.assertEqual( server.DNSServerFactory( authorities=[DummyAuthority], caches=[DummyCache], clients=[DummyClient] ).resolver.resolvers, [DummyAuthority, DummyCache, DummyClient], ) def test_cacheDefault(self): """ L{server.DNSServerFactory.cache} is L{None} by default. """ self.assertIsNone(server.DNSServerFactory().cache) def test_cacheOverride(self): """ L{server.DNSServerFactory.__init__} assigns the last object in the C{caches} list to L{server.DNSServerFactory.cache}. """ dummyResolver = object() self.assertEqual( server.DNSServerFactory(caches=[object(), dummyResolver]).cache, dummyResolver, ) def test_canRecurseDefault(self): """ L{server.DNSServerFactory.canRecurse} is a flag indicating that this server is capable of performing recursive DNS lookups. It defaults to L{False}. """ self.assertFalse(server.DNSServerFactory().canRecurse) def test_canRecurseOverride(self): """ L{server.DNSServerFactory.__init__} sets C{canRecurse} to L{True} if it is supplied with C{clients}. """ self.assertEqual(server.DNSServerFactory(clients=[None]).canRecurse, True) def test_verboseDefault(self): """ L{server.DNSServerFactory.verbose} defaults to L{False}. """ self.assertFalse(server.DNSServerFactory().verbose) def test_verboseOverride(self): """ L{server.DNSServerFactory.__init__} accepts a C{verbose} argument which overrides L{server.DNSServerFactory.verbose}. """ self.assertTrue(server.DNSServerFactory(verbose=True).verbose) def test_interface(self): """ L{server.DNSServerFactory} implements L{IProtocolFactory}. """ self.assertTrue(verifyClass(IProtocolFactory, server.DNSServerFactory)) def test_defaultProtocol(self): """ L{server.DNSServerFactory.protocol} defaults to L{dns.DNSProtocol}. """ self.assertIs(server.DNSServerFactory.protocol, dns.DNSProtocol) def test_buildProtocolProtocolOverride(self): """ L{server.DNSServerFactory.buildProtocol} builds a protocol by calling L{server.DNSServerFactory.protocol} with its self as a positional argument. """ class FakeProtocol: factory = None args = None kwargs = None stubProtocol = FakeProtocol() def fakeProtocolFactory(*args, **kwargs): stubProtocol.args = args stubProtocol.kwargs = kwargs return stubProtocol f = server.DNSServerFactory() f.protocol = fakeProtocolFactory p = f.buildProtocol(addr=None) self.assertEqual((stubProtocol, (f,), {}), (p, p.args, p.kwargs)) def test_verboseLogQuiet(self): """ L{server.DNSServerFactory._verboseLog} does not log messages unless C{verbose > 0}. """ f = server.DNSServerFactory() assertLogMessage(self, [], f._verboseLog, "Foo Bar") def test_verboseLogVerbose(self): """ L{server.DNSServerFactory._verboseLog} logs a message if C{verbose > 0}. """ f = server.DNSServerFactory(verbose=1) assertLogMessage(self, ["Foo Bar"], f._verboseLog, "Foo Bar") def test_messageReceivedLoggingNoQuery(self): """ L{server.DNSServerFactory.messageReceived} logs about an empty query if the message had no queries and C{verbose} is C{>0}. """ m = dns.Message() f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Empty query from ('192.0.2.100', 53)"], f.messageReceived, message=m, proto=None, address=("192.0.2.100", 53), ) def test_messageReceivedLogging1(self): """ L{server.DNSServerFactory.messageReceived} logs the query types of all queries in the message if C{verbose} is set to C{1}. """ m = dns.Message() m.addQuery(name="example.com", type=dns.MX) m.addQuery(name="example.com", type=dns.AAAA) f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["MX AAAA query from ('192.0.2.100', 53)"], f.messageReceived, message=m, proto=None, address=("192.0.2.100", 53), ) def test_messageReceivedLogging2(self): """ L{server.DNSServerFactory.messageReceived} logs the repr of all queries in the message if C{verbose} is set to C{2}. """ m = dns.Message() m.addQuery(name="example.com", type=dns.MX) m.addQuery(name="example.com", type=dns.AAAA) f = NoResponseDNSServerFactory(verbose=2) assertLogMessage( self, [ "<Query example.com MX IN> " "<Query example.com AAAA IN> query from ('192.0.2.100', 53)" ], f.messageReceived, message=m, proto=None, address=("192.0.2.100", 53), ) def test_messageReceivedTimestamp(self): """ L{server.DNSServerFactory.messageReceived} assigns a unix timestamp to the received message. """ m = dns.Message() f = NoResponseDNSServerFactory() t = object() self.patch(server.time, "time", lambda: t) f.messageReceived(message=m, proto=None, address=None) self.assertEqual(m.timeReceived, t) def test_messageReceivedAllowQuery(self): """ L{server.DNSServerFactory.messageReceived} passes all messages to L{server.DNSServerFactory.allowQuery} along with the receiving protocol and origin address. """ message = dns.Message() dummyProtocol = object() dummyAddress = object() f = RaisingDNSServerFactory() e = self.assertRaises( RaisingDNSServerFactory.AllowQueryArguments, f.messageReceived, message=message, proto=dummyProtocol, address=dummyAddress, ) args, kwargs = e.args self.assertEqual(args, (message, dummyProtocol, dummyAddress)) self.assertEqual(kwargs, {}) def test_allowQueryFalse(self): """ If C{allowQuery} returns C{False}, L{server.DNSServerFactory.messageReceived} calls L{server.sendReply} with a message whose C{rCode} is L{dns.EREFUSED}. """ class SendReplyException(Exception): pass class RaisingDNSServerFactory(server.DNSServerFactory): def allowQuery(self, *args, **kwargs): return False def sendReply(self, *args, **kwargs): raise SendReplyException(args, kwargs) f = RaisingDNSServerFactory() e = self.assertRaises( SendReplyException, f.messageReceived, message=dns.Message(), proto=None, address=None, ) (proto, message, address), kwargs = e.args self.assertEqual(message.rCode, dns.EREFUSED) def _messageReceivedTest(self, methodName, message): """ Assert that the named method is called with the given message when it is passed to L{DNSServerFactory.messageReceived}. @param methodName: The name of the method which is expected to be called. @type methodName: L{str} @param message: The message which is expected to be passed to the C{methodName} method. @type message: L{dns.Message} """ # Make it appear to have some queries so that # DNSServerFactory.allowQuery allows it. message.queries = [None] receivedMessages = [] def fakeHandler(message, protocol, address): receivedMessages.append((message, protocol, address)) protocol = NoopProtocol() factory = server.DNSServerFactory(None) setattr(factory, methodName, fakeHandler) factory.messageReceived(message, protocol) self.assertEqual(receivedMessages, [(message, protocol, None)]) def test_queryMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_QUERY} on to L{DNSServerFactory.handleQuery}. """ self._messageReceivedTest("handleQuery", dns.Message(opCode=dns.OP_QUERY)) def test_inverseQueryMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_INVERSE} on to L{DNSServerFactory.handleInverseQuery}. """ self._messageReceivedTest( "handleInverseQuery", dns.Message(opCode=dns.OP_INVERSE) ) def test_statusMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_STATUS} on to L{DNSServerFactory.handleStatus}. """ self._messageReceivedTest("handleStatus", dns.Message(opCode=dns.OP_STATUS)) def test_notifyMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_NOTIFY} on to L{DNSServerFactory.handleNotify}. """ self._messageReceivedTest("handleNotify", dns.Message(opCode=dns.OP_NOTIFY)) def test_updateMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_UPDATE} on to L{DNSServerFactory.handleOther}. This may change if the implementation ever covers update messages. """ self._messageReceivedTest("handleOther", dns.Message(opCode=dns.OP_UPDATE)) def test_connectionTracking(self): """ The C{connectionMade} and C{connectionLost} methods of L{DNSServerFactory} cooperate to keep track of all L{DNSProtocol} objects created by a factory which are connected. """ protoA, protoB = object(), object() factory = server.DNSServerFactory() factory.connectionMade(protoA) self.assertEqual(factory.connections, [protoA]) factory.connectionMade(protoB) self.assertEqual(factory.connections, [protoA, protoB]) factory.connectionLost(protoA) self.assertEqual(factory.connections, [protoB]) factory.connectionLost(protoB) self.assertEqual(factory.connections, []) def test_handleQuery(self): """ L{server.DNSServerFactory.handleQuery} takes the first query from the supplied message and dispatches it to L{server.DNSServerFactory.resolver.query}. """ m = dns.Message() m.addQuery(b"one.example.com") m.addQuery(b"two.example.com") f = server.DNSServerFactory() f.resolver = RaisingResolver() e = self.assertRaises( RaisingResolver.QueryArguments, f.handleQuery, message=m, protocol=NoopProtocol(), address=None, ) (query,), kwargs = e.args self.assertEqual(query, m.queries[0]) def test_handleQueryCallback(self): """ L{server.DNSServerFactory.handleQuery} adds L{server.DNSServerFactory.resolver.gotResolverResponse} as a callback to the deferred returned by L{server.DNSServerFactory.resolver.query}. It is called with the query response, the original protocol, message and origin address. """ f = server.DNSServerFactory() d = defer.Deferred() class FakeResolver: def query(self, *args, **kwargs): return d f.resolver = FakeResolver() gotResolverResponseArgs = [] def fakeGotResolverResponse(*args, **kwargs): gotResolverResponseArgs.append((args, kwargs)) f.gotResolverResponse = fakeGotResolverResponse m = dns.Message() m.addQuery(b"one.example.com") stubProtocol = NoopProtocol() dummyAddress = object() f.handleQuery(message=m, protocol=stubProtocol, address=dummyAddress) dummyResponse = object() d.callback(dummyResponse) self.assertEqual( gotResolverResponseArgs, [((dummyResponse, stubProtocol, m, dummyAddress), {})], ) def test_handleQueryErrback(self): """ L{server.DNSServerFactory.handleQuery} adds L{server.DNSServerFactory.resolver.gotResolverError} as an errback to the deferred returned by L{server.DNSServerFactory.resolver.query}. It is called with the query failure, the original protocol, message and origin address. """ f = server.DNSServerFactory() d = defer.Deferred() class FakeResolver: def query(self, *args, **kwargs): return d f.resolver = FakeResolver() gotResolverErrorArgs = [] def fakeGotResolverError(*args, **kwargs): gotResolverErrorArgs.append((args, kwargs)) f.gotResolverError = fakeGotResolverError m = dns.Message() m.addQuery(b"one.example.com") stubProtocol = NoopProtocol() dummyAddress = object() f.handleQuery(message=m, protocol=stubProtocol, address=dummyAddress) stubFailure = failure.Failure(Exception()) d.errback(stubFailure) self.assertEqual( gotResolverErrorArgs, [((stubFailure, stubProtocol, m, dummyAddress), {})] ) def test_gotResolverResponse(self): """ L{server.DNSServerFactory.gotResolverResponse} accepts a tuple of resource record lists and triggers a response message containing those resource record lists. """ f = server.DNSServerFactory() answers = [] authority = [] additional = [] e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.gotResolverResponse, (answers, authority, additional), protocol=RaisingProtocol(), message=dns.Message(), address=None, ) (message,), kwargs = e.args self.assertIs(message.answers, answers) self.assertIs(message.authority, authority) self.assertIs(message.additional, additional) def test_gotResolverResponseCallsResponseFromMessage(self): """ L{server.DNSServerFactory.gotResolverResponse} calls L{server.DNSServerFactory._responseFromMessage} to generate a response. """ factory = NoResponseDNSServerFactory() factory._responseFromMessage = raiser request = dns.Message() request.timeReceived = 1 e = self.assertRaises( RaisedArguments, factory.gotResolverResponse, ([], [], []), protocol=None, message=request, address=None, ) self.assertEqual( ( (), dict( message=request, rCode=dns.OK, answers=[], authority=[], additional=[], ), ), (e.args, e.kwargs), ) def test_responseFromMessageNewMessage(self): """ L{server.DNSServerFactory._responseFromMessage} generates a response message which is a copy of the request message. """ factory = server.DNSServerFactory() request = dns.Message(answer=False, recAv=False) response = (factory._responseFromMessage(message=request),) self.assertIsNot(request, response) def test_responseFromMessageRecursionAvailable(self): """ L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{recAV} attribute is L{True} if L{server.DNSServerFactory.canRecurse} is L{True}. """ factory = server.DNSServerFactory() factory.canRecurse = True response1 = factory._responseFromMessage(message=dns.Message(recAv=False)) factory.canRecurse = False response2 = factory._responseFromMessage(message=dns.Message(recAv=True)) self.assertEqual((True, False), (response1.recAv, response2.recAv)) def test_responseFromMessageTimeReceived(self): """ L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{timeReceived} attribute has the same value as that found on the request. """ factory = server.DNSServerFactory() request = dns.Message() request.timeReceived = 1234 response = factory._responseFromMessage(message=request) self.assertEqual(request.timeReceived, response.timeReceived) def test_responseFromMessageMaxSize(self): """ L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{maxSize} attribute has the same value as that found on the request. """ factory = server.DNSServerFactory() request = dns.Message() request.maxSize = 0 response = factory._responseFromMessage(message=request) self.assertEqual(request.maxSize, response.maxSize) def test_messageFactory(self): """ L{server.DNSServerFactory} has a C{_messageFactory} attribute which is L{dns.Message} by default. """ self.assertIs(dns.Message, server.DNSServerFactory._messageFactory) def test_responseFromMessageCallsMessageFactory(self): """ L{server.DNSServerFactory._responseFromMessage} calls C{dns._responseFromMessage} to generate a response message from the request message. It supplies the request message and other keyword arguments which should be passed to the response message initialiser. """ factory = server.DNSServerFactory() self.patch(dns, "_responseFromMessage", raiser) request = dns.Message() e = self.assertRaises( RaisedArguments, factory._responseFromMessage, message=request, rCode=dns.OK ) self.assertEqual( ( (), dict( responseConstructor=factory._messageFactory, message=request, rCode=dns.OK, recAv=factory.canRecurse, auth=False, ), ), (e.args, e.kwargs), ) def test_responseFromMessageAuthoritativeMessage(self): """ L{server.DNSServerFactory._responseFromMessage} marks the response message as authoritative if any of the answer records are authoritative. """ factory = server.DNSServerFactory() response1 = factory._responseFromMessage( message=dns.Message(), answers=[dns.RRHeader(auth=True)] ) response2 = factory._responseFromMessage( message=dns.Message(), answers=[dns.RRHeader(auth=False)] ) self.assertEqual( (True, False), (response1.auth, response2.auth), ) def test_gotResolverResponseLogging(self): """ L{server.DNSServerFactory.gotResolverResponse} logs the total number of records in the response if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) answers = [dns.RRHeader()] authority = [dns.RRHeader()] additional = [dns.RRHeader()] assertLogMessage( self, ["Lookup found 3 records"], f.gotResolverResponse, (answers, authority, additional), protocol=NoopProtocol(), message=dns.Message(), address=None, ) def test_gotResolverResponseCaching(self): """ L{server.DNSServerFactory.gotResolverResponse} caches the response if at least one cache was provided in the constructor. """ f = NoResponseDNSServerFactory(caches=[RaisingCache()]) m = dns.Message() m.addQuery(b"example.com") expectedAnswers = [dns.RRHeader()] expectedAuthority = [] expectedAdditional = [] e = self.assertRaises( RaisingCache.CacheResultArguments, f.gotResolverResponse, (expectedAnswers, expectedAuthority, expectedAdditional), protocol=NoopProtocol(), message=m, address=None, ) (query, (answers, authority, additional)), kwargs = e.args self.assertEqual(query.name.name, b"example.com") self.assertIs(answers, expectedAnswers) self.assertIs(authority, expectedAuthority) self.assertIs(additional, expectedAdditional) def test_gotResolverErrorCallsResponseFromMessage(self): """ L{server.DNSServerFactory.gotResolverError} calls L{server.DNSServerFactory._responseFromMessage} to generate a response. """ factory = NoResponseDNSServerFactory() factory._responseFromMessage = raiser request = dns.Message() request.timeReceived = 1 e = self.assertRaises( RaisedArguments, factory.gotResolverError, failure.Failure(error.DomainError()), protocol=None, message=request, address=None, ) self.assertEqual( ((), dict(message=request, rCode=dns.ENAME)), (e.args, e.kwargs) ) def _assertMessageRcodeForError(self, responseError, expectedMessageCode): """ L{server.DNSServerFactory.gotResolver} accepts a L{failure.Failure} and triggers a response message whose rCode corresponds to the DNS error contained in the C{Failure}. @param responseError: The L{Exception} instance which is expected to trigger C{expectedMessageCode} when it is supplied to C{gotResolverError} @type responseError: L{Exception} @param expectedMessageCode: The C{rCode} which is expected in the message returned by C{gotResolverError} in response to C{responseError}. @type expectedMessageCode: L{int} """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.gotResolverError, failure.Failure(responseError), protocol=RaisingProtocol(), message=dns.Message(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, expectedMessageCode) def test_gotResolverErrorDomainError(self): """ L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ENAME} if supplied with a L{error.DomainError}. """ self._assertMessageRcodeForError(error.DomainError(), dns.ENAME) def test_gotResolverErrorAuthoritativeDomainError(self): """ L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ENAME} if supplied with a L{error.AuthoritativeDomainError}. """ self._assertMessageRcodeForError(error.AuthoritativeDomainError(), dns.ENAME) def test_gotResolverErrorOtherError(self): """ L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ESERVER} if supplied with another type of error and logs the error. """ self._assertMessageRcodeForError(KeyError(), dns.ESERVER) e = self.flushLoggedErrors(KeyError) self.assertEqual(len(e), 1) def test_gotResolverErrorLogging(self): """ L{server.DNSServerFactory.gotResolver} logs a message if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Lookup failed"], f.gotResolverError, failure.Failure(error.DomainError()), protocol=NoopProtocol(), message=dns.Message(), address=None, ) def test_gotResolverErrorResetsResponseAttributes(self): """ L{server.DNSServerFactory.gotResolverError} does not allow request attributes to leak into the response ie it sends a response with AD, CD set to 0 and empty response record sections. """ factory = server.DNSServerFactory() responses = [] factory.sendReply = lambda protocol, response, address: responses.append( response ) request = dns.Message(authenticData=True, checkingDisabled=True) request.answers = [object(), object()] request.authority = [object(), object()] request.additional = [object(), object()] factory.gotResolverError( failure.Failure(error.DomainError()), protocol=None, message=request, address=None, ) self.assertEqual([dns.Message(rCode=3, answer=True)], responses) def test_gotResolverResponseResetsResponseAttributes(self): """ L{server.DNSServerFactory.gotResolverResponse} does not allow request attributes to leak into the response ie it sends a response with AD, CD set to 0 and none of the records in the request answer sections are copied to the response. """ factory = server.DNSServerFactory() responses = [] factory.sendReply = lambda protocol, response, address: responses.append( response ) request = dns.Message(authenticData=True, checkingDisabled=True) request.answers = [object(), object()] request.authority = [object(), object()] request.additional = [object(), object()] factory.gotResolverResponse( ([], [], []), protocol=None, message=request, address=None ) self.assertEqual([dns.Message(rCode=0, answer=True)], responses) def test_sendReplyWithAddress(self): """ If L{server.DNSServerFactory.sendReply} is supplied with a protocol *and* an address tuple it will supply that address to C{protocol.writeMessage}. """ m = dns.Message() dummyAddress = object() f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.sendReply, protocol=RaisingProtocol(), message=m, address=dummyAddress, ) args, kwargs = e.args self.assertEqual(args, (m, dummyAddress)) self.assertEqual(kwargs, {}) def test_sendReplyWithoutAddress(self): """ If L{server.DNSServerFactory.sendReply} is supplied with a protocol but no address tuple it will supply only a message to C{protocol.writeMessage}. """ m = dns.Message() f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.sendReply, protocol=RaisingProtocol(), message=m, address=None, ) args, kwargs = e.args self.assertEqual(args, (m,)) self.assertEqual(kwargs, {}) def test_sendReplyLoggingNoAnswers(self): """ If L{server.DNSServerFactory.sendReply} logs a "no answers" message if the supplied message has no answers. """ self.patch(server.time, "time", lambda: 86402) m = dns.Message() m.timeReceived = 86401 f = server.DNSServerFactory(verbose=2) assertLogMessage( self, ["Replying with no answers", "Processed query in 1.000 seconds"], f.sendReply, protocol=NoopProtocol(), message=m, address=None, ) def test_sendReplyLoggingWithAnswers(self): """ If L{server.DNSServerFactory.sendReply} logs a message for answers, authority, additional if the supplied a message has records in any of those sections. """ self.patch(server.time, "time", lambda: 86402) m = dns.Message() m.answers.append(dns.RRHeader(payload=dns.Record_A("127.0.0.1"))) m.authority.append(dns.RRHeader(payload=dns.Record_A("127.0.0.1"))) m.additional.append(dns.RRHeader(payload=dns.Record_A("127.0.0.1"))) m.timeReceived = 86401 f = server.DNSServerFactory(verbose=2) assertLogMessage( self, [ "Answers are <A address=127.0.0.1 ttl=None>", "Authority is <A address=127.0.0.1 ttl=None>", "Additional is <A address=127.0.0.1 ttl=None>", "Processed query in 1.000 seconds", ], f.sendReply, protocol=NoopProtocol(), message=m, address=None, ) def test_handleInverseQuery(self): """ L{server.DNSServerFactory.handleInverseQuery} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.handleInverseQuery, message=dns.Message(), protocol=RaisingProtocol(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, dns.ENOTIMP) def test_handleInverseQueryLogging(self): """ L{server.DNSServerFactory.handleInverseQuery} logs the message origin address if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Inverse query from ('::1', 53)"], f.handleInverseQuery, message=dns.Message(), protocol=NoopProtocol(), address=("::1", 53), ) def test_handleStatus(self): """ L{server.DNSServerFactory.handleStatus} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.handleStatus, message=dns.Message(), protocol=RaisingProtocol(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, dns.ENOTIMP) def test_handleStatusLogging(self): """ L{server.DNSServerFactory.handleStatus} logs the message origin address if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Status request from ('::1', 53)"], f.handleStatus, message=dns.Message(), protocol=NoopProtocol(), address=("::1", 53), ) def test_handleNotify(self): """ L{server.DNSServerFactory.handleNotify} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.handleNotify, message=dns.Message(), protocol=RaisingProtocol(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, dns.ENOTIMP) def test_handleNotifyLogging(self): """ L{server.DNSServerFactory.handleNotify} logs the message origin address if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Notify message from ('::1', 53)"], f.handleNotify, message=dns.Message(), protocol=NoopProtocol(), address=("::1", 53), ) def test_handleOther(self): """ L{server.DNSServerFactory.handleOther} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.handleOther, message=dns.Message(), protocol=RaisingProtocol(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, dns.ENOTIMP) def test_handleOtherLogging(self): """ L{server.DNSServerFactory.handleOther} logs the message origin address if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Unknown op code (0) from ('::1', 53)"], f.handleOther, message=dns.Message(), protocol=NoopProtocol(), address=("::1", 53), ) PK y�Z���}� � test/test_cache.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names.cache}. """ import time from zope.interface.verify import verifyClass from twisted.internet import interfaces, task from twisted.names import cache, dns from twisted.trial import unittest class CachingTests(unittest.TestCase): """ Tests for L{cache.CacheResolver}. """ def test_interface(self): """ L{cache.CacheResolver} implements L{interfaces.IResolver} """ verifyClass(interfaces.IResolver, cache.CacheResolver) def test_lookup(self): c = cache.CacheResolver( { dns.Query(name=b"example.com", type=dns.MX, cls=dns.IN): ( time.time(), ([], [], []), ) } ) return c.lookupMailExchange(b"example.com").addCallback( self.assertEqual, ([], [], []) ) def test_constructorExpires(self): """ Cache entries passed into L{cache.CacheResolver.__init__} get cancelled just like entries added with cacheResult """ r = ( [ dns.RRHeader( b"example.com", dns.A, dns.IN, 60, dns.Record_A("127.0.0.1", 60) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 50, dns.Record_A("127.0.0.1", 50) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 40, dns.Record_A("127.0.0.1", 40) ) ], ) clock = task.Clock() query = dns.Query(name=b"example.com", type=dns.A, cls=dns.IN) c = cache.CacheResolver({query: (clock.seconds(), r)}, reactor=clock) # 40 seconds is enough to expire the entry because expiration is based # on the minimum TTL. clock.advance(40) self.assertNotIn(query, c.cache) return self.assertFailure(c.lookupAddress(b"example.com"), dns.DomainError) def test_normalLookup(self): """ When a cache lookup finds a cached entry from 1 second ago, it is returned with a TTL of original TTL minus the elapsed 1 second. """ r = ( [ dns.RRHeader( b"example.com", dns.A, dns.IN, 60, dns.Record_A("127.0.0.1", 60) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 50, dns.Record_A("127.0.0.1", 50) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 40, dns.Record_A("127.0.0.1", 40) ) ], ) clock = task.Clock() c = cache.CacheResolver(reactor=clock) c.cacheResult(dns.Query(name=b"example.com", type=dns.A, cls=dns.IN), r) clock.advance(1) def cbLookup(result): self.assertEqual(result[0][0].ttl, 59) self.assertEqual(result[1][0].ttl, 49) self.assertEqual(result[2][0].ttl, 39) self.assertEqual(result[0][0].name.name, b"example.com") return c.lookupAddress(b"example.com").addCallback(cbLookup) def test_cachedResultExpires(self): """ Once the TTL has been exceeded, the result is removed from the cache. """ r = ( [ dns.RRHeader( b"example.com", dns.A, dns.IN, 60, dns.Record_A("127.0.0.1", 60) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 50, dns.Record_A("127.0.0.1", 50) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 40, dns.Record_A("127.0.0.1", 40) ) ], ) clock = task.Clock() c = cache.CacheResolver(reactor=clock) query = dns.Query(name=b"example.com", type=dns.A, cls=dns.IN) c.cacheResult(query, r) clock.advance(40) self.assertNotIn(query, c.cache) return self.assertFailure(c.lookupAddress(b"example.com"), dns.DomainError) def test_expiredTTLLookup(self): """ When the cache is queried exactly as the cached entry should expire but before it has actually been cleared, the cache does not return the expired entry. """ r = ( [ dns.RRHeader( b"example.com", dns.A, dns.IN, 60, dns.Record_A("127.0.0.1", 60) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 50, dns.Record_A("127.0.0.1", 50) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 40, dns.Record_A("127.0.0.1", 40) ) ], ) clock = task.Clock() # Make sure timeouts never happen, so entries won't get cleared: clock.callLater = lambda *args, **kwargs: None c = cache.CacheResolver( { dns.Query(name=b"example.com", type=dns.A, cls=dns.IN): ( clock.seconds(), r, ) }, reactor=clock, ) clock.advance(60.1) return self.assertFailure(c.lookupAddress(b"example.com"), dns.DomainError) PK y�Z��V� 6 6 test/test_rfc1982.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.names.rfc1982}. """ import calendar from datetime import datetime from functools import partial from twisted.names._rfc1982 import SerialNumber from twisted.trial import unittest class SerialNumberTests(unittest.TestCase): """ Tests for L{SerialNumber}. """ def test_serialBitsDefault(self): """ L{SerialNumber.serialBits} has default value 32. """ self.assertEqual(SerialNumber(1)._serialBits, 32) def test_serialBitsOverride(self): """ L{SerialNumber.__init__} accepts a C{serialBits} argument whose value is assigned to L{SerialNumber.serialBits}. """ self.assertEqual(SerialNumber(1, serialBits=8)._serialBits, 8) def test_repr(self): """ L{SerialNumber.__repr__} returns a string containing number and serialBits. """ self.assertEqual( "<SerialNumber number=123 serialBits=32>", repr(SerialNumber(123, serialBits=32)), ) def test_str(self): """ L{SerialNumber.__str__} returns a string representation of the current value. """ self.assertEqual(str(SerialNumber(123)), "123") def test_int(self): """ L{SerialNumber.__int__} returns an integer representation of the current value. """ self.assertEqual(int(SerialNumber(123)), 123) def test_hash(self): """ L{SerialNumber.__hash__} allows L{SerialNumber} instances to be hashed for use as dictionary keys. """ self.assertEqual(hash(SerialNumber(1)), hash(SerialNumber(1))) self.assertNotEqual(hash(SerialNumber(1)), hash(SerialNumber(2))) def test_convertOtherSerialBitsMismatch(self): """ L{SerialNumber._convertOther} raises L{TypeError} if the other SerialNumber instance has a different C{serialBits} value. """ s1 = SerialNumber(0, serialBits=8) s2 = SerialNumber(0, serialBits=16) self.assertRaises(TypeError, s1._convertOther, s2) def test_eq(self): """ L{SerialNumber.__eq__} provides rich equality comparison. """ self.assertEqual(SerialNumber(1), SerialNumber(1)) def test_eqForeignType(self): """ == comparison of L{SerialNumber} with a non-L{SerialNumber} instance returns L{NotImplemented}. """ self.assertFalse(SerialNumber(1) == object()) self.assertIs(SerialNumber(1).__eq__(object()), NotImplemented) def test_ne(self): """ L{SerialNumber.__ne__} provides rich equality comparison. """ self.assertFalse(SerialNumber(1) != SerialNumber(1)) self.assertNotEqual(SerialNumber(1), SerialNumber(2)) def test_neForeignType(self): """ != comparison of L{SerialNumber} with a non-L{SerialNumber} instance returns L{NotImplemented}. """ self.assertTrue(SerialNumber(1) != object()) self.assertIs(SerialNumber(1).__ne__(object()), NotImplemented) def test_le(self): """ L{SerialNumber.__le__} provides rich <= comparison. """ self.assertTrue(SerialNumber(1) <= SerialNumber(1)) self.assertTrue(SerialNumber(1) <= SerialNumber(2)) def test_leForeignType(self): """ <= comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(1) <= object()) def test_ge(self): """ L{SerialNumber.__ge__} provides rich >= comparison. """ self.assertTrue(SerialNumber(1) >= SerialNumber(1)) self.assertTrue(SerialNumber(2) >= SerialNumber(1)) def test_geForeignType(self): """ >= comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(1) >= object()) def test_lt(self): """ L{SerialNumber.__lt__} provides rich < comparison. """ self.assertTrue(SerialNumber(1) < SerialNumber(2)) def test_ltForeignType(self): """ < comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(1) < object()) def test_gt(self): """ L{SerialNumber.__gt__} provides rich > comparison. """ self.assertTrue(SerialNumber(2) > SerialNumber(1)) def test_gtForeignType(self): """ > comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(2) > object()) def test_add(self): """ L{SerialNumber.__add__} allows L{SerialNumber} instances to be summed. """ self.assertEqual(SerialNumber(1) + SerialNumber(1), SerialNumber(2)) def test_addForeignType(self): """ Addition of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(1) + object()) def test_addOutOfRangeHigh(self): """ L{SerialNumber} cannot be added with other SerialNumber values larger than C{_maxAdd}. """ maxAdd = SerialNumber(1)._maxAdd self.assertRaises( ArithmeticError, lambda: SerialNumber(1) + SerialNumber(maxAdd + 1) ) def test_maxVal(self): """ L{SerialNumber.__add__} returns a wrapped value when s1 plus the s2 would result in a value greater than the C{maxVal}. """ s = SerialNumber(1) maxVal = s._halfRing + s._halfRing - 1 maxValPlus1 = maxVal + 1 self.assertTrue(SerialNumber(maxValPlus1) > SerialNumber(maxVal)) self.assertEqual(SerialNumber(maxValPlus1), SerialNumber(0)) def test_fromRFC4034DateString(self): """ L{SerialNumber.fromRFC4034DateString} accepts a datetime string argument of the form 'YYYYMMDDhhmmss' and returns an L{SerialNumber} instance whose value is the unix timestamp corresponding to that UTC date. """ self.assertEqual( SerialNumber(1325376000), SerialNumber.fromRFC4034DateString("20120101000000"), ) def test_toRFC4034DateString(self): """ L{DateSerialNumber.toRFC4034DateString} interprets the current value as a unix timestamp and returns a date string representation of that date. """ self.assertEqual( "20120101000000", SerialNumber(1325376000).toRFC4034DateString() ) def test_unixEpoch(self): """ L{SerialNumber.toRFC4034DateString} stores 32bit timestamps relative to the UNIX epoch. """ self.assertEqual(SerialNumber(0).toRFC4034DateString(), "19700101000000") def test_Y2106Problem(self): """ L{SerialNumber} wraps unix timestamps in the year 2106. """ self.assertEqual(SerialNumber(-1).toRFC4034DateString(), "21060207062815") def test_Y2038Problem(self): """ L{SerialNumber} raises ArithmeticError when used to add dates more than 68 years in the future. """ maxAddTime = calendar.timegm(datetime(2038, 1, 19, 3, 14, 7).utctimetuple()) self.assertEqual( maxAddTime, SerialNumber(0)._maxAdd, ) self.assertRaises( ArithmeticError, lambda: SerialNumber(0) + SerialNumber(maxAddTime + 1) ) def assertUndefinedComparison(testCase, s1, s2): """ A custom assertion for L{SerialNumber} values that cannot be meaningfully compared. "Note that there are some pairs of values s1 and s2 for which s1 is not equal to s2, but for which s1 is neither greater than, nor less than, s2. An attempt to use these ordering operators on such pairs of values produces an undefined result." @see: U{https://tools.ietf.org/html/rfc1982#section-3.2} @param testCase: The L{unittest.TestCase} on which to call assertion methods. @type testCase: L{unittest.TestCase} @param s1: The first value to compare. @type s1: L{SerialNumber} @param s2: The second value to compare. @type s2: L{SerialNumber} """ testCase.assertFalse(s1 == s2) testCase.assertFalse(s1 <= s2) testCase.assertFalse(s1 < s2) testCase.assertFalse(s1 > s2) testCase.assertFalse(s1 >= s2) serialNumber2 = partial(SerialNumber, serialBits=2) class SerialNumber2BitTests(unittest.TestCase): """ Tests for correct answers to example calculations in RFC1982 5.1. The simplest meaningful serial number space has SERIAL_BITS == 2. In this space, the integers that make up the serial number space are 0, 1, 2, and 3. That is, 3 == 2^SERIAL_BITS - 1. https://tools.ietf.org/html/rfc1982#section-5.1 """ def test_maxadd(self): """ In this space, the largest integer that it is meaningful to add to a sequence number is 2^(SERIAL_BITS - 1) - 1, or 1. """ self.assertEqual(SerialNumber(0, serialBits=2)._maxAdd, 1) def test_add(self): """ Then, as defined 0+1 == 1, 1+1 == 2, 2+1 == 3, and 3+1 == 0. """ self.assertEqual(serialNumber2(0) + serialNumber2(1), serialNumber2(1)) self.assertEqual(serialNumber2(1) + serialNumber2(1), serialNumber2(2)) self.assertEqual(serialNumber2(2) + serialNumber2(1), serialNumber2(3)) self.assertEqual(serialNumber2(3) + serialNumber2(1), serialNumber2(0)) def test_gt(self): """ Further, 1 > 0, 2 > 1, 3 > 2, and 0 > 3. """ self.assertTrue(serialNumber2(1) > serialNumber2(0)) self.assertTrue(serialNumber2(2) > serialNumber2(1)) self.assertTrue(serialNumber2(3) > serialNumber2(2)) self.assertTrue(serialNumber2(0) > serialNumber2(3)) def test_undefined(self): """ It is undefined whether 2 > 0 or 0 > 2, and whether 1 > 3 or 3 > 1. """ assertUndefinedComparison(self, serialNumber2(2), serialNumber2(0)) assertUndefinedComparison(self, serialNumber2(0), serialNumber2(2)) assertUndefinedComparison(self, serialNumber2(1), serialNumber2(3)) assertUndefinedComparison(self, serialNumber2(3), serialNumber2(1)) serialNumber8 = partial(SerialNumber, serialBits=8) class SerialNumber8BitTests(unittest.TestCase): """ Tests for correct answers to example calculations in RFC1982 5.2. Consider the case where SERIAL_BITS == 8. In this space the integers that make up the serial number space are 0, 1, 2, ... 254, 255. 255 == 2^SERIAL_BITS - 1. https://tools.ietf.org/html/rfc1982#section-5.2 """ def test_maxadd(self): """ In this space, the largest integer that it is meaningful to add to a sequence number is 2^(SERIAL_BITS - 1) - 1, or 127. """ self.assertEqual(SerialNumber(0, serialBits=8)._maxAdd, 127) def test_add(self): """ Addition is as expected in this space, for example: 255+1 == 0, 100+100 == 200, and 200+100 == 44. """ self.assertEqual(serialNumber8(255) + serialNumber8(1), serialNumber8(0)) self.assertEqual(serialNumber8(100) + serialNumber8(100), serialNumber8(200)) self.assertEqual(serialNumber8(200) + serialNumber8(100), serialNumber8(44)) def test_gt(self): """ Comparison is more interesting, 1 > 0, 44 > 0, 100 > 0, 100 > 44, 200 > 100, 255 > 200, 0 > 255, 100 > 255, 0 > 200, and 44 > 200. """ self.assertTrue(serialNumber8(1) > serialNumber8(0)) self.assertTrue(serialNumber8(44) > serialNumber8(0)) self.assertTrue(serialNumber8(100) > serialNumber8(0)) self.assertTrue(serialNumber8(100) > serialNumber8(44)) self.assertTrue(serialNumber8(200) > serialNumber8(100)) self.assertTrue(serialNumber8(255) > serialNumber8(200)) self.assertTrue(serialNumber8(100) > serialNumber8(255)) self.assertTrue(serialNumber8(0) > serialNumber8(200)) self.assertTrue(serialNumber8(44) > serialNumber8(200)) def test_surprisingAddition(self): """ Note that 100+100 > 100, but that (100+100)+100 < 100. Incrementing a serial number can cause it to become "smaller". Of course, incrementing by a smaller number will allow many more increments to be made before this occurs. However this is always something to be aware of, it can cause surprising errors, or be useful as it is the only defined way to actually cause a serial number to decrease. """ self.assertTrue(serialNumber8(100) + serialNumber8(100) > serialNumber8(100)) self.assertTrue( serialNumber8(100) + serialNumber8(100) + serialNumber8(100) < serialNumber8(100) ) def test_undefined(self): """ The pairs of values 0 and 128, 1 and 129, 2 and 130, etc, to 127 and 255 are not equal, but in each pair, neither number is defined as being greater than, or less than, the other. """ assertUndefinedComparison(self, serialNumber8(0), serialNumber8(128)) assertUndefinedComparison(self, serialNumber8(1), serialNumber8(129)) assertUndefinedComparison(self, serialNumber8(2), serialNumber8(130)) assertUndefinedComparison(self, serialNumber8(127), serialNumber8(255)) PK y�Z!/ӏ� � + test/__pycache__/test_names.cpython-310.pycnu �[��� o �b^� � @ s� d Z ddlZddlZddlZddlmZmZ ddlmZ ddl m Z ddl m Z m Z mZ ddlmZ ddlmZmZmZmZmZ dd lmZ dd lmZmZm Z m Z m Z m Z dd l m!Z! dd l"m#Z#m$Z$ dd l%m&Z& ddl'm(Z( ddl)m*Z*m+Z+m,Z, ddl-m.Z. dd� Z/G dd� dej0�Z1ej dddddddd d �Z2ej d d d d d!d"d#d$d �Z3ej d%d&d'd(d d)dd*�Z4e1de2fe2e� d+�e�5d,�e�6d-�e�6d.d/�e�7d0d1�ej8d2d3d4�e�9d5�e�:d6�e�;d7�e�<d8d9�e�=dd:d;�e�=d<d=d>�e�=d?d@dA�e�<dB�e�>dC�ej?dDdEdF�ej@d dGdH�ejAdIdJdK�e�BdLejCdM�e�Ddd0dNdOdP�e�EdQ�ge�FdRdSdTdU�ge� dV�e� dW�ge� dX�e� dY�ge�9d�ge� dZ�gd[�d\�ZGe1d e3fd]e�Hd^�e3gid\�ZIe1d_e4fd_e4ej dZd`da�ej5dbdcda�ej5dddeda�ejFdRdSdTdUdfda�gid\�ZJG dgdh� dhe.jK�ZLG didj� dje.jK�ZMG dkdl� dle.jK�ZNG dmdn� dne.jK�ZOG dodp� dpe.jK�ZPG dqdr� dre.jK�ZQG dsdt� dte.jK�ZRG dudv� dve.jK�ZSG dwdx� dxe.jK�ZTdyZUG dzd{� d{e.jK�ZVd|ZWG d}d~� d~e.jK�ZXdS )z Test cases for twisted.names. � N)�partial�reduce)�BytesIO)�pack)�defer�error�reactor)�succeed)� authority�client�common�dns�server)�Resolver)�SOA�Message�Query�Record_A� Record_SOA�RRHeader)� DomainError)�SecondaryAuthority�SecondaryAuthorityService)� nativeString)�FilePath)�MemoryReactorClock�StringTransport�waitUntilAllDisconnected)�unittestc C s dd� | d D �S )Nc S s g | ]}|j �qS � ��payload��.0�rr r �?/usr/lib/python3/dist-packages/twisted/names/test/test_names.py� <listcomp>" � z justPayload.<locals>.<listcomp>r r ��resultsr r r% � justPayload! s r* c @ � e Zd Zdd� ZdS )�NoFileAuthorityc C s t j�| � ||| _| _d S �N)r � ResolverBase�__init__�soa�records)�selfr0 r1 r r r% r/ & s zNoFileAuthority.__init__N)�__name__� __module__� __qualname__r/ r r r r% r, % � r, � test-domain.comzroot.test-domain.com�d �� i� �H?&� � ��mname�rname�serial�refresh�minimum�expire�retry�ttls 93.84.28.in-addr.arpa�x i1� i~ �Ϊ � � � my-domain.coms postmaster.test-domain.com� i90 i?B )r> r? r@ rA rB rC rD s 127.0.0.1s 39.28.189.39�# v=spf1 mx/30 mx:example.org/30 -all� v=spf1 +mx a: colo� .example.com/28 -all not valid� �host.test-domain.com� Linux� A Fast One, Dontcha know)�os�cpus canonical.name.coms mailbox.test-domain.coms mail.group.someplace� A First piece of Text� a SecoNd pieces ABCD::4321� � s 0:0069::0s some.network.tld� s$ 0:5634:1294:AFCB:56AC:48EF:34C3:01FFs tra.la.la.net�+ Some more text, haha! Yes. Still here?s mail.redirect.or.whatevers r mail boxs e mail box)�rmailbx�emailbxs afsdb.test-domain.com)�subtype�hostnames whatever.i.dunnos some.more.text)�mbox�txts 12.54.78.12� �� � u� sip+E2U�! !^.*$!sip:information@domain.tld!s' AF43:5634:1294:AFCB:56AC:48EF:34C3:01FF� �? 骪 s some.other.place.fool� 123.242.1.5� 0.255.0.255s 255.255.255.254s 0.0.0.0s 1.2.3.4)r7 s http.tcp.test-domain.com� host.test-domain.coms host-two.test-domain.coms cname.test-domain.coms anothertest-domain.com�r0 r1 s 123.93.84.28.in-addr.arpas test.host-reverse.lookup.coms my-domain.com�1S�rE s ns1.domains 2Ms ns2.domain�3H�4Dc @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<S )=�ServerDNSTestsz/ Test cases for DNS server and client. c C s� t jtttgdd�| _t�| j�} tj d| jdd�}| � |j � |� � j }z tj||dd�}W n tjy: Y nw | � |j � nq|| _|| _tjd|fgd�| _d S )N� )�verboser< r � 127.0.0.1)� interface��servers)r �DNSServerFactory�test_domain_com�reverse_domain� my_domain_com�factoryr �DNSDatagramProtocolr � listenTCP� addCleanup� stopListening�getHost�port� listenUDPr �CannotListenError� listenerTCP� listenerUDPr r �resolver)r2 �pr� r� r� r r r% �setUp� s& � � �zServerDNSTests.setUpc C s6 | j jdd� D ]}|j�� qtt| j jdd� �S )zu Clean up any server connections associated with the L{DNSServerFactory} created in L{setUp} N)r{ � connections� transport�loseConnectionr r )r2 �connr r r% �tearDown� s zServerDNSTests.tearDownc s � �fdd�}|� |� |S )aD Assert that the DNS response C{querying} will eventually fire with contains exactly a certain collection of records. @param querying: A L{Deferred} returned from one of the DNS client I{lookup} methods. @param expectedRecords: A L{list} of L{IRecord} providers which must be in the response or the test will be failed. @return: A L{Deferred} that fires when the assertion has been made. It fires with a success result if the assertion succeeds and with a L{Failure} if it fails. c s t | �}��t� �t|�� d S r- )r* � assertEqual�set)�response�receivedRecords��expectedRecordsr2 r r% � checkResults� s z.ServerDNSTests.namesTest.<locals>.checkResults)� addCallback)r2 �queryingr� r� r r� r% � namesTest� s zServerDNSTests.namesTestc C � | � | j�d�tjddd�g�S )z"Test simple DNS 'A' record queries�test-domain.comrs r: rm �r� r� � lookupAddressr r �r2 r r r% �test_addressRecord1� � �z"ServerDNSTests.test_addressRecord1c C �, | � | j�d�tjddd�tjddd�g�S )z1Test DNS 'A' record queries with multiple answersrP z 123.242.1.5r: rm z 0.255.0.255r� r� r r r% �test_addressRecord2� � ��z"ServerDNSTests.test_addressRecord2c C r� )z+Test DNS 'A' record queries with edge caseszhost-two.test-domain.comz255.255.255.254r: rm �0.0.0.0r� r� r r r% �test_addressRecord3� r� z"ServerDNSTests.test_addressRecord3c C s | � | j�d�tg�S )z Test DNS 'SOA' record queriesr� )r� r� �lookupAuthority� soa_recordr� r r r% �test_authority� s �z ServerDNSTests.test_authorityc C s: | � | j�d�tjdddd�tjddd�tjddd�g�S )z� The DNS client can issue an MX query and receive a response including an MX record as well as any A record hints. r7 rO rj r: rm rh ri )r� r� �lookupMailExchanger � Record_MXr r� r r r% �test_mailExchangeRecord s ��z&ServerDNSTests.test_mailExchangeRecordc C r� )z Test DNS 'NS' record queriesr� z 39.28.189.39r: rm )r� r� �lookupNameserversr � Record_NSr� r r r% �test_nameserver r� z ServerDNSTests.test_nameserverc C �" | � | j�d�tjdddd�g�S )z Test DNS 'HINFO' record queriesr� rQ rR r: )rS rT rE )r� r� �lookupHostInfor � Record_HINFOr� r r r% � test_HINFO � ���zServerDNSTests.test_HINFOc C r� )z Test DNS 'PTR' record queriesz123.93.84.28.in-addr.arpaz test.host-reverse.lookup.comrG rm )r� r� � lookupPointerr � Record_PTRr� r r r% �test_PTR r� zServerDNSTests.test_PTRc C r� )z Test DNS 'CNAME' record queriesr� zcanonical.name.comr: rm )r� r� �lookupCanonicalNamer � Record_CNAMEr� r r r% � test_CNAME' r� zServerDNSTests.test_CNAMEc C r� )z Test DNS 'MB' record queriesr� zmailbox.test-domain.comr: rm )r� r� � lookupMailBoxr � Record_MBr� r r r% �test_MB. r� zServerDNSTests.test_MBc C r� )z Test DNS 'MG' record queriesr� zmail.group.someplacer: rm )r� r� �lookupMailGroupr � Record_MGr� r r r% �test_MG5 r� zServerDNSTests.test_MGc C r� )z Test DNS 'MR' record queriesr� zmail.redirect.or.whateverr: rm )r� r� �lookupMailRenamer � Record_MRr� r r r% �test_MR< r� zServerDNSTests.test_MRc C r� )z Test DNS 'MINFO' record queriesr� z r mail boxz e mail boxr: )r[ r\ rE )r� r� �lookupMailboxInfor � Record_MINFOr� r r r% � test_MINFOC r� zServerDNSTests.test_MINFOc C s& | � | j�d�tjdddddd�g�S )z Test DNS 'SRV' record querieszhttp.tcp.test-domain.comre rf rg �some.other.place.foolr: rm )r� r� � lookupServicer � Record_SRVr� r r r% �test_SRVN s �zServerDNSTests.test_SRVc C r� )z Test DNS 'AFSDB' record queriesr� r< zafsdb.test-domain.comr: )r] r^ rE )r� r� �lookupAFSDatabaser � Record_AFSDBr� r r r% � test_AFSDBU r� zServerDNSTests.test_AFSDBc C r� )z Test DNS 'RP' record queriesr� zwhatever.i.dunnozsome.more.textr: )r_ r` rE )r� r� �lookupResponsibilityr � Record_RPr� r r r% �test_RP` r� zServerDNSTests.test_RPc C s. | � | j�d�tjdddd�tjddd�g�S )z Test DNS 'TXT' record queriesr� rU rV r: rm rZ )r� r� � lookupTextr � Record_TXTr� r r r% �test_TXTk s ����zServerDNSTests.test_TXTc C s. | � | j�d�tjddd�tjdddd�g�S )zH L{DNSServerFactory} can serve I{SPF} resource records. r� rL r: rm rM rN )r� r� �lookupSenderPolicyr � Record_SPFr� r r r% �test_spfy s ���zServerDNSTests.test_spfc C s& | � | j�d�tjdtjddd�g�S )z Test DNS 'WKS' record queriesr� z 12.54.78.12ra r: rm )r� r� �lookupWellKnownServicesr � Record_WKS�socket� IPPROTO_TCPr� r r r% �test_WKS� s ���zServerDNSTests.test_WKSc C s^ t � t�}tj|_| �| j�d�|tjddd�tj ddd�tj ddd�tj d d d d d d�g�S )NrJ �1.2.3.4rl rm z ns1.domain�2Mz ns2.domainrn re rf rg r� ro ) �copy�my_soarC rE r� r� �lookupAllRecordsr r r� r� )r2 � result_soar r r% �test_someRecordsWithTTLs� s ��z'ServerDNSTests.test_someRecordsWithTTLsc C r� )z%Test DNS 'AAAA' record queries (IPv6)r� z'AF43:5634:1294:AFCB:56AC:48EF:34C3:01FFr: rm )r� r� �lookupIPV6Addressr � Record_AAAAr� r r r% � test_AAAA� r� zServerDNSTests.test_AAAAc C sD | � | j�d�tjddddd�tjddd dd�tjd d d dd�g�S ) z#Test DNS 'A6' record queries (IPv6)r� r z ABCD::4321� r: rm rX z 0:0069::0zsome.network.tldrY z$0:5634:1294:AFCB:56AC:48EF:34C3:01FFz tra.la.la.net)r� r� �lookupAddress6r � Record_A6r� r r r% �test_A6� s ���zServerDNSTests.test_A6c C sZ t j}dd� ttjtj�� �D �}|D ] }|jdu r ||_q| � | j � d�� dd� �|�S )z9 Test DNS 'AXFR' queries (Zone transfer) c S s g | ]}t � |��qS r )r� r" r r r% r& � s �z4ServerDNSTests.test_zoneTransfer.<locals>.<listcomp>Nr� c S s | d d d� fS )Nr ���r )r$ r r r% �<lambda>� r' z2ServerDNSTests.test_zoneTransfer.<locals>.<lambda>) r� rC r �operator�addrx r1 �valuesrE r� r� � lookupZoner� )r2 � default_ttlr) r$ r r r% �test_zoneTransfer� s � � ��z ServerDNSTests.test_zoneTransferc C s t dgd�}| �|�d�tj�S )zu A failed AXFR TCP connection errbacks the L{Deferred} returned from L{Resolver.lookupZone}. )znameserver.invalid�5 ru zimpossible.invalid)r � assertFailurer� r �DNSLookupError)r2 r� r r r% � test_zoneTransferConnectionFails� s �z/ServerDNSTests.test_zoneTransferConnectionFailsc C r� )z6Tests that unrelated zones don't mess with each other.zanothertest-domain.comr� r: rm r� r� r r r% � test_similarZonesDontInterfere� r� z-ServerDNSTests.test_similarZonesDontInterferec C s( | � | j�d�tjddddddd�g�S ) z2 Test DNS 'NAPTR' record queries. r� r8 rO rb rc rd r: rm )r� r� � lookupNamingAuthorityPointerr � Record_NAPTRr� r r r% � test_NAPTR� s ���zServerDNSTests.test_NAPTRN)!r3 r4 r5 �__doc__r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r% rp � s> rp c @ r+ )� HelperTestsc C s@ | � � }t�|�}td�D ]}t�|�}| �||k � |}q d S )N� )�mktempr � getSerial�range� assertTrue)r2 �f�a�i�br r r% �test_serialGenerator� s �z HelperTests.test_serialGeneratorN)r3 r4 r5 r r r r r% r� � r6 r� c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) � AXFRTestsc C s� d | _ t�� | _| j�| j� t�d| j�| _t j dt j t j ddt j ddddddd d d �d �| _| jt j dt jt j d dt jdd d�d �t j dt jt j d dt jddd d�d �t j dt jt j d dt jdd d�d �| jg| _d S )N� fooby.comi�Q Fzhooj.fooby.comr8 �� i, i� i� iX )r> r? r@ rA rD rC rB rE ��name�type�clsrE �authr! � �ns.twistedmatrix.com�r rE rO z mail.mv3d.com)� preference�exchangerE z 64.123.27.105)�addressrE )r) r �Deferred�dr� � _gotResultsr �AXFRController� controllerr r r �INr r0 �NSr� �MXr� �Ar r1 r� r r r% r� � s` �� �� � �zAXFRTests.setUpc C s t jdddddddddd� S )N�� r< r � �id�answer�opCode�recDes�recAvr �rCode�trunc�maxSize)r r r� r r r% � _makeMessage2 s �zAXFRTests._makeMessagec C sH | � � }t�dtjtj�g|_| j|_| j� |d � | � | j | j� d S )Nr ) r$ r r �AXFRr �queriesr1 �answersr �messageReceivedr� r) )r2 �mr r r% �test_bindAndTNamesStyle@ s z!AXFRTests.test_bindAndTNamesStylec C s || _ d S r- r( )r2 �resultr r r% r H s zAXFRTests._gotResultsc C sT | j d d � }|r | �� }g |_|�d�g|_| j�|d � |s | �| j| j � d S �Nr ) r1 r$ r& �popr' r r( r� r) )r2 r1 r) r r r% � test_DJBStyleK s �zAXFRTests.test_DJBStyleN)r3 r4 r5 r� r$ r* r r. r r r r% r � s 5 r c @ s e Zd Zdd� Zdd� ZdS )�ResolvConfHandlingTestsc C s2 | � � }tj|d�}| �|jdg� |j�� d S )N��resolv�rs r� )r� r r r� � dynServers� _parseCall�cancel�r2 � resolvConfr$ r r r% � test_missingW s z$ResolvConfHandlingTests.test_missingc C s@ | � � }t|d��� tj|d�}| �|jdg� |j�� d S )N�wr0 r2 ) r� �open�closer r r� r3 r4 r5 r6 r r r% � test_empty] s z"ResolvConfHandlingTests.test_emptyN)r3 r4 r5 r8 r< r r r r% r/ V s r/ c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�AuthorityTestszs Tests for the basic response record selection code in L{FileAuthority} (independent of its fileness). c C s4 t }d|jd }| �|�|��}| �|jt� dS )aJ L{FileAuthority} lookup methods errback with L{DomainError} if the requested C{name} shares a common suffix with its zone but is not actually a descendant of its zone, in terms of its sequence of DNS name labels. eg www.the-example.com has nothing to do with the zone example.com. � nonexistent.prefix-r N)rx r0 �failureResultOfr� �assertIsInstance�valuer )r2 � testDomain�testDomainNamer� r r r% �'test_domainErrorForNameWithCommonSuffixk s z6AuthorityTests.test_domainErrorForNameWithCommonSuffixc C s� t tjjtftjjtt�d�gid�}| �|�tjj��\}}}| �|g � | �|tj tjjtj tj tdd�g� | �|g � dS )a! If a L{FileAuthority} has a zone which includes an I{NS} record for a particular name and that authority is asked for another record for the same name which does not exist, the I{NS} record is not included in the authority section of the response. r� rk T�rE r! r N) r, r� r> r r r� �successResultOfr� r� r �TYPErC )r2 r r � additionalr r r% �test_recordMissingx s0 ��� � ��� z!AuthorityTests.test_recordMissingc C sJ t }d|jd }ttj�d }| �|�t||d���}| �|j t � dS )z� Requesting a record of unknown type where no records exist for the name in question results in L{DomainError}. r> r r< �r r N) rx r0 �maxr � typeToMethodr? �queryr r@ rA r )r2 rB rC � unknownTyper� r r r% �test_unknownTypeNXDOMAIN� s �z'AuthorityTests.test_unknownTypeNXDOMAINc C s< t tj�d }| �t�td|d���\}}}| �|g � dS )z� Requesting a record of unknown type where other records exist for the name in question results in an empty answer set. r< rJ rJ N)rK r rL rF rz rM r r� )r2 rN r r rH r r r% �test_unknownTypeMissing� s �z&AuthorityTests.test_unknownTypeMissingc C s� dt jj }t�d�}tt jjt f||gid�}t||�|�}| �|�\}}}| �|g � | �|tj |tj t j |dd�g� | �|g � dS )z� Create an authority and make a request against it. Then verify that the result is a referral, including no records in the answers or additional sections, but with an I{NS} record in the authority section. s example.r� rk FrE N) r� r> r r r� r, �getattrrF r� r r rC )r2 �method� subdomain� nameserverr r r rH r r r% � _referralTest� s0 ��� ��� z AuthorityTests._referralTestc C � | � d� dS )a When an I{NS} record is found for a child zone, it is included in the authority section of the response. It is marked as non-authoritative if the authority is not also authoritative for the child zone (RFC 2181, section 6.1). r� N�rU r� r r r% � test_referral� s z AuthorityTests.test_referralc C rV )zT A referral is also generated for a request of type C{ALL_RECORDS}. r� NrW r� r r r% �test_allRecordsReferral� s z&AuthorityTests.test_allRecordsReferralN) r3 r4 r5 r� rD rI rO rP rU rX rY r r r r% r= e s " ! r= c @ s� e Zd ZdZe�d�Ze�d�Zdd� Z dd� Z dd � Z d d � Z d d � Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�AdditionalProcessingTestszz Tests for L{FileAuthority}'s additional processing for those record types which require it (MX, CNAME, etc). s 10.0.0.1s f080::1c C s8 t |jj|f|jj||�g||id�}t||�tjj�S )a Perform a DNS lookup against a L{FileAuthority} configured with records as defined by C{makeRecord} and C{addresses}. @param method: The name of the lookup method to use; for example, C{"lookupNameservers"}. @type method: L{str} @param soa: A L{Record_SOA} for the zone for which the L{FileAuthority} is authoritative. @param makeRecord: A one-argument callable which accepts a name and returns an L{IRecord} provider. L{FileAuthority} is constructed with this record. The L{FileAuthority} is queried for a record of the resulting type with the given name. @param target: The extra name which the record returned by C{makeRecord} will be pointed at; this is the name which might require extra processing by the server so that all the available, useful information is returned. For example, this is the target of a CNAME record or the mail exchange host pointed to by an MX record. @type target: L{bytes} @param addresses: A L{list} of records giving addresses of C{target}. @return: A L{Deferred} that fires with the result of the resolver method give by C{method}. rk )r, r> r rQ r� )r2 rR r0 � makeRecord�target� addressesr r r r% �_lookupSomeRecords� s ��z,AdditionalProcessingTests._lookupSomeRecordsc C s( dd� }| � t||d�t||d�� dS )a Assert that the L{RRHeader} instances given by C{expected} and C{computed} carry all the same information but without requiring the records appear in the same order. @param expected: A L{list} of L{RRHeader} instances giving the expected records. @param computed: A L{list} of L{RRHeader} instances giving the records computed by the scenario under test. @raise self.failureException: If the two collections of records disagree. c S s | j S r- )r )�rrr r r% r� $ s z>AdditionalProcessingTests.assertRecordsMatch.<locals>.<lambda>)�keyN)r� �sorted)r2 �expected�computedr` r r r% �assertRecordsMatch s z,AdditionalProcessingTests.assertRecordsMatchc sL dt jj � | �|t |� |�}| �|�\}}}| �� fdd�|D �|� dS )aT Verify that certain address records are included in the I{additional} section of a response generated by L{FileAuthority}. @param method: See L{_lookupSomeRecords} @param makeRecord: See L{_lookupSomeRecords} @param addresses: A L{list} of L{IRecord} providers which the I{additional} section of the response is required to match (ignoring order). @raise self.failureException: If the I{additional} section of the response consists of different records than those given by C{addresses}. s mail.c �$ g | ]}t j� |jtj|d d��qS �TrE �r r rG r� rC �r# r �r\ r r% r& = � ���z=AdditionalProcessingTests._additionalTest.<locals>.<listcomp>N)r� r> r r^ rF rd )r2 rR r[ r] r r r rH r ri r% �_additionalTest' s � �z)AdditionalProcessingTests._additionalTestc C s | � dttjd�|� dS )z� Verify that a response to an MX query has certain records in the I{additional} section. @param addresses: See C{_additionalTest} r� rO N)rk r r r� �r2 r] r r r% �_additionalMXTestJ s �z+AdditionalProcessingTests._additionalMXTestc C � | � | jg� dS )z� If the name of the MX response has A records, they are included in the additional section of the response. N)rm �_Ar� r r r% � test_mailExchangeAdditionalAU � z6AdditionalProcessingTests.test_mailExchangeAdditionalAc C rn )z� If the name of the MX response has AAAA records, they are included in the additional section of the response. N)rm �_AAAAr� r r r% � test_mailExchangeAdditionalAAAA\ rq z9AdditionalProcessingTests.test_mailExchangeAdditionalAAAAc C � | � | j| jg� dS )z� If the name of the MX response has both A and AAAA records, they are all included in the additional section of the response. N)rm ro rr r� r r r% � test_mailExchangeAdditionalBothc � z9AdditionalProcessingTests.test_mailExchangeAdditionalBothc C s | � dtj|� dS )z� Verify that a response to an NS query has certain records in the I{additional} section. @param addresses: See C{_additionalTest} r� N)rk r r� rl r r r% �_additionalNSTestj s z+AdditionalProcessingTests._additionalNSTestc C rn )z� If the name of the NS response has A records, they are included in the additional section of the response. N)rw ro r� r r r% �test_nameserverAdditionalAs rq z4AdditionalProcessingTests.test_nameserverAdditionalAc C rn )z� If the name of the NS response has AAAA records, they are included in the additional section of the response. N)rw rr r� r r r% � test_nameserverAdditionalAAAAz rq z7AdditionalProcessingTests.test_nameserverAdditionalAAAAc C rt )z� If the name of the NS response has both A and AAAA records, they are all included in the additional section of the response. N)rw ro rr r� r r r% � test_nameserverAdditionalBoth� rv z7AdditionalProcessingTests.test_nameserverAdditionalBothc sv dt jj � | �dt tj� |�}| �|�\}}}tjt jjtjt j t�� �dd�}| � � fdd�|D �|g |� dS )z� Verify that a response to a CNAME query has certain records in the I{answer} section. @param addresses: See C{_additionalTest} s www.r� TrE c re rf rg rh ri r r% r& � rj z>AdditionalProcessingTests._answerCNAMETest.<locals>.<listcomp>N) r� r> r r^ r r� rF r �CNAMErC rd )r2 r] r r r rH �aliasr ri r% �_answerCNAMETest� s( �� � � �z*AdditionalProcessingTests._answerCNAMETestc C rn )z� If the name of the CNAME response has A records, they are included in the answer section of the response. N)r} ro r� r r r% �test_canonicalNameAnswerA� rq z3AdditionalProcessingTests.test_canonicalNameAnswerAc C rn )z� If the name of the CNAME response has AAAA records, they are included in the answer section of the response. N)r} rr r� r r r% � test_canonicalNameAnswerAAAA� rq z6AdditionalProcessingTests.test_canonicalNameAnswerAAAAc C rt )z� If the name of the CNAME response has both A and AAAA records, they are all included in the answer section of the response. N)r} ro rr r� r r r% � test_canonicalNameAnswerBoth� rv z6AdditionalProcessingTests.test_canonicalNameAnswerBothN)r3 r4 r5 r� r r ro r� rr r^ rd rk rm rp rs ru rw rx ry rz r} r~ r r� r r r r% rZ � s& &# # rZ c @ r+ )�NoInitialResponseTestsc s� � fdd�}dd� }t dgd�}||_g � | �tjd|� tjdtjtjd d tjd d d �d �g}tj dddddddddd� }||_ � � |� | � |� d�tj�S )z� If a request returns a L{dns.NS} response, but we can't connect to the given server, the request fails with the error returned at connection. c s t � �d��S r, )r r- )r2 �args��messagesr r% rM � s z3NoInitialResponseTests.test_noAnswer.<locals>.queryc _ s t �t�d��S )NzCouldn't connect)r �failr� �gaierror)r2 r� �kwargsr r r% � queryProtocol� � z;NoInitialResponseTests.test_noAnswer.<locals>.queryProtocol)r� r ru rM z fooba.comr Fr r r r r< r r r )r �_query�patchr r| r r r r� r r' �appendr� � getHostByNamer� r� )r2 rM r� r� r1 r) r r� r% � test_noAnswer� s: �� � z$NoInitialResponseTests.test_noAnswerN)r3 r4 r5 r� r r r r% r� � r6 r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � SecondaryAuthorityServiceTestsz� Tests for L{SecondaryAuthorityService}, a service which keeps one or more authorities up to date by doing zone transfers from a master. c C s� d}t |ddg�}| �|j|� | �|jd� | �|jd j|� | �|jd jd� | �|jd jd� | �|jd j|� | �|jd jd� | �|jd jd� dS ) a L{SecondaryAuthorityService} can be constructed with a C{str} giving a master server address and several domains, causing the creation of a secondary authority for each domain and that master server address and the default DNS port. � 192.168.1.2� example.comz example.orgr� r r< s example.orgN)r r� �primary�_port�domains�domain�r2 r� �servicer r r% � test_constructAuthorityFromHost� s z>SecondaryAuthorityServiceTests.test_constructAuthorityFromHostc C s� d}d}t �||fddg�}| �|j|� | �|jd� | �|jd j|� | �|jd j|� | �|jd jd� | �|jd j|� | �|jd j|� | �|jd jd� dS ) a\ L{SecondaryAuthorityService.fromServerAddressAndDomains} constructs a new L{SecondaryAuthorityService} from a C{str} giving a master server address and DNS port and several domains, causing the creation of a secondary authority for each domain and that master server address and the given DNS port. � 192.168.1.3i� z example.net� example.edur � example.netr< N)r �fromServerAddressAndDomainsr� r� r� r� r� )r2 r� r� r� r r r% �&test_constructAuthorityFromHostAndPort s �zESecondaryAuthorityServiceTests.test_constructAuthorityFromHostAndPortc C sx d}t |�� ddg�}| �|j|� | �|jd j|� | �|jd jd� | �|jd j|� | �|jd jd� dS )aQ L{SecondaryAuthorityService.fromServerAddressAndDomains} constructs a new L{SecondaryAuthorityService} from a C{bytes} giving a master server address and several domains, causing the creation of a secondary authority for each domain and that master server address and the given DNS port. r� r� z example.edur r< r� N)r �encoder� r� r� r� r� r r r% � test_constructAuthorityFromBytes# s �z?SecondaryAuthorityServiceTests.test_constructAuthorityFromBytesN)r3 r4 r5 r� r� r� r� r r r r% r� � s r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �SecondaryAuthorityTestsz� L{twisted.names.secondary.SecondaryAuthority} correctly constructs objects with a specified IP address and optionally specified DNS port. c C s8 t dd�}| �|jd� | �|jd� | �|jd� dS )zp When constructed using L{SecondaryAuthority.__init__}, the default port of 53 is used. � 192.168.1.1� inside.comr� � inside.comN)r r� r� r� r� �r2 � secondaryr r r% �test_defaultPort? s z(SecondaryAuthorityTests.test_defaultPortc C s: t �dd�}| �|jd� | �|jd� | �|jd� dS )z~ When constructed using L{SecondaryAuthority.fromServerAddressAndDomain}, the specified port is used. )r� �� r� r� r� r� N)r �fromServerAddressAndDomainr� r� r� r� r� r r r% �test_explicitPortI s �z)SecondaryAuthorityTests.test_explicitPortc C s� t �dd�}t� |_}|�� |j�d�\}}}}}| �|d� | �|d� |�||f�}t � } |� | � t � } | � t | �� dd� �� | �t�dtjtj�g| j� dS )z� An attempt is made to transfer the zone for the domain the L{SecondaryAuthority} was constructed with from the server address it was constructed with when L{SecondaryAuthority.transfer} is called. �r� r9 � example.comr r� r9 rq N)r r� r �_reactor�transfer� tcpClientsr- r� � buildProtocolr �makeConnectionr �decoder rA r r r% r r& ) r2 r� r �hostr� r{ �timeout� bindAddress�protor� �msgr r r% � test_transferU s � "z%SecondaryAuthorityTests.test_transferc C s. t �dd�}t� |_}|�� |j�d�\}}}}}|�||f�}t� } |� | � t ddd�} | � t | � � dd� �� tdd d d d d ddd�} tddd�} t | jddd�} | j�tdt| d�td| d�tdt| d�g� | �� }|�tdt|��| � | �|�d��}| �td| dd�gg g f|� dS )z� L{SecondaryAuthority.lookupAddress} returns a L{Deferred} that fires with the I{A} records the authority has cached from the primary. r� r� r r< )r r rq Ns ns1.example.comzadmin.example.comi@� i i� i i�% i�. r= s 192.168.1.2rm )r r r )r r! r z!Hr� T)r! r ) r r� r r� r� r� r- r� r r� r r� r rA r r r r' �extendr r �toStr� dataReceivedr �lenrF r� r� )r2 r� r r� r� r{ r� r� r� r� rM r0 r� r �datar+ r r r% �test_lookupAddresss sF � � ���z*SecondaryAuthorityTests.test_lookupAddressN)r3 r4 r5 r� r� r� r� r� r r r r% r� 9 s r� sY $ORIGIN example.com. $TTL 1w example.com. IN SOA dns.example.com ( 2013120201 ; serial number of this zone file 1d ; slave refresh 2h ; slave retry time in case of a problem 4w ; slave expiration time 1h ; maximum caching time in case of failed lookups ) ; A comment. @ IN AAAA 2001:db8:10::1 example.com. IN A 10.0.0.1 no-in.example.com. A 10.0.0.2 ; technically wrong but used to work not-fqdn IN MX 10 mx.example.com www IN CNAME example.comc @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )�BindAuthorityTestsz= Tests for L{twisted.names.authority.BindAuthority}. c C s( t | �� �d��}|�|� t�|j�S )z� Create a new L{twisted.names.authority.BindAuthority} from C{s}. @param s: A string with BIND zone data. @type s: bytes @return: a new bind authority @rtype: L{twisted.names.authority.BindAuthority} �ascii)r r� r� � setContentr � BindAuthority�path)r2 �s�fpr r r% �loadBindString� s z!BindAuthorityTests.loadBindStringc C � | � t�| _d S r- )r� �sampleBindZoner r� r r r% r� � r� zBindAuthorityTests.setUpc C s8 | j j�� D ]}| j j| D ] }| �d|jk� qqdS )zG Loads the default $TTL and applies it to all records. �: N)r r1 �keysr� rE )r2 �dom�recr r r% �test_ttl� s ��zBindAuthorityTests.test_ttlc C s$ | � d| jj� | �d| jj� dS )z, Loads the default $ORIGIN. s example.com.� not-fqdn.example.comN)r� r �origin�assertInr1 r� r r r% �test_originFromFile� s ��z&BindAuthorityTests.test_originFromFilec C sB dD ] \}}| � | j�|��\\}\ \ | �t�|d�|j� qdS )�' A records are loaded. �)r� z10.0.0.1)� no-in.example.comz10.0.0.2r� N�rF r r� r� r r r! �r2 r� �ipr_ r r r% � test_aRecords� s ���z BindAuthorityTests.test_aRecordsc C s4 | � | j�d��\\}\ \ | �t�dd�|j� dS )�* AAAA records are loaded. r� �2001:db8:10::1r� N�rF r r� r� r r� r! �r2 r_ r r r% �test_aaaaRecords� s ���z#BindAuthorityTests.test_aaaaRecordsc C s8 | � | j�d��\\}\ \ | �tjdddd�|j� dS )�( MX records are loaded. r� rO zmx.example.comr� )r r rE N�rF r r� r� r r� r! r� r r r% �test_mxRecords s ���z!BindAuthorityTests.test_mxRecordsc C s< | � | j�d��\}\ \ |d }| �tjddd�|j� dS )�+ CNAME records are loaded. � www.example.comr r� r� r N�rF r r� r� r r� r! �r2 r' r_ r r r% �test_cnameRecords s ���z$BindAuthorityTests.test_cnameRecordsc C sL | � t�� }| �d� W d � n1 sw Y | �d|jjd � dS )zO loadBindString raises NotImplementedError on invalid records. s example.com. IN LOL 192.168.0.1Nz Record type 'LOL' not supportedr )� assertRaises�NotImplementedErrorr� r� � exceptionr� )r2 �er r r% �test_invalidRecordClass% s �z*BindAuthorityTests.test_invalidRecordClassc C sb dD ],}| � t��}| �|d � W d � n1 sw Y | �t|d �|jjd � qdS )zC $INCLUDE and $GENERATE raise NotImplementedError. )s $INCLUDEs $GENERATEs doesNotMatterNs directive not implementedr )r� r� r� r� r r� r� )r2 � directiver� r r r% �test_invalidDirectives- s � ��z)BindAuthorityTests.test_invalidDirectivesN)r3 r4 r5 r� r� r� r� r� r� r� r� r� r� r� r r r r% r� � s r� a� zone = [ SOA( # For whom we are the authority 'example.com', # This nameserver's name mname = "dns.example.com", # Mailbox of individual who handles this rname = "root.example.com", # Unique serial identifying this SOA data serial = 86400, # Time interval before zone should be refreshed refresh = "2H", # Interval before failed refresh should be retried retry = "1H", # Upper limit on time interval before expiry expire = "1H", # Minimum TTL minimum = "3H" ), AAAA('example.com', '2001:db8:10::1'), A('example.com', '10.0.0.1'), NS('example.com', 'dns.example.com'), A('no-in.example.com', '10.0.0.2'), PTR('2.0.0.10.in-addr.arpa', 'no-in.example.com'), CNAME('www.example.com', 'example.com'), CNAME('ftp.example.com', 'example.com'), MX('not-fqdn.example.com', 10, 'mail.example.com'), ] c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )�PySourceAuthorityTestszA Tests for L{twisted.names.authority.PySourceAuthority}. c C sN t | �� �}t|jd�� }|�|� W d � n1 s w Y t�|j�S )a Create a new L{twisted.names.authority.PySourceAuthority} from C{s}. @param s: A string with BIND zone data in a Python source file. @type s: L{str} @return: a new bind authority @rtype: L{twisted.names.authority.PySourceAuthority} r9 N)r r� r: r� �writer �PySourceAuthority)r2 r� r� r� r r r% �loadPySourceStringj s � z)PySourceAuthorityTests.loadPySourceStringc C r� r- )r� �samplePySourcer r� r r r% r� z r� z PySourceAuthorityTests.setUpc C s@ dD ]\}}| � | j�|��\\}\ \ | �t�|�|j� qdS )r� r� Nr� r� r r r% r� } s ��z$PySourceAuthorityTests.test_aRecordsc C s2 | � | j�d��\\}\ \ | �t�d�|j� dS )r� r� r� Nr� r� r r r% r� � s ��z'PySourceAuthorityTests.test_aaaaRecordsc C s6 | � | j�d��\\}\ \ | �tjddd�|j� dS )r� r� rO zmail.example.com)r r Nr� r� r r r% r� � s ���z%PySourceAuthorityTests.test_mxRecordsc C �: | � | j�d��\}\ \ |d }| �tjdd�|j� dS )r� r� r r� �r Nr� r� r r r% r� � � ���z(PySourceAuthorityTests.test_cnameRecordsc C r� )z) PTR records are loaded. s 2.0.0.10.in-addr.arpar r� r� N)rF r r� r� r r� r! r� r r r% r� � r� z PySourceAuthorityTests.test_PTRc C s d}| � t| j|� dS )z1 Input file has no zone variable z nothing = []N)r� � ValueErrorr� )r2 � badPySourcer r r% �test_badInputNoZone� s z*PySourceAuthorityTests.test_badInputNoZoneN) r3 r4 r5 r� r� r� r� r� r� r� r� r� r r r r% r� e s r� )Yr� r� r� r� � functoolsr r �ior �structr �twisted.internetr r r �twisted.internet.deferr � twisted.namesr r r r r �twisted.names.clientr �twisted.names.dnsr r r r r r �twisted.names.errorr �twisted.names.secondaryr r �twisted.python.compatr �twisted.python.filepathr �twisted.test.proto_helpersr r r � twisted.trialr r* � FileAuthorityr, r� � reverse_soar� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rx r� ry rz �TestCaserp r� r r/ r= rZ r� r� r� r� r� r� r� r r r r% �<module> s� � � � � �� �� � ��3��� ��� \ Z~ _0Hm +PK y�Z� -m m - test/__pycache__/test_resolve.cpython-310.pycnu �[��� o �b1 � @ s< d Z ddlmZ ddlmZ ddlmZ G dd� de�ZdS )z% Tests for L{twisted.names.resolve}. � )� DomainError)� ResolverChain)�TestCasec @ s e Zd ZdZdd� Zdd� ZdS )�ResolverChainTestsz: Tests for L{twisted.names.resolve.ResolverChain} c C �2 t g �}|�d�}| �|�}| �|�t�t� dS )zv L{ResolverChain._lookup} returns a L{DomainError} failure if its C{resolvers} list is empty. �www.example.comN)r � lookupAddress�failureResultOf�assertIs�trapr ��self�r�d�f� r �A/usr/lib/python3/dist-packages/twisted/names/test/test_resolve.py�test_emptyResolversList � z*ResolverChainTests.test_emptyResolversListc C r )z L{ResolverChain.lookupAllRecords} returns a L{DomainError} failure if its C{resolvers} list is empty. r N)r �lookupAllRecordsr r r r r r r r �'test_emptyResolversListLookupAllRecords r z:ResolverChainTests.test_emptyResolversListLookupAllRecordsN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r N)r �twisted.names.errorr �twisted.names.resolver �twisted.trial.unittestr r r r r r �<module> s PK y�Z52@�> �> - test/__pycache__/test_rfc1982.cpython-310.pycnu �[��� o �b 6 � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddlmZ G dd� dej �Z d d � Z eed d �Z G d d� dej �Z eedd �ZG dd� dej �ZdS )z* Test cases for L{twisted.names.rfc1982}. � N)�datetime)�partial�� SerialNumber)�unittestc @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:S );�SerialNumberTestsz$ Tests for L{SerialNumber}. c C s | � td�jd� dS )zB L{SerialNumber.serialBits} has default value 32. � � N�� assertEqualr � _serialBits��self� r �A/usr/lib/python3/dist-packages/twisted/names/test/test_rfc1982.py�test_serialBitsDefault s z(SerialNumberTests.test_serialBitsDefaultc C s | � tddd�jd� dS )z� L{SerialNumber.__init__} accepts a C{serialBits} argument whose value is assigned to L{SerialNumber.serialBits}. r � �� serialBitsNr r r r r �test_serialBitsOverride � z)SerialNumberTests.test_serialBitsOverridec C s | � dttddd��� dS )ze L{SerialNumber.__repr__} returns a string containing number and serialBits. z'<SerialNumber number=123 serialBits=32>�{ r r N)r �reprr r r r r � test_repr# s �zSerialNumberTests.test_reprc C s | � ttd��d� dS )zg L{SerialNumber.__str__} returns a string representation of the current value. r �123N)r �strr r r r r �test_str- � zSerialNumberTests.test_strc C s | � ttd��d� dS )zi L{SerialNumber.__int__} returns an integer representation of the current value. r N)r �intr r r r r �test_int4 r zSerialNumberTests.test_intc C s< | � ttd��ttd��� | �ttd��ttd��� dS )z| L{SerialNumber.__hash__} allows L{SerialNumber} instances to be hashed for use as dictionary keys. r � N)r �hashr �assertNotEqualr r r r � test_hash; s zSerialNumberTests.test_hashc C s, t ddd�}t ddd�}| �t|j|� dS )z� L{SerialNumber._convertOther} raises L{TypeError} if the other SerialNumber instance has a different C{serialBits} value. r r r � N)r � assertRaises� TypeError� _convertOther)r �s1�s2r r r �#test_convertOtherSerialBitsMismatchC s z5SerialNumberTests.test_convertOtherSerialBitsMismatchc C s | � td�td�� dS )zK L{SerialNumber.__eq__} provides rich equality comparison. r N�r r r r r r �test_eqM � zSerialNumberTests.test_eqc C s0 | � td�t� k� | �td��t� �t� dS )zy == comparison of L{SerialNumber} with a non-L{SerialNumber} instance returns L{NotImplemented}. r N)� assertFalser �object�assertIs�__eq__�NotImplementedr r r r �test_eqForeignTypeS � z$SerialNumberTests.test_eqForeignTypec C s. | � td�td�k� | �td�td�� dS )zK L{SerialNumber.__ne__} provides rich equality comparison. r r N)r. r r" r r r r �test_ne[ s zSerialNumberTests.test_nec C s0 | � td�t� k� | �td��t� �t� dS )zy != comparison of L{SerialNumber} with a non-L{SerialNumber} instance returns L{NotImplemented}. r N)� assertTruer r/ r0 �__ne__r2 r r r r �test_neForeignTypeb r4 z$SerialNumberTests.test_neForeignTypec C s0 | � td�td�k� | � td�td�k� dS )zE L{SerialNumber.__le__} provides rich <= comparison. r r N�r6 r r r r r �test_lej � zSerialNumberTests.test_lec C � | � tdd� � dS )zs <= comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� kS �Nr �r r/ r r r r �<lambda>v � z6SerialNumberTests.test_leForeignType.<locals>.<lambda>N�r% r& r r r r �test_leForeignTypeq � z$SerialNumberTests.test_leForeignTypec C s0 | � td�td�k� | � td�td�k� dS )zE L{SerialNumber.__ge__} provides rich >= comparison. r r Nr9 r r r r �test_gex r; zSerialNumberTests.test_gec C r< )zs >= comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� kS r= r> r r r r r? � r@ z6SerialNumberTests.test_geForeignType.<locals>.<lambda>NrA r r r r �test_geForeignType rC z$SerialNumberTests.test_geForeignTypec C s | � td�td�k � dS )zD L{SerialNumber.__lt__} provides rich < comparison. r r Nr9 r r r r �test_lt� � zSerialNumberTests.test_ltc C r< )zr < comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� k S r= r> r r r r r? � r@ z6SerialNumberTests.test_ltForeignType.<locals>.<lambda>NrA r r r r �test_ltForeignType� rC z$SerialNumberTests.test_ltForeignTypec C s | � td�td�k� dS )zD L{SerialNumber.__gt__} provides rich > comparison. r r Nr9 r r r r �test_gt� rG zSerialNumberTests.test_gtc C r< )zt > comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� kS )Nr r> r r r r r? � r@ z6SerialNumberTests.test_gtForeignType.<locals>.<lambda>NrA r r r r �test_gtForeignType� rC z$SerialNumberTests.test_gtForeignTypec C s | � td�td� td�� dS )zX L{SerialNumber.__add__} allows L{SerialNumber} instances to be summed. r r Nr+ r r r r �test_add� s zSerialNumberTests.test_addc C r< )zn Addition of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� S r= r> r r r r r? � r@ z7SerialNumberTests.test_addForeignType.<locals>.<lambda>NrA r r r r �test_addForeignType� rC z%SerialNumberTests.test_addForeignTypec s" t d�j� | �t� fdd�� dS )zp L{SerialNumber} cannot be added with other SerialNumber values larger than C{_maxAdd}. r c s t d�t � d � S r= r r ��maxAddr r r? � � z:SerialNumberTests.test_addOutOfRangeHigh.<locals>.<lambda>N)r �_maxAddr% �ArithmeticErrorr r rM r �test_addOutOfRangeHigh� s �z(SerialNumberTests.test_addOutOfRangeHighc C sN t d�}|j|j d }|d }| �t |�t |�k� | �t |�t d�� dS )z� L{SerialNumber.__add__} returns a wrapped value when s1 plus the s2 would result in a value greater than the C{maxVal}. r r N)r � _halfRingr6 r )r �s�maxVal� maxValPlus1r r r � test_maxVal� s z SerialNumberTests.test_maxValc C s | � td�t�d�� dS )z� L{SerialNumber.fromRFC4034DateString} accepts a datetime string argument of the form 'YYYYMMDDhhmmss' and returns an L{SerialNumber} instance whose value is the unix timestamp corresponding to that UTC date. � ��N�20120101000000N)r r �fromRFC4034DateStringr r r r �test_fromRFC4034DateString� s �z,SerialNumberTests.test_fromRFC4034DateStringc C s | � dtd��� � dS )z� L{DateSerialNumber.toRFC4034DateString} interprets the current value as a unix timestamp and returns a date string representation of that date. rY rX N�r r �toRFC4034DateStringr r r r �test_toRFC4034DateString� s �z*SerialNumberTests.test_toRFC4034DateStringc C � | � td��� d� dS )zq L{SerialNumber.toRFC4034DateString} stores 32bit timestamps relative to the UNIX epoch. r �19700101000000Nr\ r r r r �test_unixEpoch� r z SerialNumberTests.test_unixEpochc C r_ )zI L{SerialNumber} wraps unix timestamps in the year 2106. ����21060207062815Nr\ r r r r �test_Y2106Problem� r- z#SerialNumberTests.test_Y2106Problemc sF t �tdddddd��� �� | �� td�j� | �t� fdd �� d S ) zy L{SerialNumber} raises ArithmeticError when used to add dates more than 68 years in the future. i� r � � � � r c s t d�t � d � S )Nr r r r �� maxAddTimer r r? � rO z5SerialNumberTests.test_Y2038Problem.<locals>.<lambda>N) �calendar�timegmr � utctimetupler r rP r% rQ r r ri r �test_Y2038Problem� s � �z#SerialNumberTests.test_Y2038ProblemN) �__name__� __module__� __qualname__�__doc__r r r r r r# r* r, r3 r5 r8 r: rB rD rE rF rH rI rJ rK rL rR rW r[ r^ ra rd rn r r r r r s< r c C sJ | � ||k� | � ||k� | � ||k � | � ||k� | � ||k� dS )a� A custom assertion for L{SerialNumber} values that cannot be meaningfully compared. "Note that there are some pairs of values s1 and s2 for which s1 is not equal to s2, but for which s1 is neither greater than, nor less than, s2. An attempt to use these ordering operators on such pairs of values produces an undefined result." @see: U{https://tools.ietf.org/html/rfc1982#section-3.2} @param testCase: The L{unittest.TestCase} on which to call assertion methods. @type testCase: L{unittest.TestCase} @param s1: The first value to compare. @type s1: L{SerialNumber} @param s2: The second value to compare. @type s2: L{SerialNumber} N)r. )�testCaser( r) r r r �assertUndefinedComparison� s rt r r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �SerialNumber2BitTestsaF Tests for correct answers to example calculations in RFC1982 5.1. The simplest meaningful serial number space has SERIAL_BITS == 2. In this space, the integers that make up the serial number space are 0, 1, 2, and 3. That is, 3 == 2^SERIAL_BITS - 1. https://tools.ietf.org/html/rfc1982#section-5.1 c C � | � tddd�jd� dS )z� In this space, the largest integer that it is meaningful to add to a sequence number is 2^(SERIAL_BITS - 1) - 1, or 1. r r r r N�r r rP r r r r � test_maxadd r z!SerialNumber2BitTests.test_maxaddc C st | � td�td� td�� | � td�td� td�� | � td�td� td�� | � td�td� td�� dS )zN Then, as defined 0+1 == 1, 1+1 == 2, 2+1 == 3, and 3+1 == 0. r r r rf N)r � serialNumber2r r r r rK & s z SerialNumber2BitTests.test_addc C s\ | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� dS )z: Further, 1 > 0, 2 > 1, 3 > 2, and 0 > 3. r r r rf N)r6 ry r r r r rI / s z SerialNumber2BitTests.test_gtc C sT t | td�td�� t | td�td�� t | td�td�� t | td�td�� dS )zU It is undefined whether 2 > 0 or 0 > 2, and whether 1 > 3 or 3 > 1. r r r rf N)rt ry r r r r �test_undefined8 s z$SerialNumber2BitTests.test_undefinedN)ro rp rq rr rx rK rI rz r r r r ru s ru r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �SerialNumber8BitTestsa. Tests for correct answers to example calculations in RFC1982 5.2. Consider the case where SERIAL_BITS == 8. In this space the integers that make up the serial number space are 0, 1, 2, ... 254, 255. 255 == 2^SERIAL_BITS - 1. https://tools.ietf.org/html/rfc1982#section-5.2 c C rv )z� In this space, the largest integer that it is meaningful to add to a sequence number is 2^(SERIAL_BITS - 1) - 1, or 127. r r r � Nrw r r r r rx P r z!SerialNumber8BitTests.test_maxaddc C sX | � td�td� td�� | � td�td� td�� | � td�td� td�� dS )z| Addition is as expected in this space, for example: 255+1 == 0, 100+100 == 200, and 200+100 == 44. � r r �d �� �, N)r � serialNumber8r r r r rK W s z SerialNumber8BitTests.test_addc C s� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� dS )z� Comparison is more interesting, 1 > 0, 44 > 0, 100 > 0, 100 > 44, 200 > 100, 255 > 200, 0 > 255, 100 > 255, 0 > 200, and 44 > 200. r r r� r~ r r} N�r6 r� r r r r rI ` s z SerialNumber8BitTests.test_gtc C sH | � td�td� td�k� | � td�td� td� td�k � dS )a� Note that 100+100 > 100, but that (100+100)+100 < 100. Incrementing a serial number can cause it to become "smaller". Of course, incrementing by a smaller number will allow many more increments to be made before this occurs. However this is always something to be aware of, it can cause surprising errors, or be useful as it is the only defined way to actually cause a serial number to decrease. r~ Nr� r r r r �test_surprisingAdditiono s ��z-SerialNumber8BitTests.test_surprisingAdditionc C sT t | td�td�� t | td�td�� t | td�td�� t | td�td�� d S ) z� The pairs of values 0 and 128, 1 and 129, 2 and 130, etc, to 127 and 255 are not equal, but in each pair, neither number is defined as being greater than, or less than, the other. r � r � r � r| r} N)rt r� r r r r rz ~ s z$SerialNumber8BitTests.test_undefinedN) ro rp rq rr rx rK rI r� rz r r r r r{ E s r{ )rr rk r � functoolsr �twisted.names._rfc1982r � twisted.trialr �TestCaser rt ry ru r� r{ r r r r �<module> s d .PK y�Z�^^� � . test/__pycache__/test_examples.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZm Z G dd� d�Z G dd � d e e �Z G d d � d e e �Z G d d � d e e �Z G dd� de e �ZdS )z- Tests for L{twisted.names} example scripts. � N)�StringIO)�FilePath)�SkipTest�TestCasec @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �ExampleTestBasea� This is a mixin which adds an example to the path, tests it, and then removes it from the path and unimports the modules which the test loaded. Test cases which test example code and documentation listings should use this. This is done this way so that examples can live in isolated path entries, next to the documentation, replete with their own plugin packages and whatever other metadata they need. Also, example code is a rare instance of it being valid to have multiple versions of the same code in the repository at once, rather than relying on version control, because documentation will often show the progression of a single piece of code as features are added to it, and we want to test each one. c C s� t jdd� | _t j�� | _t� | _| �t d| j� t� | _ | �t d| j � z t t j d �� d�}W n ty= td��w | j�d�D ]}|� |�}|�� sXtd|j� d ���qD|| _t j�| j�� j� | j�� �d �d }t|�| _dS ) zn Add our example directory to the path and record which modules are currently loaded. N�stderr�stdout� TOX_INI_DIR�docsz5Examples not found ($TOX_INI_DIR unset) - cannot test�/z Examples (z) not found - cannot test�.r )�sys�path� originalPath�modules�copy�originalModulesr �fakeErr�patch�fakeOutr �os�environ�child�KeyErrorr �exampleRelativePath�split�exists� examplePath�append�parent�basename� __import__�example)�self�here� childName� moduleName� r' �B/usr/lib/python3/dist-packages/twisted/names/test/test_examples.py�setUp! s, �� �zExampleTestBase.setUpc C s, t j�� t j�| j� | jt jdd�< dS )z� Remove the example directory from the path and remove all modules loaded by the test from sys.modules. N)r r �clear�updater r r )r# r' r' r( �tearDownE s zExampleTestBase.tearDownc C sD | j �� �}| �|�� �� d� W d � dS 1 sw Y dS )zK The example scripts start with the standard shebang line. s #!/usr/bin/env pythonN)r �open� assertEqual�readline�rstrip)r# �fr' r' r( � test_shebangN s "�z ExampleTestBase.test_shebangc C sF | � t| jjdd� | j�� �� }| �|d �d�d|d f � dS )z� The example script prints a usage message to stdout if it is passed a --help option and then exits. The first line should contain a USAGE summary, explaining the accepted command arguments. Nz--helpr �Usage:�?Usage message first line should start with "Usage:". Actual: %r) � assertRaises� SystemExitr" �mainr �getvalue� splitlines� assertTrue� startswith)r# �outr' r' r( �test_usageConsistencyU s ��z%ExampleTestBase.test_usageConsistencyc C sf | � t| jjdd� | j�� �� }| �|d �d�d|d f � | �|d �d�d|d f � dS ) a` The example script prints a usage message to stderr if it is passed unrecognized command line arguments. The first line should contain a USAGE summary, explaining the accepted command arguments. The last line should contain an ERROR summary, explaining that incorrect arguments were supplied. Nz--unexpected_argumentr r3 r4 ���zERROR:z=Usage message last line should start with "ERROR:" Actual: %r) r5 r6 r" r7 r r8 r9 r: r; )r# �errr' r' r( � test_usageConsistencyOnErrorh s �� ��z,ExampleTestBase.test_usageConsistencyOnErrorN) �__name__� __module__� __qualname__�__doc__r) r, r2 r= r@ r' r' r' r( r s $ r c @ � e Zd ZdZdZdS )� TestDnsTestsz- Test the testdns.py example script. znames/examples/testdns.pyN�rA rB rC rD r r' r' r' r( rF � � rF c @ rE )�GetHostByNameTestsz3 Test the gethostbyname.py example script. z names/examples/gethostbyname.pyNrG r' r' r' r( rI � rH rI c @ rE )�DnsServiceTestsz1 Test the dns-service.py example script. z names/examples/dns-service.pyNrG r' r' r' r( rJ � rH rJ c @ rE )�MultiReverseLookupTestsz: Test the multi_reverse_lookup.py example script. z&names/examples/multi_reverse_lookup.pyNrG r' r' r' r( rK � rH rK )rD r r �ior �twisted.python.filepathr �twisted.trial.unittestr r r rF rI rJ rK r' r' r' r( �<module> s sPK y�Z�� � ) test/__pycache__/test_dns.cpython-310.pycnu �[��� o �b�s � @ s d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z m Z ddl m Z m Z ddlmZ dd lmZ dd lmZmZ dd lmZ dd lmZ dd lmZ ejej ej ej ej ej ej!ej"ej#ej$ej%ej&ej'ej(ej)ej*ej+ej,ej-ej.ej/ej0ej1ej2ej3ej4gZ5G dd� dej6�Z7G dd� dej8�Z9G dd� dej8�Z:G dd� dej8�Z;G dd� dej8�Z<dZ=dZ>G dd� dej6�Z?G d d � d eej6�Z@G d d � d �ZAG d d!� d!ej8�ZBG d"d#� d#eA�ZCG d$d%� d%ej8�ZDG d&d'� d'ej8�ZEG d(d)� d)eej8�ZFG d*d+� d+ej8�ZGG d,d-� d-ej6�ZHd.d/� ZId0d1� ZJG d2d3� d3ej6�ZKG d4d5� d5�ZLG d6d7� d7eej8�ZMG d8d9� d9eej8�ZNG d:d;� d;eO�ZPG d<d=� d=�ZQG d>d?� d?�ZRG d@dA� dA�ZSG dBdC� dC�ZTG dDdE� dE�ZUG dFdG� dG�ZVG dHdI� dI�ZWG dJdK� dK�ZXG dLdM� dMee�ZY djdNdO�ZZG dPdQ� dQ�Z[G dRdS� dS�Z\G dTdU� dUe[e\ej6�Z]G dVdW� dWe[e\ej6�Z^G dXdY� dYe[ej6�Z_G dZd[� d[eej6�Z`G d\d]� d]�ZaG d^d_� d_eaej6�ZbG d`da� daeaej6�ZcG dbdc� dcej6�ZdG ddde� deej6�ZeG dfdg� dg�ZfG dhdi� diej6�ZgdS )kz Tests for twisted.names.dns. � N)�BytesIO)�cast)� verifyClass)�address�task)�CannotListenError�ConnectionDone)�dns)�Failure)� FancyEqMixin� FancyStrMixin)� proto_helpers)�ComparisonTestsMixin)�unittestc @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �DomainStringTestsc C s | � dt�d�� dS )zA L{dns.domainString} returns L{bytes} unchanged. s twistedmatrix.comN�� assertEqualr � domainString��self� r �=/usr/lib/python3/dist-packages/twisted/names/test/test_dns.py� test_bytes8 s �z DomainStringTests.test_bytesc C � | � dt�d�� dS )z` L{dns.domainString} converts a native string to L{bytes} if necessary. � example.com� example.comNr r r r r � test_nativeA � z DomainStringTests.test_nativec C r )zS L{dns.domainString} always converts a unicode string to L{bytes}. s foo.examplez foo.exampleNr r r r r � test_textH � zDomainStringTests.test_textc C r )�A L{dns.domainString} encodes Unicode using IDNA. s xn--fwg.testu ‽.testNr r r r r � test_idnaN r zDomainStringTests.test_idnac C s* | � ttjd� | � ttjt�d�� dS )r i(# z bar.exampleN)� assertRaises� TypeErrorr r �Namer r r r � test_nonsenseT s z DomainStringTests.test_nonsenseN)�__name__� __module__� __qualname__r r r r! r% r r r r r 7 s r c @ � e Zd ZdZdd� ZdS )� Ord2ByteTestsz& Tests for L{dns._ord2bytes}. c C r )z� L{dns._ord2byte} accepts an integer and returns a byte string of length one with an ordinal value equal to the given integer. � � N)r r � _ord2bytesr r r r � test_ord2bytea r zOrd2ByteTests.test_ord2byteN)r& r' r( �__doc__r. r r r r r* \ � r* c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� Str2TimeTestsz$ Tests for L{dns.str2name}. c C s t � }| �|t�|�� dS )zY When passed a non-string object, L{dns.str2name} returns it unmodified. N)�object�assertIsr �str2time)r �timer r r �test_nonStringn s z Str2TimeTests.test_nonStringc C r )z� Passed a string giving a number of seconds, L{dns.str2time} returns the number of seconds represented. For example, C{"10S"} represents C{10} seconds. � �10SN�r r r4 r r r r � test_secondsu � zStr2TimeTests.test_secondsc C r )z� Like C{test_seconds}, but for the C{"M"} suffix which multiplies the time value by C{60} (the number of seconds in a minute!). �x �2MNr9 r r r r � test_minutes} r zStr2TimeTests.test_minutesc C r )z� Like C{test_seconds}, but for the C{"H"} suffix which multiplies the time value by C{3600}, the number of seconds in an hour. i0* �3HNr9 r r r r � test_hours� r zStr2TimeTests.test_hoursc C r )z� Like L{test_seconds}, but for the C{"D"} suffix which multiplies the time value by C{86400}, the number of seconds in a day. i F �4DNr9 r r r r � test_days� r zStr2TimeTests.test_daysc C r )z� Like L{test_seconds}, but for the C{"W"} suffix which multiplies the time value by C{604800}, the number of seconds in a week. i�$. �5WNr9 r r r r � test_weeks� r zStr2TimeTests.test_weeksc C r )z� Like L{test_seconds}, but for the C{"Y"} suffix which multiplies the time value by C{31536000}, the number of seconds in a year. i 5G �6YNr9 r r r r � test_years� r zStr2TimeTests.test_yearsc C s | � ttjd� dS )zY If a non-integer prefix is given, L{dns.str2time} raises L{ValueError}. �fooSN)r" � ValueErrorr r4 r r r r �test_invalidPrefix� � z Str2TimeTests.test_invalidPrefixN) r& r' r( r/ r6 r: r> r@ rB rD rF rI r r r r r1 i s r1 c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )� NameTestsz� Tests for L{Name}, the representation of a single domain name with support for encoding into and decoding from DNS message format. c C s6 | � ttjd� | � ttjt� � | � ttjg � dS )zy When constructed with a name which is neither C{bytes} nor C{str}, L{Name} raises L{TypeError}. �{ N)r" r# r r$ r2 r r r r �test_nonStringName� s z NameTests.test_nonStringNamec C s* t �d�}| �|jt� | �d|j� dS )zg L{dns.Name} automatically encodes unicode domain name using C{idna} encoding. u échec.example.orgs xn--chec-9oa.example.orgN)r r$ �assertIsInstance�name�bytesr )r rO r r r �test_unicodeName� s zNameTests.test_unicodeNamec C s( t �� }|�td�� | �|jd� dS )z� L{Name.decode} populates the L{Name} instance with name information read from the file-like object passed to it. � examplecom r N)r r$ �decoder r rO )r �nr r r � test_decode� s zNameTests.test_decodec C s. t �d�}t� }|�|� | �|�� d� dS )zy L{Name.encode} encodes its name information and writes it to the file-like object passed to it. � foo.example.coms fooexamplecom N)r r$ r �encoder �getvalue�r rO �streamr r r � test_encode� s zNameTests.test_encodec C st t �d�}ddi}d}t� }|�|� t|�t jj }|�||� | �d|� � t|�d� � | �d|d�|� dS )am If a compression dictionary is passed to it, L{Name.encode} uses offset information from it to encode its name with references to existing labels in the stream instead of including another copy of them in the output. It also updates the compression dictionary with the location of the name it writes to the stream. rV r � s some prefix to change .tell()s foo�N)r rV ) r r$ r �write�len�Message� headerSizerW r rX )r rO � compression�previousrZ �expectedr r r �test_encodeWithCompression� s �z$NameTests.test_encodeWithCompressionc C s� d}t �� }|�|� | �|jt jdddd�g� | �|jt jddddt jddd�d �g� | �|j t jd t j t j dt j d dd�d �g� |� � }| �||� d S ) z� A resource record of unknown type and class is parsed into an L{UnknownRecord} instance with its data preserved, and an L{UnknownRecord} instance is serialized to a string equal to the one it was parsed from. sD foobar ޭ�� ޭ�� somedatabazban � foo.bari�� i� )�type�clsi s somedata��ttl�rf rg ri �payloads baz.ban�1.2.3.4N)r r_ �fromStrr �queries�Query�answers�RRHeader� UnknownRecord� additional�A�IN�Record_A�toStr)r �wire�msg�encr r r � test_unknown� sB � �� ��� ��� zNameTests.test_unknownc C s� t d�}|�d� t�� }|�|� | �d|j� | �d|�� � |�|� | �|jd� | �d|�� � |�|� | �|jd� | �d|�� � d S ) a If the leading byte of an encoded label (in bytes read from a stream passed to L{Name.decode}) has its two high bits set, the next byte is treated as a pointer to another label in the stream and that label is included in the name being decoded. s, xxxxxxxxxxxxxxxxxxxxfisiarpa foo�bar� � s f.isi.arpa� s foo.f.isi.arpa�& s bar.foo.f.isi.arpa�, N)r �seekr r$ rS r rO �tell)r rZ rO r r r �test_decodeWithCompression5 s � z$NameTests.test_decodeWithCompressionc C s$ t �� }td�}| �t|j|� dS )z� L{Name.decode} raises L{ValueError} if the stream passed to it includes a compression pointer which forms a loop, causing the name to be undecodable. s � N)r r$ r r" rH rS rY r r r �test_rejectCompressionLoopT s z$NameTests.test_rejectCompressionLoopc C s: t �d�}t �d�}| �||� t �d�}| �||� dS )z� L{Name} instances are equal as long as they have the same value for L{Name.name}, regardless of the case. re s fOO.barN)r r$ r )r �name1�name2�name3r r r � test_equality^ s zNameTests.test_equalityc C s$ t �d�}t �d�}| �||� dS )zq L{Name} instances are not equal as long as they have different L{Name.name} attributes. re s bar.fooN)r r$ �assertNotEqual)r r� r� r r r �test_inequalityj s zNameTests.test_inequalityN)r& r' r( r/ rM rQ rU r[ rd r{ r� r� r� r� r r r r rK � s J rK c @ s� e Zd ZdZg d�Zdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Z d3d4� Z d5S )6�RoundtripDNSTestsz5 Encoding and then decoding various objects. )� example.orgs go-away.fish.tvs 23strikesback.netc C sR | j D ]#}t� }t�|��|� |�dd� t�� }|�|� | �|j|� qd S )Nr ) �namesr r r$ rW r� rS r rO �r rT �f�resultr r r � test_name{ s �zRoundtripDNSTests.test_namec C s� | j D ]D}tdd�D ]<}tdd�D ]4}t� }t�|||��|� |�dd� t�� }|�|� | �|j j |� | �|j |� | �|j |� qq qdS )z� L{dns.Query.encode} returns a byte string representing the fields of the query which can be decoded into a new L{dns.Query} instance using L{dns.Query.decode}. � � � r N) r� �ranger r ro rW r� rS r rO rf rg )r rT �dnstype�dnsclsr� r� r r r � test_query� s ���z RoundtripDNSTests.test_queryc C s| t � }t�dddd��|� |�dd� t�� }|�|� | �|jt�d�� | �|j d� | �|j d� | �|j d� dS )a L{dns.RRHeader.encode} encodes the record header's information and writes it to the file-like object passed to it and L{dns.RRHeader.decode} reads from a file-like object to re-construct a L{dns.RRHeader} instance. s test.org� � r� r N) r r rq rW r� rS r rO r$ rf rg ri )r r� r� r r r �test_resourceRecordHeader� s z+RoundtripDNSTests.test_resourceRecordHeaderc C sF | � td�� tjtjt�� d� W d � dS 1 s w Y dS )zy L{RRHeader()} raises L{ValueError} when the given type and the type of the payload don't match. z#Payload type \(AAAA\) .* type \(A\)�rf rk N)�assertRaisesRegexrH r rq rt � Record_AAAAr r r r �%test_resourceRecordHeaderTypeMismatch� s "�z7RoundtripDNSTests.test_resourceRecordHeaderTypeMismatchc C sZ d}|D ]&}t � }t�|��|� |�dd� t�� }|�|� | �|jt�|�� qdS )a L{dns.SimpleRecord.encode} encodes the record's name information and writes it to the file-like object passed to it and L{dns.SimpleRecord.decode} reads from a file-like object to re-construct a L{dns.SimpleRecord} instance. )s this.are.test.names0 will.compress.will.this.will.name.will.hopefullys test.CASE.preSErVatIOn.YeAHs a.s.h.o.r.t.c.a.s.e.t.o.t.e.s.ts singletonr N) r r � SimpleRecordrW r� rS r rO r$ )r r� �sr� r� r r r �test_resources� s �z RoundtripDNSTests.test_resourcesc C sL t D ]!}|� |� }}t|�}t|�}| �|||� d|� d|� d�� qdS )z= Instances of all record types are hashable. z != z (for �)N)� RECORD_TYPES�hashr )r �k�k1�k2�hk1�hk2r r r � test_hashable� s "�z RoundtripDNSTests.test_hashablec C sR | j D ]#}t� }t�|��|� |�dd� t�� }|�|� | �|j|� qdS )z8 Test L{dns.Charstr} encode and decode. r N) r� r r �CharstrrW r� rS r �stringr� r r r � test_Charstr� s �z RoundtripDNSTests.test_Charstrc C sH t � }|�|� |�� }|�dd� |�� }|�||� | �||� dS )z� Assert that encoding C{record} and then decoding the resulting bytes creates a record which compares equal to C{record}. @type record: L{dns.IEncodable} @param record: A record instance to encode r N)r rW r� r� � __class__rS r )r �recordrZ �length�replicar r r �_recordRoundtripTest� s z&RoundtripDNSTests._recordRoundtripTestc C s$ t � }|�|� | �|�� |� dS )a3 Assert that encoding C{record} produces the expected bytes. @type record: L{dns.IEncodable} @param record: A record instance to encode @type expectedEncoding: L{bytes} @param expectedEncoding: The value which C{record.encode()} should produce. N)r rW r rX )r �expectedEncodingr� rZ r r r �assertEncodedFormat� s z%RoundtripDNSTests.assertEncodedFormatc C s" | � tjdddddddd�� d S ) z� The byte stream written by L{dns.Record_SOA.encode} can be used by L{dns.Record_SOA.decode} to reconstruct the state of the original L{dns.Record_SOA} instance. � foo� bar� �" �8 �N �Z )�mname�rname�serial�refresh�retry�expire�minimumN)r� r � Record_SOAr r r r �test_SOA s ��zRoundtripDNSTests.test_SOAc C � | � t�d�� dS )z� The byte stream written by L{dns.Record_A.encode} can be used by L{dns.Record_A.decode} to reconstruct the state of the original L{dns.Record_A} instance. rl N)r� r rv r r r r �test_A � zRoundtripDNSTests.test_Ac C r� )z� The byte stream written by L{dns.Record_NULL.encode} can be used by L{dns.Record_NULL.decode} to reconstruct the state of the original L{dns.Record_NULL} instance. s foo barN)r� r � Record_NULLr r r r � test_NULL# r� zRoundtripDNSTests.test_NULLc C � | � t�ddd�� dS )z� The byte stream written by L{dns.Record_WKS.encode} can be used by L{dns.Record_WKS.decode} to reconstruct the state of the original L{dns.Record_WKS} instance. rl r� s xyzN)r� r � Record_WKSr r r r �test_WKS+ � zRoundtripDNSTests.test_WKSc C r� )z� The byte stream written by L{dns.Record_AAAA.encode} can be used by L{dns.Record_AAAA.decode} to reconstruct the state of the original L{dns.Record_AAAA} instance. z::1N)r� r r� r r r r � test_AAAA3 r� zRoundtripDNSTests.test_AAAAc C r� )z� The byte stream written by L{dns.Record_A6.encode} can be used by L{dns.Record_A6.decode} to reconstruct the state of the original L{dns.Record_A6} instance. � z::1:2r� N)r� r � Record_A6r r r r �test_A6; r� zRoundtripDNSTests.test_A6c C s | � tjddddd�� dS )z� The byte stream written by L{dns.Record_SRV.encode} can be used by L{dns.Record_SRV.decode} to reconstruct the state of the original L{dns.Record_SRV} instance. r� � r� r )�priority�weight�port�targetN)r� r � Record_SRVr r r r �test_SRVC � �zRoundtripDNSTests.test_SRVc C s: d}t jt jjt jj|d�}| �|� | �d| |� dS )z� The byte stream written by L{dns.Record_SSHFP.encode} can be used by L{dns.Record_SSHFP.decode} to reconstruct the state of the original L{dns.Record_SSHFP} instance. s �9��^kK 2U��`��� )� algorithm�fingerprintType� fingerprints N)r � Record_SSHFP� ALGORITHM_DSS�FINGERPRINT_TYPE_SHA1r� r� )r �fp�rrr r r � test_SSHFPM s �� z RoundtripDNSTests.test_SSHFPc C s� ddg}|D ]c\}}}}}}t �||||||�}t� } |�| � | �dd� t �� } | �| � | �|j| j� | �|j| j� | �|j | j � | �|j | j � | �|j | j � | �|j j | j j � | �|j| j� qdS )z= Test L{dns.Record_NAPTR} encode and decode. )�d r7 � u� sip+E2Us! !^.*$!sip:information@domain.tld!� )r� �2 � ss http+I2L+I2C+I2Rr� s _http._tcp.gatech.edur N)r � Record_NAPTRr rW r� rS r �order� preference�flags�service�regexp� replacementrO ri ) r �naptrsr� r� r� r� r� r� �rin�e�routr r r � test_NAPTR` s( � � �z RoundtripDNSTests.test_NAPTRc C � | � tjddd�� dS )z� The byte stream written by L{dns.Record_AFSDB.encode} can be used by L{dns.Record_AFSDB.decode} to reconstruct the state of the original L{dns.Record_AFSDB} instance. r� r )�subtype�hostnameN)r� r � Record_AFSDBr r r r � test_AFSDBz r� z RoundtripDNSTests.test_AFSDBc C r� )z� The byte stream written by L{dns.Record_RP.encode} can be used by L{dns.Record_RP.decode} to reconstruct the state of the original L{dns.Record_RP} instance. � alice.example.comr )�mbox�txtN)r� r � Record_RPr r r r �test_RP� s �zRoundtripDNSTests.test_RPc C r� )z� The byte stream written by L{dns.Record_HINFO.encode} can be used by L{dns.Record_HINFO.decode} to reconstruct the state of the original L{dns.Record_HINFO} instance. s fasts great)�cpu�osN)r� r � Record_HINFOr r r r � test_HINFO� r� z RoundtripDNSTests.test_HINFOc C r� )z� The byte stream written by L{dns.Record_MINFO.encode} can be used by L{dns.Record_MINFO.decode} to reconstruct the state of the original L{dns.Record_MINFO} instance. r� r� )�rmailbx�emailbxN)r� r � Record_MINFOr r r r � test_MINFO� r� z RoundtripDNSTests.test_MINFOc C r� )z� The byte stream written by L{dns.Record_MX.encode} can be used by L{dns.Record_MX.decode} to reconstruct the state of the original L{dns.Record_MX} instance. r� r )r� rO N)r� r � Record_MXr r r r �test_MX� r� zRoundtripDNSTests.test_MXc C sx d}t jdddd|d�}| �|� d| d }| �||� t jd d d t jd |d �}| �|� d| d }| �||� dS )z� The byte stream written by L{dns.Record_TSIG.encode} can be used by L{dns.Record_TSIG.decode} to reconstruct the state of the original L{dns.Record_TSIG} instance. s !"#0123zhmac-md5.sig-alg.reg.int�/qUZ�* r� )r� � timeSigned� originalID�fudge�MACs$ hmac-md5sig-algregint ZUq/ s * z hmac-sha256l '� � s � )r� r r �error� otherDatar s hmac-sha256 �' s �� � N)r � Record_TSIGr� r� �EBADTIME)r �macr� �rdatar r r � test_TSIG� s@ � ��� � ���zRoundtripDNSTests.test_TSIGc C s | � t�dd�� dS )z� The byte stream written by L{dns.Record_TXT.encode} can be used by L{dns.Record_TXT.decode} to reconstruct the state of the original L{dns.Record_TXT} instance. r� r� N)r� r � Record_TXTr r r r �test_TXT� r; zRoundtripDNSTests.test_TXTN) r& r' r( r/ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r� t s8 )r� s s c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&S )'� MessageTestsz1 Tests for L{twisted.names.dns.Message}. c C � | � t�� jd� dS )zC L{dns.Message.authenticData} has default value 0. r N�r r r_ � authenticDatar r r r �test_authenticDataDefault� r z&MessageTests.test_authenticDataDefaultc C � | � tjdd�jd� dS )z� L{dns.Message.__init__} accepts a C{authenticData} argument which is assigned to L{dns.Message.authenticData}. r� �r Nr r r r r �test_authenticDataOverride� � z'MessageTests.test_authenticDataOverridec C � | � tjdd��� t� dS )zr L{dns.Message.toStr} encodes L{dns.Message.authenticData} into byte4 of the byte string. r� r N)r r r_ rw � MESSAGE_AUTHENTIC_DATA_BYTESr r r r �test_authenticDataEncode� � �z%MessageTests.test_authenticDataEncodec C �$ t �� }|�t� | �|jd� dS )zp L{dns.Message.fromStr} decodes byte4 and assigns bit3 to L{dns.Message.authenticData}. r� N)r r_ rm r# r r �r �mr r r �test_authenticDataDecode � z%MessageTests.test_authenticDataDecodec C r )zF L{dns.Message.checkingDisabled} has default value 0. r N�r r r_ �checkingDisabledr r r r � test_checkingDisabledDefault r z)MessageTests.test_checkingDisabledDefaultc C r )z� L{dns.Message.__init__} accepts a C{checkingDisabled} argument which is assigned to L{dns.Message.checkingDisabled}. r� �r, Nr+ r r r r � test_checkingDisabledOverride r! z*MessageTests.test_checkingDisabledOverridec C r" )zu L{dns.Message.toStr} encodes L{dns.Message.checkingDisabled} into byte4 of the byte string. r� r. N)r r r_ rw � MESSAGE_CHECKING_DISABLED_BYTESr r r r �test_checkingDisabledEncode r% z(MessageTests.test_checkingDisabledEncodec C r& )zs L{dns.Message.fromStr} decodes byte4 and assigns bit4 to L{dns.Message.checkingDisabled}. r� N)r r_ rm r0 r r, r' r r r �test_checkingDisabledDecode' r* z(MessageTests.test_checkingDisabledDecodec C s | � dtt�� �� dS )z� L{dns.Message.__repr__} omits field values and sections which are identical to their defaults. The id field value is always shown. z<Message id=0>N)r �reprr r_ r r r r �test_reprDefaults1 � z MessageTests.test_reprDefaultsc C s, t jdddddddd�}| �dt|�� dS )zM L{dns.Message.__repr__} displays flags if they are L{True}. T)�answer�auth�trunc�recDes�recAvr r, zR<Message id=0 flags=answer,auth,trunc,recDes,recAv,authenticData,checkingDisabled>N�r r_ r r3 r' r r r �test_reprFlagsIfSet8 s � �z MessageTests.test_reprFlagsIfSetc C s& t jddddd�}| �dt|�� dS )zk L{dns.Message.__repr__} displays field values if they differ from their defaults. r7 r| � �( )�id�opCode�rCode�maxSizez-<Message id=10 opCode=20 rCode=30 maxSize=40>Nr; r' r r r �test_reprNonDefautFieldsN s �z%MessageTests.test_reprNonDefautFieldsc C sD t �� }g d�|_g d�|_g d�|_g d�|_| �dt|�� dS )�e L{dns.Message.__repr__} displays sections which differ from their defaults. �r� r� r� �r� r� � �� r� � �r7 � r� z^<Message id=0 queries=[1, 2, 3] answers=[4, 5, 6] authority=[7, 8, 9] additional=[10, 11, 12]>N)r r_ rn rp � authorityrs r r3 r' r r r �test_reprNonDefaultSectionsY � �z(MessageTests.test_reprNonDefaultSectionsc C s t �� }| �t|jd� dS )zy Test that a message which has been truncated causes an EOFError to be raised when it is parsed. r� N)r r_ r" �EOFErrorrm �r ry r r r �test_emptyMessagen s z MessageTests.test_emptyMessagec C s� t �� }|�d� | �|jd� | �|jd� | �|jt j� | �|j d� | �|j d� | �|j g � | �|j g � | �|j g � | �|jg � dS )ze Test that bytes representing an empty query message can be decoded as such. s � z)Message was not supposed to be an answer.z-Message was not supposed to be authoritative.z)Message was not supposed to be truncated.N)r r_ rm r r? � assertFalser6 r@ �OP_QUERYr7 r8 rn rp rM rs rQ r r r �test_emptyQueryv s � z MessageTests.test_emptyQueryc C s� d� dd� td�D ��}t�|�}tjdtj|d�}t�� }|j�|� t � }|� |� |� dd� t�� }|� |� | � |jd jtj� | �|jd jj|� dS ) z| A I{NULL} record with an arbitrary payload can be encoded and decoded as part of a L{dns.Message}. r� c S � g | ]}t �|��qS r �r r- ��.0�ir r r � <listcomp>� � z*MessageTests.test_NULL.<locals>.<listcomp>rS � testname�rk r N)�joinr� r r� rq �NULLr_ rp �appendr rW r� rS rN rk r �r rP �recr� �msg1r� �msg2r r r r� � s zMessageTests.test_NULLc C s | � t�� �d�tj� dS )z� L{Message.lookupRecordType} returns C{dns.UnknownRecord} if it is called with an integer which doesn't correspond to any known record type. i � N)r3 r r_ �lookupRecordTyperr r r r r � test_lookupRecordTypeDefault� s z)MessageTests.test_lookupRecordTypeDefaultc C sf t � }tjtjddd�d�}|�|� t�� }|�d|�� � | �|j |g� | � |j d j � dS )z� The L{RRHeader} instances created by L{Message} from a non-authoritative message are marked as not authoritative. rl r rh r_ s N) r r rq rv rW r_ rm rX r rp rT r7 �r �bufr6 �messager r r � test_nonAuthoritativeMessage� s �� z)MessageTests.test_nonAuthoritativeMessagec C sl t � }tjtjddd�d�}|�|� t�� }|�d|�� � d|_| � |j |g� | � |j d j� dS )z� The L{RRHeader} instances created by L{Message} from an authoritative message are marked as authoritative. rl r rh r_ s TN) r r rq rv rW r_ rm rX r7 r rp � assertTrueri r r r �test_authoritativeMessage� s �� z&MessageTests.test_authoritativeMessageN)r& r' r( r/ r r r$ r) r- r/ r1 r2 r4 r< rC rN rR rV r� rh rl rn r r r r r � s( r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�MessageComparisonTestszD Tests for the rich comparison of L{dns.Message} instances. c O sl |� dg �}|� dg �}|� dg �}|� dg �}tjdi |��}|r%||_|r*||_|r/||_|r4||_|S )a� Create a L{dns.Message}. The L{dns.Message} constructor doesn't accept C{queries}, C{answers}, C{authority}, C{additional} arguments, so we extract them from the kwargs supplied to this factory function and assign them to the message. @param args: Positional arguments. @param kwargs: Keyword arguments. @return: A L{dns.Message} instance. rn rp rM rs Nr )�popr r_ rn rp rM rs )r �args�kwargsrn rp rM rs r( r r r �messageFactory� s z%MessageComparisonTests.messageFactoryc C �* | � | jdd�| jdd�| jdd�� dS )zd Two L{dns.Message} instances compare equal if they have the same id value. r7 �r? r| N��"assertNormalEqualityImplementationrs r r r r �test_id � �z MessageComparisonTests.test_idc C rt )zg Two L{dns.Message} instances compare equal if they have the same answer flag. r� �r6 r Nrv r r r r � test_answer ry z"MessageComparisonTests.test_answerc C rt )zh Two L{dns.Message} instances compare equal if they have the same opCode value. r7 �r@ r| Nrv r r r r � test_opCode ry z"MessageComparisonTests.test_opCodec C rt )zg Two L{dns.Message} instances compare equal if they have the same recDes flag. r� �r9 r Nrv r r r r � test_recDes! ry z"MessageComparisonTests.test_recDesc C rt )zf Two L{dns.Message} instances compare equal if they have the same recAv flag. r� �r: r Nrv r r r r � test_recAv, ry z!MessageComparisonTests.test_recAvc C rt )ze Two L{dns.Message} instances compare equal if they have the same auth flag. r� �r7 r Nrv r r r r � test_auth7 ry z MessageComparisonTests.test_authc C rt )zg Two L{dns.Message} instances compare equal if they have the same rCode value. r7 �rA r| Nrv r r r r � test_rCodeB ry z!MessageComparisonTests.test_rCodec C rt )zf Two L{dns.Message} instances compare equal if they have the same trunc flag. r� �r8 r Nrv r r r r � test_truncM ry z!MessageComparisonTests.test_truncc C rt )zi Two L{dns.Message} instances compare equal if they have the same maxSize value. r7 �rB r| Nrv r r r r � test_maxSizeX ry z#MessageComparisonTests.test_maxSizec C rt )zn Two L{dns.Message} instances compare equal if they have the same authenticData flag. r� r r Nrv r r r r �test_authenticDatac ry z)MessageComparisonTests.test_authenticDatac C rt )zq Two L{dns.Message} instances compare equal if they have the same checkingDisabled flag. r� r. r Nrv r r r r �test_checkingDisabledn ry z,MessageComparisonTests.test_checkingDisabledc C �B | � | jt�d�gd�| jt�d�gd�| jt�d�gd�� dS )zc Two L{dns.Message} instances compare equal if they have the same queries. r �rn r� N�rw rs r ro r r r r � test_queriesy � �z#MessageComparisonTests.test_queriesc C �` | � | jtjdt�d�d�gd�| jtjdt�d�d�gd�| jtjdt�d�d�gd�� dS )zc Two L{dns.Message} instances compare equal if they have the same answers. r rl r_ �rp r� �4.3.2.1N�rw rs r rq rv r r r r � test_answers� � ����z#MessageComparisonTests.test_answersc C �f | � | jtjdtjt�� d�gd�| jtjdtjt�� d�gd�| jtjdtjt�� d�gd�� dS )zm Two L{dns.Message} instances compare equal if they have the same authority records. r r� �rM r� N�rw rs r rq �SOAr� r r r r �test_authority� � �������z%MessageComparisonTests.test_authorityc C �` | � | jtjdt�d�d�gd�| jtjdt�d�d�gd�| jtjdt�d�d�gd�� dS )zn Two L{dns.Message} instances compare equal if they have the same additional records. r rl r_ �rs r� Nr� r r r r �test_additional� � �������z&MessageComparisonTests.test_additionalN)r& r' r( r/ rs rx r{ r} r r� r� r� r� r� r� r� r� r� r� r� r r r r ro � s$ ro c @ s" e Zd ZdZdd� Zddd�ZdS )�TestControllerz� Pretend to be a DNS query processor for a DNSDatagramProtocol. @ivar messages: the list of received messages. @type messages: C{list} of (msg, protocol, address) c C s g | _ dS )zG Initialize the controller: create a list of messages. N)�messagesr r r r �__init__� s zTestController.__init__Nc C s | j �|||f� dS )zN Save the message so that it can be checked during the tests. N)r� rb )r ry �proto�addrr r r �messageReceived� r z TestController.messageReceived�N)r& r' r( r/ r� r� r r r r r� � s r� c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�DatagramProtocolTestsz= Test various aspects of L{dns.DNSDatagramProtocol}. c C sD t �� | _t� | _t�| j�| _t� � }| j� |� | jj | j_ dS )zQ Create a L{dns.DNSDatagramProtocol} with a deterministic clock. N) r �Clock�clockr� � controllerr �DNSDatagramProtocolr� r �FakeDatagramTransport�makeConnection� callLater)r � transportr r r �setUp� s zDatagramProtocolTests.setUpc C s, | j �dt�ddd�� | �| jjg � dS )z� Test that when a short datagram is received, datagramReceived does not raise an exception while processing it. r� �UDP� 127.0.0.1i90 N)r� �datagramReceivedr � IPv4Addressr r� r� r r r r �test_truncatedPacket� s z*DatagramProtocolTests.test_truncatedPacketc s� � j �dt�d�g�}� �t� j j�� �d� t�� }t t � j j�� ��|_ tj tj dd�d�g|_� fdd�}|�|� � j �|�� d� |S ) �6 Test content received after a query. �r� iaS r� r� rl �r r_ c � � � | jd j�� d� d S �Nr rl �r rp rk � dottedQuad�r� r r r �cb� � z2DatagramProtocolTests.test_simpleQuery.<locals>.cb)r� �queryr ro r r^ � liveMessages�keysr_ �next�iterr? rq rv rp � addCallbackr� rw )r �dr( r� r r r �test_simpleQuery� s z&DatagramProtocolTests.test_simpleQueryc C s\ | j �dt�d�g�}| �t| j j�d� | j�d� | � |tj � | �t| j j�d� |S )�> Test that query timeouts after some seconds. r� r� r� r7 r � r� r� r ro r r^ r� r� �advance� assertFailure�DNSQueryTimeoutError�r r� r r r �test_queryTimeout s z'DatagramProtocolTests.test_queryTimeoutc C s4 dd� }|| j j_| j �dt�d�g�}| �|t�S )z� Exceptions raised by the transport's write method should be turned into C{Failure}s passed to errbacks of the C{Deferred} returned by L{DNSDatagramProtocol.query}. c S � t d���N�bar�� RuntimeError)rk r� r r r � writeError � z9DatagramProtocolTests.test_writeError.<locals>.writeErrorr� r� �r� r� r] r� r ro r� r� �r r� r� r r r �test_writeError s z%DatagramProtocolTests.test_writeErrorc C s: dd� }|| j _d| j _| j �dt�d�g�}| �|t�S )z� Exception L{CannotListenError} raised by C{listenUDP} should be turned into a C{Failure} passed to errback of the C{Deferred} returned by L{DNSDatagramProtocol.query}. c S s t d d d ��r� )r r r r r �startListeningError# � zCDatagramProtocolTests.test_listenError.<locals>.startListeningErrorNr� r� )r� �startListeningr� r� r ro r� r )r r� r� r r r �test_listenError s z&DatagramProtocolTests.test_listenErrorc C s\ t �� }d|_t jt jdd�d�g|_| j�|�� d� | � | j j d d �� |�� � dS ) z� When receiving a message whose id is not in L{DNSDatagramProtocol.liveMessages} or L{DNSDatagramProtocol.resends}, the message will be received by L{DNSDatagramProtocol.controller}. r� rl r� r_ r� ���r N) r r_ r? rq rv rp r� r� rw r r� r� )r rk r r r �$test_receiveMessageNotInLiveMessages- s $z:DatagramProtocolTests.test_receiveMessageNotInLiveMessagesN) r& r' r( r/ r� r� r� r� r� r� r� r r r r r� � s r� c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �TestTCPControllera Pretend to be a DNS query processor for a DNSProtocol. @ivar connections: A list of L{DNSProtocol} instances which have notified this controller that they are connected and have not yet notified it that their connection has been lost. c C s t �| � g | _d S r� )r� r� � connectionsr r r r r� C s zTestTCPController.__init__c C � | j �|� d S r� )r� rb �r r� r r r �connectionMadeG � z TestTCPController.connectionMadec C r� r� )r� �remover� r r r �connectionLostJ r� z TestTCPController.connectionLostN)r& r' r( r/ r� r� r� r r r r r� : s r� c @ �@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�DNSProtocolTestsz5 Test various aspects of L{dns.DNSProtocol}. c C s@ t �� | _t� | _t�| j�| _| j�t � � � | jj | j_ dS )zI Create a L{dns.DNSProtocol} with a deterministic clock. N) r r� r� r� r� r � DNSProtocolr� r� r �StringTransportr� r r r r r� S s zDNSProtocolTests.setUpc C s< | � | jj| jg� | j�ttd��� | � | jjg � dS )z� L{dns.DNSProtocol} calls its controller's C{connectionMade} method with itself when it is connected to a transport and its controller's C{connectionLost} method when it is disconnected. zFake Connection DoneN)r r� r� r� r� r r r r r r �test_connectionTracking] s z(DNSProtocolTests.test_connectionTrackingc C sZ | j �t�d�g�}| �t| j j�d� | j�d� | � |tj � | �t| j j�d� |S )r� r� r� �< r r� r� r r r r� g s z"DNSProtocolTests.test_queryTimeoutc s� � j �t�d�g�}� �t� j j�� �d� t�� }t t � j j�� ��|_ tj tj dd�d�g|_� fdd�}|�|� |�� }t�dt|��| }� j �|� |S ) r� r� r� rl r� r_ c r� r� r� r� r r r r� | r� z-DNSProtocolTests.test_simpleQuery.<locals>.cb�!H)r� r� r ro r r^ r� r� r_ r� r� r? rq rv rp r� rw �struct�pack� dataReceived)r r� r( r� r� r r r r� r s z!DNSProtocolTests.test_simpleQueryc C s2 dd� }|| j j_| j �t�d�g�}| �|t�S )z� Exceptions raised by the transport's write method should be turned into C{Failure}s passed to errbacks of the C{Deferred} returned by L{DNSProtocol.query}. c S r� r� r� )rk r r r r� � r� z4DNSProtocolTests.test_writeError.<locals>.writeErrorr� r� r� r r r r� � s z DNSProtocolTests.test_writeErrorc C sr t �� }d|_t jt jdd�d�g|_|�� }t�dt |��| }| j � |� | � | j jd d �� |�� � dS ) z� When receiving a message whose id is not in L{DNSProtocol.liveMessages} the message will be received by L{DNSProtocol.controller}. r� rl r� r_ r� r� r N)r r_ r? rq rv rp rw r� r� r^ r� r� r r� r� )r rk r� r r r r� � s $z5DNSProtocolTests.test_receiveMessageNotInLiveMessagesN) r& r' r( r/ r� r� r� r� r� r� r r r r r� N s r� c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4S )5� ReprTestszE Tests for the C{__repr__} implementation of record classes. c C � | � tt�dd��d� dS )z� The repr of a L{dns.Record_NS} instance includes the name of the nameserver and the TTL of the record. r �� z <NS name=example.com ttl=4321>N)r r3 r � Record_NSr r r r �test_ns� r% zReprTests.test_nsc C r� )z� The repr of a L{dns.Record_MD} instance includes the name of the mail destination and the TTL of the record. r r� z <MD name=example.com ttl=4321>N)r r3 r � Record_MDr r r r �test_md� r% zReprTests.test_mdc C r� )z� The repr of a L{dns.Record_MF} instance includes the name of the mail forwarder and the TTL of the record. r r� z <MF name=example.com ttl=4321>N)r r3 r � Record_MFr r r r �test_mf� r% zReprTests.test_mfc C r� )z� The repr of a L{dns.Record_CNAME} instance includes the name of the mail forwarder and the TTL of the record. r r� z!<CNAME name=example.com ttl=4321>N)r r3 r � Record_CNAMEr r r r � test_cname� � �zReprTests.test_cnamec C r� )z} The repr of a L{dns.Record_MB} instance includes the name of the mailbox and the TTL of the record. r r� z <MB name=example.com ttl=4321>N)r r3 r � Record_MBr r r r �test_mb� r% zReprTests.test_mbc C r� )z� The repr of a L{dns.Record_MG} instance includes the name of the mail group member and the TTL of the record. r r� z <MG name=example.com ttl=4321>N)r r3 r � Record_MGr r r r �test_mg� r% zReprTests.test_mgc C r� )z� The repr of a L{dns.Record_MR} instance includes the name of the mail rename domain and the TTL of the record. r r� z <MR name=example.com ttl=4321>N)r r3 r � Record_MRr r r r �test_mr� r% zReprTests.test_mrc C r� )z~ The repr of a L{dns.Record_PTR} instance includes the name of the pointer and the TTL of the record. r r� z <PTR name=example.com ttl=4321>N)r r3 r � Record_PTRr r r r �test_ptr� r� zReprTests.test_ptrc C r� )z� The repr of a L{dns.Record_DNAME} instance includes the name of the non-terminal DNS name redirection and the TTL of the record. r r� z!<DNAME name=example.com ttl=4321>N)r r3 r � Record_DNAMEr r r r � test_dname� r� zReprTests.test_dnamec C r� )z� The repr of a L{dns.Record_A} instance includes the dotted-quad string representation of the address it is for and the TTL of the record. rl i7 z<A address=1.2.3.4 ttl=567>N)r r3 r rv r r r r �test_a� r� zReprTests.test_ac C s* | � ttjddddddddd ��d � d S ) zh The repr of a L{dns.Record_SOA} instance includes all of the authority fields. s mNames rNamerL �� � r7 rL r� )r� r� r� r� r� r� r� ri zZ<SOA mname=mName rname=rName serial=123 refresh=456 retry=789 expire=10 minimum=11 ttl=12>N)r r3 r r� r r r r �test_soa s �� �zReprTests.test_soac C r� )z The repr of a L{dns.Record_NULL} instance includes the repr of its payload and the TTL of the record. s abcdrL z <NULL payload='abcd' ttl=123>N)r r3 r r� r r r r � test_null r% zReprTests.test_nullc C � | � ttjdddd��d� dS )z� The repr of a L{dns.Record_WKS} instance includes the dotted-quad string representation of the address it is for, the IP protocol number it is for, and the TTL of the record. z2.3.4.5rI r� rh z&<WKS address=2.3.4.5 protocol=7 ttl=8>N)r r3 r r� r r r r �test_wks$ s �zReprTests.test_wksc C s | � ttjddd��d� dS )z� The repr of a L{dns.Record_AAAA} instance includes the colon-separated hex string representation of the address it is for and the TTL of the record. z 8765::1234r7 rh z <AAAA address=8765::1234 ttl=10>N)r r3 r r� r r r r � test_aaaa/ s �zReprTests.test_aaaac C s" | � ttjddddd��d� dS )z� The repr of a L{dns.Record_A6} instance includes the colon-separated hex string representation of the address it is for and the TTL of the record. r z 1234::5678re r7 rh z,<A6 suffix=1234::5678 prefix=foo.bar ttl=10>N)r r3 r r� r r r r �test_a6: s �zReprTests.test_a6c C s" | � tt�ddddd��d� dS )z� The repr of a L{dns.Record_SRV} instance includes the name and port of the target and the priority, weight, and TTL of the record. r� r� r� r� r� z9<SRV priority=1 weight=2 target=example.org port=3 ttl=4>N)r r3 r r� r r r r �test_srvE s �zReprTests.test_srvc C s* t �ddddddd�}| �t|�d� d S ) z� The repr of a L{dns.Record_NAPTR} instance includes the order, preference, flags, service, regular expression, replacement, and TTL of the record. r� rJ � S� https /foo/bar/i� bazr� zY<NAPTR order=5 preference=9 flags=S service=http regexp=/foo/bar/i replacement=baz ttl=3>N)r r� r r3 �r r� r r r � test_naptrO s �zReprTests.test_naptrc C � | � tt�ddd��d� dS )z{ The repr of a L{dns.Record_AFSDB} instance includes the subtype, hostname, and TTL of the record. r� r� r� z,<AFSDB subtype=3 hostname=example.org ttl=5>N)r r3 r r� r r r r � test_afsdb\ � �zReprTests.test_afsdbc C r )zw The repr of a L{dns.Record_RP} instance includes the mbox, txt, and TTL fields of the record. r� s admin.example.comr� z7<RP mbox=alice.example.com txt=admin.example.com ttl=3>N)r r3 r r� r r r r �test_rpf r zReprTests.test_rpc C r )zx The repr of a L{dns.Record_HINFO} instance includes the cpu, os, and TTL fields of the record. s sparcs minixr� z%<HINFO cpu='sparc' os='minix' ttl=12>N)r r3 r r r r r r � test_hinfop r zReprTests.test_hinfoc C s" t �ddd�}| �t|�d� dS )z� The repr of a L{dns.Record_MINFO} instance includes the rmailbx, emailbx, and TTL fields of the record. r� � bob.example.com� zF<MINFO responsibility=alice.example.com errors=bob.example.com ttl=15>N)r r r r3 r r r r � test_minfoz s �zReprTests.test_minfoc C r )z~ The repr of a L{dns.Record_MX} instance includes the preference, name, and TTL fields of the record. � s mx.example.comr� z,<MX preference=13 name=mx.example.com ttl=2>N)r r3 r r r r r r �test_mx� r zReprTests.test_mxc C r )zr The repr of a L{dns.Record_TXT} instance includes the data and ttl fields of the record. r� r� r rh z <TXT data=['foo', 'bar'] ttl=15>N)r r3 r r r r r r �test_txt� � �zReprTests.test_txtc C r )zr The repr of a L{dns.Record_SPF} instance includes the data and ttl fields of the record. r� r� r rh z <SPF data=['foo', 'bar'] ttl=15>N)r r3 r � Record_SPFr r r r �test_spf� r# zReprTests.test_spfc C r� )zu The repr of a L{dns.UnknownRecord} instance includes the data and ttl fields of the record. s foo barr� z"<UNKNOWN data='foo\x1fbar' ttl=12>N)r r3 r rr r r r r r{ � r� zReprTests.test_unknownN) r& r' r( r/ r� r� r� r� r r r r r r r r r r r r r r r r r r! r" r% r{ r r r r r� � s6 r� c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBS )C� EqualityTestszM Tests for the equality and non-equality behavior of record classes. c C s | � |||�S r� )rw )r � firstValueOne�secondValueOne�valueTwor r r � _equalityTest� s �zEqualityTests._equalityTestc C �$ | � t�d�t�d�t�d�� dS )zt Two L{dns.Charstr} instances compare equal if and only if they have the same string value. � abc� defN)r* r r� r r r r � test_charstr� s �zEqualityTests.test_charstrc C r+ )zo Two L{dns.Name} instances compare equal if and only if they have the same name value. r, r- N)r* r r$ r r r r r� � s $zEqualityTests.test_namec C sD | � |dd�|dd�|dd�� | � |dd�|dd�|dd�� dS )z� Assert that instances of C{cls} with the same attributes compare equal to each other and instances with different attributes compare as not equal. @param cls: A L{dns.SimpleRecord} subclass. r rL iA r� N)r* )r rg r r r �_simpleEqualityTest� s ��z!EqualityTests._simpleEqualityTestc C s~ | � tjdt�d�d�tjdt�d�d�tjdt�d�d�� | � tjdt�d�d�tjdt�d�d�tjdt�d�d�� | � t�dtj�t�dtj�t�dtj�� | � tjdtjt�d�d�tjdtjt�d�d�tjdtjt�d�d�� | � tjddt�d�d�tjddt�d�d�tjdd t�d�d�� | � tjdd t�d�d �tjdd t�d�d �tjdd t�d�d �� d S )z� Two L{dns.RRHeader} instances compare equal if and only if they have the same name, type, class, time to live, payload, and authoritative bit. r rl r_ r� �1.2.3.5)rg rk r� )ri rk r< r� )r7 rk r N)r* r rq rv rt �MXru �CSr r r r � test_rrheader� s< �� ����zEqualityTests.test_rrheaderc C � | � tj� dS )zv Two L{dns.Record_NS} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r� � zEqualityTests.test_nsc C r4 �zv Two L{dns.Record_MD} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r� r5 zEqualityTests.test_mdc C r4 )zv Two L{dns.Record_MF} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r� r5 zEqualityTests.test_mfc C r4 )zy Two L{dns.Record_CNAME} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r� r5 zEqualityTests.test_cnamec C r4 )zv Two L{dns.Record_MB} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r & r5 zEqualityTests.test_mbc C r4 )zv Two L{dns.Record_MG} instances compare equal if and only if they have the same name and TTL. N)r/ r r r r r r r - r5 zEqualityTests.test_mgc C r4 )zv Two L{dns.Record_MR} instances compare equal if and only if they have the same name and TTL. N)r/ r r r r r r r 4 r5 zEqualityTests.test_mrc C r4 )zw Two L{dns.Record_PTR} instances compare equal if and only if they have the same name and TTL. N)r/ r r r r r r r ; r5 zEqualityTests.test_ptrc C r4 r6 )r/ r r r r r r r B r5 zEqualityTests.test_dnamec C sP | � t�dd�t�dd�t�dd�� | � t�dd�t�dd�t�dd�� dS )zx Two L{dns.Record_A} instances compare equal if and only if they have the same address and TTL. rl r� rG r0 N)r* r rv r r r r r I � � �zEqualityTests.test_ac C sT | � t�dddddddd�t�dddddddd�t�d ddddddd�� | � t�dddddddd�t�dddddddd�t�dd dddddd�� | � t�dddddddd�t�dddddddd�t�ddd ddddd�� | � t�dddddddd�t�dddddddd�t�dddd dddd�� | � t�dddddddd�t�dddddddd�t�ddddd ddd�� | � t�dddddddd�t�dddddddd�t�dddddd dd�� | � t�dddddddd�t�dddddddd�t�ddddddd d�� | � t�dddddddd�t�dddddddd�t�dd dddddd �� d S ) z� Two L{dns.Record_SOA} instances compare equal if and only if they have the same mname, rname, serial, refresh, minimum, expire, retry, and ttl. s mnames rnamerL r r r7 r| r= s xnamer� N)r* r r� r r r r r [ sP ��������zEqualityTests.test_soac C �P | � t�dd�t�dd�t�dd�� | � t�dd�t�dd�t�dd�� dS )z{ Two L{dns.Record_NULL} instances compare equal if and only if they have the same payload and ttl. zfoo barr7 zbar foor� N)r* r r� r r r r r � r7 zEqualityTests.test_nullc C �� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� d S ) z� Two L{dns.Record_WKS} instances compare equal if and only if they have the same address, protocol, map, and ttl. rl r� �foor� r� r� r� �� N)r* r r� r r r r r � �( ����zEqualityTests.test_wksc C r8 )z{ Two L{dns.Record_AAAA} instances compare equal if and only if they have the same address and ttl. z1::2r� z2::1r7 N)r* r r� r r r r r � r7 zEqualityTests.test_aaaac C r9 ) z� Two L{dns.Record_A6} instances compare equal if and only if they have the same prefix, prefix length, suffix, and ttl. r, z::abcdr r7 r} z::abcd:0r� r� N)r* r r� r r r r r � s( ����zEqualityTests.test_a6c C s | � t�ddddd�t�ddddd�t�ddddd�� | � t�ddddd�t�ddddd�t�ddddd�� | � t�ddddd�t�ddddd�t�ddddd�� | � t�ddddd�t�ddddd�t�dddd d�� | � t�ddddd�t�ddddd�t�ddddd �� d S ) z� Two L{dns.Record_SRV} instances compare equal if and only if they have the same priority, weight, port, target, and ttl. r7 r| r= r r> r� r; i, r� � N)r* r r� r r r r r � s2 �����zEqualityTests.test_srvc C s� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� dS )z� Two L{dns.Record_SSHFP} instances compare equal if and only if they have the same key type, fingerprint type, fingerprint, and ttl. r� r� s happydayr> s happxday�- N)r* r r� r r r r � test_sshfp r< zEqualityTests.test_sshfpc C s� | � t�ddddddd�t�ddddddd�t�ddddddd�� | � t�ddddddd�t�ddddddd�t�ddddddd�� | � t�ddddddd�t�ddddddd�t�ddd dddd�� | � t�ddddddd�t�ddddddd�t�dddd ddd�� | � t�ddddddd�t�ddddddd�t�ddddd dd�� | � t�ddddddd�t�ddddddd�t�ddddd d d�� | � t�ddddddd�t�ddddddd�t�ddddd dd �� dS )z� Two L{dns.Record_NAPTR} instances compare equal if and only if they have the same order, preference, flags, service, regexp, replacement, and ttl. r� r� r� r� s /foo/bar/r r� r� � pr s /bar/foo/s quuxr� N)r* r r� r r r r r 7 sF �������zEqualityTests.test_naptrc C s� | � t�ddd�t�ddd�t�ddd�� | � t�ddd�t�ddd�t�ddd�� | � t�ddd�t�ddd�t�ddd�� dS )z� Two L{dns.Record_AFSDB} instances compare equal if and only if they have the same subtype, hostname, and ttl. r� r r� r� r� N)r* r r� r r r r r h � � � �zEqualityTests.test_afsdbc C � | � t�ddd�t�ddd�t�ddd�� | � t�ddd�t�ddd�t�ddd�� | � t�ddd�t�ddd�t�ddd�� dS )zx Two L{Record_RP} instances compare equal if and only if they have the same mbox, txt, and ttl. r� s alice is nicer7 r s alice is not nicer� N)r* r r� r r r r r � rA zEqualityTests.test_rpc C rB )z} Two L{dns.Record_HINFO} instances compare equal if and only if they have the same cpu, os, and ttl. zx86-64�plan9r7 �i386�plan11r� N)r* r r r r r r r � rA zEqualityTests.test_hinfoc C rB )z� Two L{dns.Record_MINFO} instances compare equal if and only if they have the same rmailbx, emailbx, and ttl. s rmailboxs emailboxr7 s someplaces somethingr� N)r* r r r r r r r � rA zEqualityTests.test_minfoc C rB )z� Two L{dns.Record_MX} instances compare equal if and only if they have the same preference, name, and ttl. r7 r� r| r� s example.netr; N)r* r r r r r r r! � rA zEqualityTests.test_mxc C � | � tjdddd�tjdddd�tjddddd�� | � tjdddd�tjdddd�tjdddd�� | � tjdddd�tjdddd�tjdddd�� dS )zw Two L{dns.Record_TXT} instances compare equal if and only if they have the same data and ttl. r: r� r7 rh �bazr� N)r* r r r r r r r" � � ���zEqualityTests.test_txtc C rF )zs L{dns.Record_SPF} instances compare equal if and only if they have the same data and ttl. r: r� r7 rh rG r� N)r* r r$ r r r r r% � rH zEqualityTests.test_spfc C s� dddddt jddd�}d d d d d t jddd�}|�� D ]%}|�� }|| ||< | �t jdi |��t jdi |��t jdi |��� q dS )z� L{dns.Record_TSIG} instances compare equal if and only if they have the same RDATA (algorithm, timestamp, MAC, etc.) and ttl. z hmac-sha224r r� s �c r� r> )r� r r r r r r ri z hmac-sha512i�pUZr s i�� � r= Nr )r �OKr r� �copyr* r )r �baseargs�altargs�kw�alteredr r r � test_tsig s6 � � ��zEqualityTests.test_tsigc C s� | � tjddd�tjddd�tjddd�� | � tjddd�tjddd�tjddd�� | � tjddd�tjddd�tjddd�� dS )zv L{dns.UnknownRecord} instances compare equal if and only if they have the same data and ttl. r: r7 rh �foobarr� r� N)r* r rr r r r r r{ 2 rA zEqualityTests.test_unknownN)$r& r' r( r/ r* r. r� r/ r3 r� r� r� r� r r r r r r r r r r r r r? r r r r r r! r" r% rQ r{ r r r r r& � sD 17 !$ 1 "r& c @ r� ) � RRHeaderTestsz2 Tests for L{twisted.names.dns.RRHeader}. c C �& | � ttjdtjtjdt�d�� dS )z� Attempting to create a L{dns.RRHeader} instance with a negative TTL causes L{ValueError} to be raised. r r� r� N�r" rH r rq rt ru rv r r r r �test_negativeTTLP � �z RRHeaderTests.test_negativeTTLc C s6 d}t �dt jt j|t �d��}| �|jt|�� dS )z< L{dns.RRHeader} converts TTLs to integers. g������^@r r� N)r rq rt ru rv r ri �int)r � ttlAsFloat�headerr r r �test_nonIntegralTTL_ s �z!RRHeaderTests.test_nonIntegralTTLc C rT )z� Attempting to create a L{dns.RRHeader} instance with a TTL that L{int} cannot convert to an integer raises a L{TypeError}. r zthis is not a numberr� NrU r r r r �!test_nonNumericTTLRaisesTypeErrori rW z/RRHeaderTests.test_nonNumericTTLRaisesTypeErrorN)r& r' r( r/ rV r[ r\ r r r r rS K s rS c @ r� )�NameToLabelsTestsz7 Tests for L{twisted.names.dns._nameToLabels}. c C s | � t�d�dg� dS )zp L{dns._nameToLabels} returns a list containing a single empty label for an empty name. r� N�r r � _nameToLabelsr r r r � test_empty~ r5 z NameToLabelsTests.test_emptyc C s | � t�d�dg� dS )z L{dns._nameToLabels} returns a list containing a single empty label for a name containing only a dot. � .r� Nr^ r r r r � test_onlyDot� r5 z NameToLabelsTests.test_onlyDotc C s | � t�d�ddg� dS )z{ L{dns._nameToLabels} returns a list ending with an empty label for a name without a trailing dot. � comr� Nr^ r r r r �test_withoutTrailingDot� r! z)NameToLabelsTests.test_withoutTrailingDotc C s | � t�d�ddg� dS )zx L{dns._nameToLabels} returns a list ending with an empty label for a name with a trailing dot. s com.rc r� Nr^ r r r r �test_withTrailingDot� r! z&NameToLabelsTests.test_withTrailingDotc C � | � t�d�g d�� dS )zt L{dns._nameToLabels} returns a list containing entries for all labels in a subdomain name. s foo.bar.baz.example.com.)r� r� r s examplerc r� Nr^ r r r r �test_subdomain� s �z NameToLabelsTests.test_subdomainc C rf )z` L{dns._nameToLabels} preserves the case of ascii characters in labels. � EXAMPLE.COM)s EXAMPLEs COMr� Nr^ r r r r �test_casePreservation� r! z'NameToLabelsTests.test_casePreservationN) r& r' r( r/ r` rb rd re rg ri r r r r r] y s r] c C �" | � t�||�|�d|��� dS )a\ Assert that C{descendant} *is* a subdomain of C{ancestor}. @type testCase: L{unittest.SynchronousTestCase} @param testCase: The test case on which to run the assertions. @type descendant: C{str} @param descendant: The subdomain name to test. @type ancestor: C{str} @param ancestor: The superdomain name to test. z is not a subdomain of N)rm r �_isSubdomainOf��testCase� descendant�ancestorr r r �assertIsSubdomainOf� � �rp c C rj )a` Assert that C{descendant} *is not* a subdomain of C{ancestor}. @type testCase: L{unittest.SynchronousTestCase} @param testCase: The test case on which to run the assertions. @type descendant: C{str} @param descendant: The subdomain name to test. @type ancestor: C{str} @param ancestor: The superdomain name to test. z is a subdomain of N)rT r rk rl r r r �assertIsNotSubdomainOf� rq rr c @ sp e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� ZdS )�IsSubdomainOfTestsz8 Tests for L{twisted.names.dns._isSubdomainOf}. c C s t | dd� dS )z[ L{dns._isSubdomainOf} returns C{True} for identical domain names. r N�rp r r r r �test_identical� r5 z!IsSubdomainOfTests.test_identicalc C � t | dd� dS )z� L{dns._isSubdomainOf} returns C{True} when the first name is an immediate descendant of the second name. rV r Nrt r r r r � test_parent� r5 z IsSubdomainOfTests.test_parentc C rv )z L{dns._isSubdomainOf} returns C{True} when the first name is a distant descendant of the second name. s foo.bar.baz.example.comrc Nrt r r r r �test_distantAncestor� r5 z'IsSubdomainOfTests.test_distantAncestorc C rv )zw L{dns._isSubdomainOf} returns C{False} when the first name is an ancestor of the second name. r rV N�rr r r r r �test_superdomain� r5 z#IsSubdomainOfTests.test_superdomainc C rv )zs L{dns._isSubdomainOf} returns C{False} if the first name is a sibling of the second name. rV s bar.example.comNry r r r r � test_sibling� r5 z IsSubdomainOfTests.test_siblingc C rv )zx L{dns._isSubdomainOf} returns C{False} even when domain names happen to share a common suffix. s foo.myexample.comr Nry r r r r �test_unrelatedCommonSuffix� r5 z-IsSubdomainOfTests.test_unrelatedCommonSuffixc C rv )z� L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name but the first name has a trailing ".". � foo.example.com.r Nrt r r r r � test_subdomainWithTrailingDot � z0IsSubdomainOfTests.test_subdomainWithTrailingDotc C rv )z� L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name but the second name has a trailing ".". rV � example.com.Nrt r r r r � test_superdomainWithTrailingDot r z2IsSubdomainOfTests.test_superdomainWithTrailingDotc C rv )z� L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name and both names have a trailing ".". r} r� Nrt r r r r �test_bothWithTrailingDot r z+IsSubdomainOfTests.test_bothWithTrailingDotc C rv )zw L{dns._isSubdomainOf} returns C{False} if the first name is empty and the second name is not. r� r Nry r r r r �test_emptySubdomain r5 z&IsSubdomainOfTests.test_emptySubdomainc C rv )zv L{dns._isSubdomainOf} returns C{True} if the second name is empty and the first name is not. rV r� Nrt r r r r �test_emptySuperdomain r5 z(IsSubdomainOfTests.test_emptySuperdomainc C s t | dd� t | dd� dS )z` L{dns._isSubdomainOf} does case-insensitive comparison of name labels. rV rh s FOO.EXAMPLE.COMr Nrt r r r r � test_caseInsensitiveComparison' s z1IsSubdomainOfTests.test_caseInsensitiveComparisonN)r& r' r( r/ ru rw rx rz r{ r| r~ r� r� r� r� r� r r r r rs � s rs c @ s* e Zd ZdZeddd��Zedd� �ZdS ) �OPTNonStandardAttributesz� Generate byte and instance representations of an L{dns._OPTHeader} where all attributes are set to non-default values. For testing whether attributes have really been read from the byte string during decoding. Fc C s d}|rd}d| S )aT Return L{bytes} representing an encoded OPT record. @param excludeName: A flag that controls whether to exclude the name field. This allows a non-standard name to be prepended during the test. @type excludeName: L{bool} @param excludeOptions: A flag that controls whether to exclude the RDLEN field. This allows encoded variable options to be appended during the test. @type excludeOptions: L{bool} @return: L{bytes} representing the encoded OPT record returned by L{object}. rJ r� s ) � r )rg � excludeName�excludeOptions�rdlenr r r rP : s �z OPTNonStandardAttributes.bytesc C s t jddddd�S )z� Return a new L{dns._OPTHeader} instance. @return: A L{dns._OPTHeader} instance with attributes that match the encoded record returned by L{bytes}. � r� r� T)�udpPayloadSize� extendedRCODE�version�dnssecOK)r � _OPTHeader�rg r r r r2 Y s �z OPTNonStandardAttributes.objectN)FF)r& r' r( r/ � classmethodrP r2 r r r r r� 1 s r� c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@S )A�OPTHeaderTestsz4 Tests for L{twisted.names.dns._OPTHeader}. c C � t tjtj� dS )zA L{dns._OPTHeader} implements L{dns.IEncodable}. N)r r � IEncodabler� r r r r �test_interfacek � z OPTHeaderTests.test_interfacec C s | � t�� jt�d�� dS )zq L{dns._OPTHeader.name} is an instance attribute whose value is fixed as the root domain r� N)r r r� rO r$ r r r r r� q s zOPTHeaderTests.test_namec C s$ t �� }| �tt|dt �d�� dS )z5 L{dns._OPTHeader.name} is readonly. rO r N)r r� r" �AttributeError�setattrr$ �r �hr r r �test_nameReadonlyx s z OPTHeaderTests.test_nameReadonlyc C r )z^ L{dns._OPTHeader.type} is an instance attribute with fixed value 41. �) N)r r r� rf r r r r � test_type r zOPTHeaderTests.test_typec C s t �� }| �tt|dt j� dS )z5 L{dns._OPTHeader.type} is readonly. rf N)r r� r" r� r� rt r� r r r �test_typeReadonly� s z OPTHeaderTests.test_typeReadonlyc C r )zt L{dns._OPTHeader.udpPayloadSize} defaults to 4096 as recommended in rfc6891 section-6.2.5. � N�r r r� r� r r r r �test_udpPayloadSize� r z"OPTHeaderTests.test_udpPayloadSizec C r )z` L{dns._OPTHeader.udpPayloadSize} can be overridden in the constructor. r� �r� Nr� r r r r �test_udpPayloadSizeOverride� r! z*OPTHeaderTests.test_udpPayloadSizeOverridec C r )z@ L{dns._OPTHeader.extendedRCODE} defaults to 0. r N�r r r� r� r r r r �test_extendedRCODE� r z!OPTHeaderTests.test_extendedRCODEc C r )z_ L{dns._OPTHeader.extendedRCODE} can be overridden in the constructor. r� �r� Nr� r r r r �test_extendedRCODEOverride� r! z)OPTHeaderTests.test_extendedRCODEOverridec C r )z: L{dns._OPTHeader.version} defaults to 0. r N�r r r� r� r r r r � test_version� r zOPTHeaderTests.test_versionc C r )zY L{dns._OPTHeader.version} can be overridden in the constructor. r� �r� Nr� r r r r �test_versionOverride� r! z#OPTHeaderTests.test_versionOverridec C s | � t�� j� dS )z? L{dns._OPTHeader.dnssecOK} defaults to False. N)rT r r� r� r r r r � test_dnssecOK� rJ z OPTHeaderTests.test_dnssecOKc C s | � tjdd�j� dS )zZ L{dns._OPTHeader.dnssecOK} can be overridden in the constructor. T�r� N)rm r r� r� r r r r �test_dnssecOKOverride� r5 z$OPTHeaderTests.test_dnssecOKOverridec C s | � t�� jg � dS )zC L{dns._OPTHeader.options} defaults to empty list. N)r r r� �optionsr r r r � test_options� r zOPTHeaderTests.test_optionsc C s" t jdgd�}| �|jdg� dS )zY L{dns._OPTHeader.options} can be overridden in the constructor. )r� r� � �r� N)r r� r r� r� r r r �test_optionsOverride� s z#OPTHeaderTests.test_optionsOverridec C s, t � }t�� �|� | �|�� t�� � dS )z� L{dns._OPTHeader.encode} packs the header fields and writes them to a file like object passed in as an argument. N)r r� r2 rW r rX rP )r �br r r r[ � s zOPTHeaderTests.test_encodec C sR t �� }t�dd�t�dd�g|_t� }|�|� | �|�� t j dd�d � dS ) z� L{dns._OPTHeader.options} is a list of L{dns._OPTVariableOption} instances which are packed into the rdata area of the header. r� � foobarbazr� � quxT�r� � foobarbaz quxN) r� r2 r �_OPTVariableOptionr� r rW r rX rP )r r� r� r r r �test_encodeWithOptions� s � ��z%OPTHeaderTests.test_encodeWithOptionsc C s. t �� }|�tt�� �� | �|t�� � dS )z� L{dns._OPTHeader.decode} unpacks the header fields from a file like object and populates the attributes of an existing L{dns._OPTHeader} instance. N)r r� rS r r� rP r r2 )r � decodedHeaderr r r rU � s zOPTHeaderTests.test_decodec C s: t t�� �}t�� }|�|� | �|�� t|� � �� dS )zk L{dns._OPTHeader.decode} reads all the bytes of the record that is being decoded. N� r r� rP r r� rS r r� r^ rX �r r� r� r r r �test_decodeAllExpectedBytes s z*OPTHeaderTests.test_decodeAllExpectedBytesc C sF t t�� d �}t�� }|�|� | �|�� t|� � �td� � dS )z� L{dns._OPTHeader.decode} reads only the bytes from the current file position to the end of the record that is being decoded. Trailing bytes are not consumed. s xxxxNr� r� r r r � test_decodeOnlyExpectedBytes s $z+OPTHeaderTests.test_decodeOnlyExpectedBytesc C s> t tjdd�d �}t�� }|�|� | �|jt�d�� dS )z� L{dns._OPTHeader.decode} discards the name which is encoded in the supplied bytes. The name attribute of the resulting L{dns._OPTHeader} instance will always be L{dns.Name(b'')}. T)r� rR r� N) r r� rP r r� rS r rO r$ �r r� r� r r r �test_decodeDiscardsName s � z&OPTHeaderTests.test_decodeDiscardsNamec C �0 t tjdd�d �}t�� }| �t|j|� dS )zj L{dns._OPTHeader.decode} raises an exception if the supplied RDLEN is too short. Tr� s N�r r� rP r r� r" rP rS r� r r r �test_decodeRdlengthTooShort( � �� z*OPTHeaderTests.test_decodeRdlengthTooShortc C r� )zi L{dns._OPTHeader.decode} raises an exception if the supplied RDLEN is too long. Tr� s Nr� r� r r r �test_decodeRdlengthTooLong9 r� z)OPTHeaderTests.test_decodeRdlengthTooLongc C sL t tjdd�d �}t�� }|�|� | �|jt�dd�t�dd�g� dS ) z� If the OPT bytes contain variable options, L{dns._OPTHeader.decode} will populate a list L{dns._OPTHeader.options} with L{dns._OPTVariableOption} instances. Tr� r� r� r� r� r� N) r r� rP r r� rS r r� r� r� r r r �test_decodeWithOptionsJ s �� ��z%OPTHeaderTests.test_decodeWithOptionsc C sX t jdt jddt �d�d�}t j�|�}t jddddt jdd d �gd �}| �||� d S ) z� L{_OPTHeader.fromRRHeader} accepts an L{RRHeader} instance and returns an L{_OPTHeader} instance whose attribute values have been derived from the C{cls}, C{ttl} and C{payload} attributes of the original header. r r l �} s �� abcrj � � Tr, )�code�data)r� r� r� r� r� N)r rq �OPTrr r� � fromRRHeaderr� r )r � genericHeader�decodedOptHeader�expectedOptHeaderr r r �test_fromRRHeaderi s � �z OPTHeaderTests.test_fromRRHeaderc C s | � tt�� �d� dS )z� L{dns._OPTHeader.__repr__} displays the name and type and all the fixed and extended header values of the OPT record. zb<_OPTHeader name= type=41 udpPayloadSize=4096 extendedRCODE=0 version=0 dnssecOK=False options=[]>N)r r3 r r� r r r r � test_repr� s �zOPTHeaderTests.test_reprc C �* | � tjdd�tjdd�tjdd�� dS )zh Two L{OPTHeader} instances compare equal if they have the same udpPayloadSize. r� r� r� N�rw r r� r r r r �test_equalityUdpPayloadSize� ry z*OPTHeaderTests.test_equalityUdpPayloadSizec C r� )zg Two L{OPTHeader} instances compare equal if they have the same extendedRCODE. r� r� r� Nr� r r r r �test_equalityExtendedRCODE� ry z)OPTHeaderTests.test_equalityExtendedRCODEc C r� )za Two L{OPTHeader} instances compare equal if they have the same version. r� r� r� Nr� r r r r �test_equalityVersion� ry z#OPTHeaderTests.test_equalityVersionc C r� )zh Two L{OPTHeader} instances compare equal if they have the same dnssecOK flags. Tr� FNr� r r r r �test_equalityDnssecOK� ry z$OPTHeaderTests.test_equalityDnssecOKc C sH | � tjt�dd�gd�tjt�dd�gd�tjt�dd�gd�� dS )za Two L{OPTHeader} instances compare equal if they have the same options. r� � xr� r� � yN)rw r r� r� r r r r �test_equalityOptions� s �z#OPTHeaderTests.test_equalityOptionsN)#r& r' r( r/ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r[ r� rU r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� f sB r� c @ r� )�OPTVariableOptionTestsz. Tests for L{dns._OPTVariableOption}. c C r� )zI L{dns._OPTVariableOption} implements L{dns.IEncodable}. N)r r r� r� r r r r r� � r� z%OPTVariableOptionTests.test_interfacec C s, t �dd�}| �|jd� | �|jd� dS )z� L{dns._OPTVariableOption.__init__} requires code and data arguments which are saved as public instance attributes. r� r� N)r r� r r� r� r� r r r �test_constructorArguments� s z0OPTVariableOptionTests.test_constructorArgumentsc C r� )zf L{dns._OPTVariableOption.__repr__} displays the code and data of the option. r� r� z"<_OPTVariableOption code=1 data=x>N)r r3 r r� r r r r r� � r� z OPTVariableOptionTests.test_reprc C r8 )zs Two OPTVariableOption instances compare equal if they have the same code and data values. r� r� r� r� N)rw r r� r r r r r� � s � �z$OPTVariableOptionTests.test_equalityc C s0 t �dd�}t� }|�|� | �|�� d� dS )z� L{dns._OPTVariableOption.encode} encodes the code and data instance attributes to a byte string which also includes the data length. r� � foobar� foobarN)r r� r rW r rX )r �or� r r r r[ � s �z"OPTVariableOptionTests.test_encodec C s: t d�}t�� }|�|� | �|jd� | �|jd� dS )z� L{dns._OPTVariableOption.decode} is a classmethod that decodes a byte string and returns a L{dns._OPTVariableOption} instance. r� r� r� N)r r r� rS r r� r� )r r� r� r r r rU s � z"OPTVariableOptionTests.test_decodeN) r& r' r( r/ r� r� r� r� r[ rU r r r r r� � s r� c @ r) )� RaisedArgszp An exception which can be raised by fakes to test that the fake is called with expected arguments. c C s || _ || _dS )z� Store the positional and keyword arguments as attributes. @param args: The positional args. @param kwargs: The keyword args. N�rq rr �r rq rr r r r r� # s zRaisedArgs.__init__N)r& r' r( r/ r� r r r r r� s r� c @ �( e Zd ZdZedd� �Zedd� �ZdS )� MessageEmptyz^ Generate byte string and constructor arguments for an empty L{dns._EDNSMessage}. c C � dS )�� Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. s �� r r� r r r rP 4 � �zMessageEmpty.bytesc C s t ddtjddddddd� S )�� Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. rS Tr N� r? r6 r@ r7 r8 r9 r: rA � ednsVersion)�dictr � OP_STATUSr� r r r rr G s �zMessageEmpty.kwargsN�r& r' r( r/ r� rP rr r r r r r� . s r� c @ r� )�MessageTruncatedz= An empty response message whose TR bit is set to 1. c C r� )r� s � r r� r r r rP a r� zMessageTruncated.bytesc C s t dddddddddd� S )r� rS r� r Nr� )r� r� r r r rr t s �zMessageTruncated.kwargsNr� r r r r r� \ s r� c @ r� )�MessageNonAuthoritativez. A minimal non-authoritative message. c C r� )r� s r r� r r r rP � r� z MessageNonAuthoritative.bytesc C s( t dddtjdtjddd�dd�gd �S ) r� rS r Nr� rl rh F�rk r7 �r? r7 r� rp �r� r rq rv r� r r r rr � � ��z MessageNonAuthoritative.kwargsNr� r r r r r� � � r� c @ r� )�MessageAuthoritativez* A minimal authoritative message. c C r� )r� s r r� r r r rP � r� zMessageAuthoritative.bytesc C s( t dddtjdtjddd�dd �gd �S ) r� rS r� Nr� rl r rh Tr� r� r� r� r r r rr � r� zMessageAuthoritative.kwargsNr� r r r r r� � r� r� c @ r� )�MessageCompletez� An example of a fully populated non-edns response message. Contains name compression, answers, authority, and additional records. c C r� )r� sn �� examplecom � ���� 'ns1� hostmaster� ������������������ ���� �)�) ���� r r� r r r rP � r� zMessageComplete.bytesc C s� t ddtjdddddt�dtj�gtjdtjddtjddd d d d d dd�d�gtjdtjddtjddd�d�gtjdtj ddtj ddd�d�gd� S )r� rS r� r Nr � �� T� ns1.example.com� hostmaster.example.com� �� ������� �� �ri r� r� r� r� r� r� r� �rf ri r7 rk �ns1.example.comrh �5.6.7.8) r? r6 r@ r7 r9 r: rA r� rn rp rM rs � r� r r� ro r� rq r� �NSr� rt rv r� r r r rr $ sX ��� �� ���zMessageComplete.kwargsNr� r r r r r� � s 1r� c @ r� )�MessageEDNSQueryz' A minimal EDNS query message. c C r� )r� s, wwwexamplecom ) r r� r r r rP b r� zMessageEDNSQuery.bytesc C s, t ddtjddddddt�dtj�gg d� S )r� r r� Fs www.example.com) r? r6 r@ r7 r9 r: rA r� r� rn rs )r� r rU ro rt r� r r r rr � s �zMessageEDNSQuery.kwargsNr� r r r r r ] s r c @ r� )�MessageEDNSCompletez� An example of a fully populated edns response message. Contains name compression, answers, authority, and additional records. c C r� )r� sy �� examplecom � ���� 'ns1� hostmaster� ������������������ ���� �)�) ���� ) � r r� r r r rP � r� zMessageEDNSComplete.bytesc C s� t d(i dd�dd�dtj�dd�dd�d d�d d�d d �d d�dd�dd�dd�dd�dt�dtj�g�dtjdtjddtjddddd d d d d �d!�g�d"tjdtjddtjd#dd$�d!�g�d%tjdtj ddtj d&dd$�d!�g��S ))r� r? rS r6 r� r@ r7 r8 r r9 r: rA r r� r� r� Tr r, rB � rn r rp r� r� r� r� r� r� r� r� r r rM r rh rs r Nr r r� r r r rr � s� �������� � � � � ������" ���+ ���zMessageEDNSComplete.kwargsNr� r r r r r � s 9r c @ r� )�MessageEDNSExtendedRCODEz? An example of an EDNS message with an extended RCODE. c C r� )r� s ) � r r� r r r rP r� z MessageEDNSExtendedRCODE.bytesc C s( t ddtjddddddddg g g g d�S )r� r Fi� r� )r? r6 r@ r7 r8 r9 r: rA r� r� rB rn rp rM rs )r� r rU r� r r r rr 7 s" �z MessageEDNSExtendedRCODE.kwargsNr� r r r r r s r c @ s( e Zd ZdZd ZZdd� Zdd� ZdS )�MessageComparablez� A wrapper around L{dns.Message} which is comparable so that it can be tested using some of the L{dns._EDNSMessage} tests. ) r? r6 r@ r7 r8 r9 r: rA rn rp rM rs c C s || _ d S r� )�original)r r r r r r� g � zMessageComparable.__init__c C s t | j|�S r� )�getattrr )r �keyr r r � __getattr__j r� z MessageComparable.__getattr__N)r& r' r( r/ �showAttributes�compareAttributesr� r r r r r r R s r c C s^ |du r|}i }||d�}|� }t ||�|d< |di ||i��}t ||�|d< | �||� dS )a� Verify that an attribute has the expected default value and that a corresponding argument passed to a constructor is assigned to that attribute. @param testCase: The L{TestCase} whose assert methods will be called. @type testCase: L{unittest.TestCase} @param cls: The constructor under test. @type cls: L{type} @param argName: The name of the constructor argument under test. @type argName: L{str} @param defaultVal: The expected default value of C{attrName} / C{argName} @type defaultVal: L{object} @param altVal: A value which is different from the default. Used to test that supplied constructor arguments are actually assigned to the correct attribute. @type altVal: L{object} @param attrName: The name of the attribute under test if different from C{argName}. Defaults to C{argName} @type attrName: L{str} N�� defaultVal�altValr r r )r r ) rm rg �argNamer r �attrName�actualrc r� r r r �verifyConstructorArgumentn s r c @ s e Zd ZdZdd� Zdd� ZdS )�ConstructorTestsMixinzl Helper methods for verifying default attribute values and corresponding constructor arguments. c C s t | | j|||d� dS )a� Wrap L{verifyConstructorArgument} to provide simpler interface for testing Message and _EDNSMessage constructor arguments. @param argName: The name of the constructor argument. @param defaultVal: The expected default value. @param altVal: An alternative value which is expected to be assigned to a correspondingly named attribute. �rm rg r r r N�r rs )r r r r r r r �_verifyConstructorArgument� s �z0ConstructorTestsMixin._verifyConstructorArgumentc C s& |dv sJ �t | | j||| d� dS )a Wrap L{verifyConstructorArgument} to provide simpler interface for testing _EDNSMessage constructor flags. @param argName: The name of the constructor flag argument @param defaultVal: The expected default value of the flag )TFr Nr )r r r r r r �_verifyConstructorFlag� s �z,ConstructorTestsMixin._verifyConstructorFlagN)r& r' r( r/ r r r r r r r � s r c @ sx e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd S ) �CommonConstructorTestsMixina� Tests for constructor arguments and their associated attributes that are common to both L{twisted.names.dns._EDNSMessage} and L{dns.Message}. TestCase classes that use this mixin must provide a C{messageFactory} method which accepts any argment supported by L{dns.Message.__init__}. TestCases must also mixin ConstructorTestsMixin which provides some custom assertions for testing constructor arguments. c C � | j dddd� dS )zk L{dns._EDNSMessage.id} defaults to C{0} and can be overridden in the constructor. r? r r� r N�r r r r r rx � � z#CommonConstructorTestsMixin.test_idc C � | j ddd� dS )zs L{dns._EDNSMessage.answer} defaults to C{False} and can be overridden in the constructor. r6 F�r N�r r r r r r{ � � z'CommonConstructorTestsMixin.test_answerc C s | j dtjtjd� dS )zz L{dns._EDNSMessage.opCode} defaults to L{dns.OP_QUERY} and can be overridden in the constructor. r@ r N)r r rU r� r r r r r} � s �z'CommonConstructorTestsMixin.test_opCodec C r" )zq L{dns._EDNSMessage.auth} defaults to C{False} and can be overridden in the constructor. r7 Fr# Nr$ r r r r r� � r% z%CommonConstructorTestsMixin.test_authc C r" )zr L{dns._EDNSMessage.trunc} defaults to C{False} and can be overridden in the constructor. r8 Fr# Nr$ r r r r r� � r% z&CommonConstructorTestsMixin.test_truncc C r" )zs L{dns._EDNSMessage.recDes} defaults to C{False} and can be overridden in the constructor. r9 Fr# Nr$ r r r r r � r% z'CommonConstructorTestsMixin.test_recDesc C r" )zr L{dns._EDNSMessage.recAv} defaults to C{False} and can be overridden in the constructor. r: Fr# Nr$ r r r r r� � r% z&CommonConstructorTestsMixin.test_recAvc C r )zn L{dns._EDNSMessage.rCode} defaults to C{0} and can be overridden in the constructor. rA r rL r Nr r r r r r� r! z&CommonConstructorTestsMixin.test_rCodec C r )zr L{dns._EDNSMessage.maxSize} defaults to C{512} and can be overridden in the constructor. rB r� r r Nr r r r r r� r! z(CommonConstructorTestsMixin.test_maxSizec C � | � | �� jg � dS )z@ L{dns._EDNSMessage.queries} defaults to C{[]}. N)r rs rn r r r r r� r z(CommonConstructorTestsMixin.test_queriesc C r& )z@ L{dns._EDNSMessage.answers} defaults to C{[]}. N)r rs rp r r r r r� r z(CommonConstructorTestsMixin.test_answersc C r& )zB L{dns._EDNSMessage.authority} defaults to C{[]}. N)r rs rM r r r r r� r z*CommonConstructorTestsMixin.test_authorityc C r& )zC L{dns._EDNSMessage.additional} defaults to C{[]}. N)r rs rs r r r r r� % r z+CommonConstructorTestsMixin.test_additionalN)r& r' r( r/ rx r{ r} r� r� r r� r� r� r� r� r� r� r r r r r � s r c @ � e Zd ZdZejZdS )�EDNSMessageConstructorTestszt Tests for L{twisted.names.dns._EDNSMessage} constructor arguments that are shared with L{dns.Message}. N�r& r' r( r/ r � _EDNSMessagers r r r r r( , � r( c @ r' )�MessageConstructorTestszt Tests for L{twisted.names.dns.Message} constructor arguments that are shared with L{dns._EDNSMessage}. N)r& r' r( r/ r r_ rs r r r r r, 7 r+ r, c @ s� e Zd ZdZejZdd� Zdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�EDNSMessageSpecificsTestsz� Tests for L{dns._EDNSMessage}. These tests are for L{dns._EDNSMessage} APIs which are not shared with L{dns.Message}. c C s | j dddd� dS )zt L{dns._EDNSMessage.ednsVersion} defaults to C{0} and can be overridden in the constructor. r� r Nr r r r r r �test_ednsVersionL r! z*EDNSMessageSpecificsTests.test_ednsVersionc C r" )zu L{dns._EDNSMessage.dnssecOK} defaults to C{False} and can be overridden in the constructor. r� Fr# Nr$ r r r r r� S r% z'EDNSMessageSpecificsTests.test_dnssecOKc C r" )zz L{dns._EDNSMessage.authenticData} defaults to C{False} and can be overridden in the constructor. r Fr# Nr$ r r r r r� Z r% z,EDNSMessageSpecificsTests.test_authenticDatac C r" )z} L{dns._EDNSMessage.checkingDisabled} defaults to C{False} and can be overridden in the constructor. r, Fr# Nr$ r r r r r� a r% z/EDNSMessageSpecificsTests.test_checkingDisabledc C s. | j t�d�gd�}| �|jt�d�g� dS )zS L{dns._EDNSMessage.queries} can be overridden in the constructor. r r� N)rs r ro r rn rQ r r r �test_queriesOverrideh s z.EDNSMessageSpecificsTests.test_queriesOverridec C �B | j tjdt�d�d�gd�}| �|jtjdt�d�d�g� dS )zS L{dns._EDNSMessage.answers} can be overridden in the constructor. r rl r_ r� N)rs r rq rv r rp rQ r r r �test_answersOverridep s ��z.EDNSMessageSpecificsTests.test_answersOverridec C sF | j tjdtjt�� d�gd�}| �|jtjdtjt�� d�g� dS )�U L{dns._EDNSMessage.authority} can be overridden in the constructor. r r� r� N)rs r rq r� r� r rM rQ r r r �test_authorityOverride| s ���z0EDNSMessageSpecificsTests.test_authorityOverridec C r0 )r2 r rl r_ r� N)rs r rq rv r rs rQ r r r �test_additionalOverride� s ��z1EDNSMessageSpecificsTests.test_additionalOverridec C � | � dt| �� �� dS )z� L{dns._EDNSMessage.__repr__} omits field values and sections which are identical to their defaults. The id field value is always shown. z<_EDNSMessage id=0>N�r r3 rs r r r r r4 � r5 z+EDNSMessageSpecificsTests.test_reprDefaultsc C s. | j ddddddddd�}| �dt|�� dS )zR L{dns._EDNSMessage.__repr__} displays flags if they are L{True}. T)r6 r7 r8 r9 r: r r, r� z`<_EDNSMessage id=0 flags=answer,auth,trunc,recDes,recAv,authenticData,checkingDisabled,dnssecOK>N�rs r r3 r' r r r r< � s � �z-EDNSMessageSpecificsTests.test_reprFlagsIfSetc C s( | j dddddd�}| �dt|�� dS ) zp L{dns._EDNSMessage.__repr__} displays field values if they differ from their defaults. r7 r| r= r> r� )r? r@ rA rB r� zA<_EDNSMessage id=10 opCode=20 rCode=30 maxSize=40 ednsVersion=50>Nr7 r' r r r rC � s �z2EDNSMessageSpecificsTests.test_reprNonDefautFieldsc C sD | � � }g d�|_g d�|_g d�|_g d�|_| �dt|�� dS )rD rE rF rH rK zc<_EDNSMessage id=0 queries=[1, 2, 3] answers=[4, 5, 6] authority=[7, 8, 9] additional=[10, 11, 12]>N)rs rn rp rM rs r r3 r' r r r rN � rO z5EDNSMessageSpecificsTests.test_reprNonDefaultSectionsc C sP G dd� d�}t �� }||_t� }| �t|j|�}| �|fi f|j|j f� dS )z� L{dns._EDNSMessage.fromString} calls L{dns._EDNSMessage._messageFactory} to create a new L{dns.Message} instance which is used to decode the supplied bytes. c @ r) )zUEDNSMessageSpecificsTests.test_fromStrCallsMessageFactory.<locals>.FakeMessageFactory�/ Fake message factory. c _ s t ||��)z� Fake fromStr method which raises the arguments it was passed. @param args: positional arguments @param kwargs: keyword arguments �r� r� r r r rm � s z]EDNSMessageSpecificsTests.test_fromStrCallsMessageFactory.<locals>.FakeMessageFactory.fromStrN�r& r' r( r/ rm r r r r �FakeMessageFactory� r0 r; N) r r* �_messageFactoryr2 r" r� rm r rq rr )r r; r( � dummyBytesr� r r r � test_fromStrCallsMessageFactory� s z9EDNSMessageSpecificsTests.test_fromStrCallsMessageFactoryc sf t �� }G dd� d�}|� � � fdd�|_dd� }||_| �t|jd�}| �� fi f|j|j f� dS ) z~ L{dns._EDNSMessage.fromString} calls L{dns._EDNSMessage._fromMessage} with a L{dns.Message} instance c @ r) )zREDNSMessageSpecificsTests.test_fromStrCallsFromMessage.<locals>.FakeMessageFactoryr8 c S s dS )zw A noop fake version of fromStr @param bytes: the bytes to be decoded Nr )r rP r r r rm � zZEDNSMessageSpecificsTests.test_fromStrCallsFromMessage.<locals>.FakeMessageFactory.fromStrNr: r r r r r; � r0 r; c � � S r� r r �� fakeMessager r �<lambda> r? zHEDNSMessageSpecificsTests.test_fromStrCallsFromMessage.<locals>.<lambda>c _ � t | |��r� r9 r� r r r �fakeFromMessage r zOEDNSMessageSpecificsTests.test_fromStrCallsFromMessage.<locals>.fakeFromMessager� N) r r* r< � _fromMessager" r� rm r rq rr )r r( r; rE r� r rA r � test_fromStrCallsFromMessage� s z6EDNSMessageSpecificsTests.test_fromStrCallsFromMessagec C s@ t �� }dd� }||_| �t|j�}| �di f|j|jf� dS )zP L{dns._EDNSMessage.toStr} calls L{dns._EDNSMessage._toMessage} c _ rD r� r9 r� r r r � fakeToMessage r zIEDNSMessageSpecificsTests.test_toStrCallsToMessage.<locals>.fakeToMessager N) r r* � _toMessager" r� rw r rq rr )r r( rH r� r r r �test_toStrCallsToMessage s z2EDNSMessageSpecificsTests.test_toStrCallsToMessagec sF t �� }t� �G �fdd�d�� � fdd�}||_| ��|�� � dS )z} L{dns._EDNSMessage.toStr} calls C{toStr} on the message returned by L{dns._EDNSMessage._toMessage}. c s e Zd ZdZ� fdd�ZdS )zLEDNSMessageSpecificsTests.test_toStrCallsToMessageToStr.<locals>.FakeMessagez& Fake Message c r@ )zk Fake toStr which returns dummyBytes. @return: dummyBytes r r �r= r r rw . s zREDNSMessageSpecificsTests.test_toStrCallsToMessageToStr.<locals>.FakeMessage.toStrN)r& r' r( r/ rw r rK r r � FakeMessage) s rL c s � � S r� r r� )rL r r rH 6 s zNEDNSMessageSpecificsTests.test_toStrCallsToMessageToStr.<locals>.fakeToMessageN)r r* r2 rI r rw )r r( rH r )rL r= r � test_toStrCallsToMessageToStr! s z7EDNSMessageSpecificsTests.test_toStrCallsToMessageToStrN)r& r' r( r/ r r* rs r. r� r� r� r/ r1 r3 r4 r4 r< rC rN r> rG rJ rM r r r r r- B s& r- c @ s� e Zd ZdZejZdd� Zdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$S )%�EDNSMessageEqualityTestsz� Tests for equality between L{dns._EDNSMessage} instances. These tests will not work with L{dns.Message} because it does not use L{twisted.python.util.FancyEqMixin}. c C rt )zc Two L{dns._EDNSMessage} instances compare equal if they have the same id. r� ru r� Nrv r r r r rx H ry z EDNSMessageEqualityTests.test_idc C rt )zl Two L{dns._EDNSMessage} instances compare equal if they have the same answer flag. Trz FNrv r r r r r{ S ry z$EDNSMessageEqualityTests.test_answerc C s0 | � | jtjd�| jtjd�| jtjd�� dS )zg Two L{dns._EDNSMessage} instances compare equal if they have the same opCode. r| N)rw rs r r� � OP_INVERSEr r r r r} ^ s �z$EDNSMessageEqualityTests.test_opCodec C rt )zj Two L{dns._EDNSMessage} instances compare equal if they have the same auth flag. Tr� FNrv r r r r r� i ry z"EDNSMessageEqualityTests.test_authc C rt )zk Two L{dns._EDNSMessage} instances compare equal if they have the same trunc flag. Tr� FNrv r r r r r� t ry z#EDNSMessageEqualityTests.test_truncc C rt )zl Two L{dns._EDNSMessage} instances compare equal if they have the same recDes flag. Tr~ FNrv r r r r r ry z$EDNSMessageEqualityTests.test_recDesc C rt )zk Two L{dns._EDNSMessage} instances compare equal if they have the same recAv flag. Tr� FNrv r r r r r� � ry z#EDNSMessageEqualityTests.test_recAvc C rt )zf Two L{dns._EDNSMessage} instances compare equal if they have the same rCode. r, r� r Nrv r r r r r� � ry z#EDNSMessageEqualityTests.test_rCodec C s* | � | jdd�| jdd�| jdd�� dS )zl Two L{dns._EDNSMessage} instances compare equal if they have the same ednsVersion. r� �r� Nrv r r r r r. � ry z)EDNSMessageEqualityTests.test_ednsVersionc C rt )zi Two L{dns._EDNSMessage} instances compare equal if they have the same dnssecOK. Tr� FNrv r r r r r� � ry z&EDNSMessageEqualityTests.test_dnssecOKc C rt )zt Two L{dns._EDNSMessage} instances compare equal if they have the same authenticData flags. Tr FNrv r r r r r� � ry z+EDNSMessageEqualityTests.test_authenticDatac C rt )zw Two L{dns._EDNSMessage} instances compare equal if they have the same checkingDisabled flags. Tr. FNrv r r r r r� � ry z.EDNSMessageEqualityTests.test_checkingDisabledc C rt )zh Two L{dns._EDNSMessage} instances compare equal if they have the same maxSize. i r� r Nrv r r r r r� � ry z%EDNSMessageEqualityTests.test_maxSizec C r� )zh Two L{dns._EDNSMessage} instances compare equal if they have the same queries. r r� r� Nr� r r r r r� � r� z%EDNSMessageEqualityTests.test_queriesc C r� )zh Two L{dns._EDNSMessage} instances compare equal if they have the same answers. r rl r_ r� r� r� Nr� r r r r r� � r� z%EDNSMessageEqualityTests.test_answersc C r� )zr Two L{dns._EDNSMessage} instances compare equal if they have the same authority records. r r� r� r� Nr� r r r r r� � r� z'EDNSMessageEqualityTests.test_authorityc C r� )zs Two L{dns._EDNSMessage} instances compare equal if they have the same additional records. r rl r_ r� r� Nr� r r r r r� r� z(EDNSMessageEqualityTests.test_additionalN)r& r' r( r/ r r* rs rx r{ r} r� r� r r� r� r. r� r� r� r� r� r� r� r� r r r r rN > s( rN c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�StandardEncodingTestsMixina� Tests for the encoding and decoding of various standard (not EDNS) messages. These tests should work with both L{dns._EDNSMessage} and L{dns.Message}. TestCase classes that use this mixin must provide a C{messageFactory} method which accepts any argment supported by L{dns._EDNSMessage.__init__}. EDNS specific arguments may be discarded if not supported by the message class under construction. c C �( | � | jdi t�� ���� t�� � dS )z2 An empty message can be encoded. Nr )r rs r� rr rw rP r r r r �test_emptyMessageEncode/ s �z2StandardEncodingTestsMixin.test_emptyMessageEncodec C �6 | � � }|�t�� � | �|| j di t�� ��� dS )z@ An empty message byte sequence can be decoded. Nr )rs rm r� rP r rr r' r r r �test_emptyMessageDecode7 s z2StandardEncodingTestsMixin.test_emptyMessageDecodec C rR )zA A fully populated query message can be encoded. Nr )r rs r� rr rw rP r r r r �test_completeQueryEncode@ s �z3StandardEncodingTestsMixin.test_completeQueryEncodec C s8 | � � }|�t�� �f | �|| j di t�� ��� dS )zG A fully populated message byte string can be decoded. Nr )rs rm r� rP r rr r' r r r �test_completeQueryDecodeI s z3StandardEncodingTestsMixin.test_completeQueryDecodec C s� d� dd� td�D ��}t�|�}tjdtj|d�}| �� }|j�|� |� � }| �� }|� |� | � |jd j tj� | � |jd j j |� dS ) zu A I{NULL} record with an arbitrary payload can be encoded and decoded as part of a message. r� c S rW r rX rY r r r r\ W r] z8StandardEncodingTestsMixin.test_NULL.<locals>.<listcomp>rS r^ r_ r N)r` r� r r� rq ra rs rp rb rw rm rN rk r rc r r r r� R s z$StandardEncodingTestsMixin.test_NULLc C rR )zv If the message C{authoritative} attribute is set to 0, the encoded bytes will have AA bit 0. Nr )r rs r� rr rw rP r r r r �"test_nonAuthoritativeMessageEncoded � �z=StandardEncodingTestsMixin.test_nonAuthoritativeMessageEncodec C rT )z� The L{dns.RRHeader} instances created by a message from a non-authoritative message byte string are marked as not authoritative. Nr )rs rm r� rP r rr r' r r r �"test_nonAuthoritativeMessageDecoden � z=StandardEncodingTestsMixin.test_nonAuthoritativeMessageDecodec C rR )zv If the message C{authoritative} attribute is set to 1, the encoded bytes will have AA bit 1. Nr )r rs r� rr rw rP r r r r � test_authoritativeMessageEncodex rY z:StandardEncodingTestsMixin.test_authoritativeMessageEncodec C rT )z� The message and its L{dns.RRHeader} instances created by C{decode} from an authoritative message byte string, are marked as authoritative. Nr )rs rm r� rP r rr r' r r r � test_authoritativeMessageDecode� r[ z:StandardEncodingTestsMixin.test_authoritativeMessageDecodec C rR )zm If the message C{trunc} attribute is set to 1 the encoded bytes will have TR bit 1. Nr )r rs r� rr rw rP r r r r �test_truncatedMessageEncode� rY z6StandardEncodingTestsMixin.test_truncatedMessageEncodec C rT )zn The message instance created by decoding a truncated message is marked as truncated. Nr )rs rm r� rP r rr r' r r r �test_truncatedMessageDecode� r[ z6StandardEncodingTestsMixin.test_truncatedMessageDecodeN)r& r' r( r/ rS rU rV rW r� rX rZ r\ r] r^ r_ r r r r rQ " s rQ c @ r' )� EDNSMessageStandardEncodingTestszq Tests for the encoding and decoding of various standard (non-EDNS) messages by L{dns._EDNSMessage}. Nr) r r r r r` � r+ r` c @ s e Zd ZdZedd� �ZdS )� MessageStandardEncodingTestszl Tests for the encoding and decoding of various standard (non-EDNS) messages by L{dns.Message}. c K sl | � dg �}| � dg �}| � dg �}| � dg �}| � dd� tjdi | ��}||_||_||_||_t|�S )a� This function adapts constructor arguments expected by _EDNSMessage.__init__ to arguments suitable for use with the Message.__init__. Also handles the fact that unlike L{dns._EDNSMessage}, L{dns.Message.__init__} does not accept queries, answers etc as arguments. Also removes any L{dns._EDNSMessage} specific arguments. @param args: The positional arguments which will be passed to L{dns.Message.__init__}. @param kwargs: The keyword arguments which will be stripped of EDNS specific arguments before being passed to L{dns.Message.__init__}. @return: An L{dns.Message} instance. rn rp rM rs r� Nr )rp r r_ rn rp rM rs r )rr rn rp rM rs r( r r r rs � s z+MessageStandardEncodingTests.messageFactoryN)r& r' r( r/ � staticmethodrs r r r r ra � s ra c @ sf e Zd ZdZejZdd� Zdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� ZdS )� EDNSMessageEDNSEncodingTestszz Tests for the encoding and decoding of various EDNS messages. These test will not work with L{dns.Message}. c C s( | � � }|�t�� � | �|jg � dS )z� The L(_EDNSMessage} instance created by L{dns._EDNSMessage.decode} from an EDNS query never includes OPT records in the additional section. N)rs rm r rP r rs r' r r r �&test_ednsMessageDecodeStripsOptRecords� s zCEDNSMessageEDNSEncodingTests.test_ednsMessageDecodeStripsOptRecordsc C sH t �� }t jdd�t jdd�g|_t �� }|�|�� � | �|j� dS )a An L(_EDNSMessage} instance created from a byte string containing multiple I{OPT} records will discard all the C{OPT} records. C{ednsVersion} will be set to L{None}. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.1} r� r� r� N) r r_ r� rs r* rm rw � assertIsNoner� )r r( � ednsMessager r r �(test_ednsMessageDecodeMultipleOptRecords� s zEEDNSMessageEDNSEncodingTests.test_ednsMessageDecodeMultipleOptRecordsc C sj t �� }|�t�� � t j�|�}g }dD ]}t||�t||�u r&|�|� q|r3| � d|f � dS dS )z� L{dns._EDNSMessage._fromMessage} returns an L{_EDNSMessage} instance whose queries, answers, authority and additional lists are copies (not references to) the original message lists. )rn rp rM rs z\Message and _EDNSMessage shared references to the following section lists after decoding: %sN) r r_ rm r rP r* rF r rb �fail)r �standardMessagerf � duplicatesr r r r � test_fromMessageCopiesSections� s ����z;EDNSMessageEDNSEncodingTests.test_fromMessageCopiesSectionsc C s& t jdd�}|�� | �|jg � dS )zf L{dns._EDNSMessage.toStr} makes no in place changes to the message instance. r� rP N)r r* rw r rs )r rf r r r � test_toMessageCopiesSections s z9EDNSMessageEDNSEncodingTests.test_toMessageCopiesSectionsc C s� t � }tjdd�}|�|� t�� }|�d� |�|� t�� }|g|_g }|� tj � |�j � |j� tjtj d�� |� tj � |�j � |j�dtjtj d�� |� tj � |�j � | �dgd |� dS )a L{dns._EDNSMessage} can decode OPT records, regardless of their position in the additional records section. "The OPT RR MAY be placed anywhere within the additional data section." @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.1} r� r� r )rf r� N)r r r� rW rq r� rS r_ rs rb r* rF r� rt �insertr )r r� � optRecord� optRRHeaderr( �actualMessagesr r r �test_optHeaderPosition s z3EDNSMessageEDNSEncodingTests.test_optHeaderPositionc C rT )z� The L(_EDNSMessage} instance created by L{dns._EDNSMessage.fromStr} derives its edns specific values (C{ednsVersion}, etc) from the supplied OPT record. Nr )rs rm r rP r rr r' r r r �test_ednsDecode9 s z,EDNSMessageEDNSEncodingTests.test_ednsDecodec C rR )z� The L(_EDNSMessage} instance created by L{dns._EDNSMessage.toStr} encodes its edns specific values (C{ednsVersion}, etc) into an OPT record added to the additional section. Nr )r rs r rr rw rP r r r r �test_ednsEncodeD � �z,EDNSMessageEDNSEncodingTests.test_ednsEncodec C rR )z� The L(_EDNSMessage.toStr} encodes the extended I{RCODE} (>=16) by assigning the lower 4bits to the message RCODE field and the upper 4bits to the OPT pseudo record. Nr )r rs r rr rw rP r r r r �test_extendedRcodeEncodeO rt z5EDNSMessageEDNSEncodingTests.test_extendedRcodeEncodec C rT )z� The L(_EDNSMessage} instance created by L{dns._EDNSMessage.fromStr} derives RCODE from the supplied OPT record. Nr )rs rm r rP r rr r' r r r �test_extendedRcodeDecodeZ r[ z5EDNSMessageEDNSEncodingTests.test_extendedRcodeDecodec C s4 | j ddd�}|�� }| �d|j|jd jf� dS )z� Note that EXTENDED-RCODE value 0 indicates that an unextended RCODE is in use (values 0 through 15). https://tools.ietf.org/html/rfc6891#section-6.1.3 r r )rA r� )r r N)rs rI r rA rs r� )r rf ri r r r �test_extendedRcodeZerod s �z3EDNSMessageEDNSEncodingTests.test_extendedRcodeZeroN)r& r' r( r/ r r* rs rd rg rk rl rq rr rs ru rv rw r r r r rc � s rc c @ r� )�ResponseFromMessageTestsz0 Tests for L{dns._responseFromMessage}. c C s( t �� }t jt j|d�}| �||� dS )z� L{dns.Message._responseFromMessage} is a constructor function which generates a new I{answer} message from an existing L{dns.Message} like instance. ��responseConstructorrk N)r r_ �_responseFromMessage� assertIsNot�r �request�responser r r �$test_responseFromMessageResponseTypey s �z=ResponseFromMessageTests.test_responseFromMessageResponseTypec C s0 G dd� d�}t j}| �t j||� d�|� dS )zN L{dns._responseFromMessage} returns a new instance of C{cls} c @ s e Zd ZdZg ZdS )zAResponseFromMessageTests.test_responseType.<locals>.SuppliedClassr� N)r& r' r( r? rn r r r r � SuppliedClass� s r� ry N)r r_ rN r{ )r r� � expectedClassr r r �test_responseType� s ��z*ResponseFromMessageTests.test_responseTypec C s& | � dtjtjtjdd�d�j� dS )zi L{dns._responseFromMessage} copies the C{id} attribute of the original message. i� ru ry N)r r r{ r_ r? r r r r �test_responseId� s ��z(ResponseFromMessageTests.test_responseIdc C s0 t �� }t jt j|d�}| �d|j|jf� dS )zP L{dns._responseFromMessage} sets the C{answer} flag to L{True} ry )FTN)r r_ r{ r r6 r} r r r �test_responseAnswer� s �z,ResponseFromMessageTests.test_responseAnswerc C sD t �� }t� t� t� g}|dd� |_| �|t jt j|d�j� dS )zn L{dns._responseFromMessage} copies the C{queries} attribute of the original message. Nry )r r_ r2 rn r r{ )r r~ �expectedQueriesr r r �test_responseQueries� s ��z-ResponseFromMessageTests.test_responseQueriesc C s$ | � dtjtjt�� dd�j� dS )z� L{dns._responseFromMessage} accepts other C{kwargs} which are assigned to the new message before it is returned. rL )rz rk rA N)r r r{ r_ rA r r r r �test_responseKwargs� s ��z,ResponseFromMessageTests.test_responseKwargsN) r& r' r( r/ r� r� r� r� r� r� r r r r rx t s rx c @ s4 e Zd ZdZ d dd �Zd efd d �ZdS )�Fooz� An example class for use in L{dns._compactRepr} tests. It follows the pattern of initialiser settable flags, fields and sections found in L{dns.Message} and L{dns._EDNSMessage}. r� r� �ASTFNc C s4 || _ || _|| _|| _|| _|du rg }|| _dS )zK Set some flags, fields and sections as public attributes. N)�field1�field2�alwaysShowField�flagTrue� flagFalse�section1)r r� r� r� r� r� r� r r r r� � s z Foo.__init__�returnc C s* t ttj| d�� d�� d�� d�� d��S )zO Call L{dns._compactRepr} to generate a string representation. r� z field1 field2 alwaysShowFieldzflagTrue flagFalsezsection1 section2)� alwaysShow� fieldNames� flagNames� sectionNames)r �strr � _compactRepr�splitr r r r �__repr__� s ��z Foo.__repr__)r� r� r� TFN)r& r' r( r/ r� r� r� r r r r r� � s �r� c @ s4 e Zd ZdZeZdd� Zdd� Zdd� Zdd � Z d S ) �CompactReprTestsz( Tests for L{dns._compactRepr}. c C r5 )z� L{dns._compactRepr} omits field values and sections which have the default value. Flags which are True are always shown. z)<Foo alwaysShowField='AS' flags=flagTrue>Nr6 r r r r � test_defaults� s �z CompactReprTests.test_defaultsc C s" | j ddd�}| �dt|�� dS )zV L{dns._compactRepr} displays flags if they have a non-default value. T)r� r� z3<Foo alwaysShowField='AS' flags=flagTrue,flagFalse>Nr7 r' r r r �test_flagsIfSet s �z CompactReprTests.test_flagsIfSetc C s" | j ddd�}| �dt|�� dS )zg L{dns._compactRepr} displays field values if they differ from their defaults. r7 r| )r� r� z=<Foo field1=10 field2=20 alwaysShowField='AS' flags=flagTrue>Nr7 r' r r r �test_nonDefautFields s �z%CompactReprTests.test_nonDefautFieldsc C s0 | � � }g d�|_g d�|_| �dt|�� dS )zY L{dns._compactRepr} displays sections which differ from their defaults. )r� r� r� )r� r� r� zO<Foo alwaysShowField='AS' flags=flagTrue section1=[1, 1, 1] section2=[2, 2, 2]>N)rs r� �section2r r3 r' r r r �test_nonDefaultSections! s �z(CompactReprTests.test_nonDefaultSectionsN) r& r' r( r/ r� rs r� r� r� r� r r r r r� � s r� r� )hr/ r� �ior �typingr �zope.interface.verifyr �twisted.internetr r �twisted.internet.errorr r � twisted.namesr �twisted.python.failurer �twisted.python.utilr r � twisted.testr �twisted.test.testutilsr � twisted.trialr r� r� r� r� r� r r r r rv r� r� r� r� r� r� r r r r r� r� r� r� r rr r� �SynchronousTestCaser �TestCaser* r1 rK r� r# r0 r ro r� r� r� r� r� r& rS r] rp rr rs r� r� r� � Exceptionr� r� r� r� r� r� r r r r r r r r( r, r- rN rQ r` ra rc rx r� r� r r r r �<module> s� � % > N e� � u eaT ".3_5 iP.-11r;; �.* f� � } e � �, V-PK y�Z�ѽ � ) test/__pycache__/__init__.cpython-310.pycnu �[��� o �b � @ s d Z dS )zTests for twisted.namesN)�__doc__� r r �=/usr/lib/python3/dist-packages/twisted/names/test/__init__.py�<module> s PK y�Z��q��W �W 1 test/__pycache__/test_rootresolve.cpython-310.pycnu �[��� o �b4d � @ s� d Z ddlmZ ddlmZ ddlmZmZmZm Z ddl m Z ddl m Z mZ ddlmZmZmZmZmZmZmZmZmZmZmZmZm Z m Z ddl m Z m Z dd l!m"Z" dd l#m$Z$ dd l%m&Z& dd l'm(Z( dd l)m*Z*m+Z+ dd� Z,dd� Z-G dd� de+�Z.G dd� de/�Z0dd� Z1G dd� de+�Z2g d�Z3ee �G dd � d ��Z4ee e4� G d d � d e*�Z5G d d � d �Z6e(j7e8d!d"�Z9d#S )$z. Test cases for Twisted.names' root resolver. � )� implementer)� verifyClass)�Deferred� TimeoutError� gatherResults�succeed)�IResolverSimple)�client�root)�CNAME�ENAME�HS�IN�NS�OK�A�Message�Name�Query�Record_A� Record_CNAME� Record_NS�RRHeader)� DNSNameError� ResolverError)�Resolver)� MemoryReactor)�msg)�util)�SynchronousTestCase�TestCasec C s | \}}}|d j S )z� From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the payload of the first record in the answer section. r ��payload��results�ans�auth�add� r( �E/usr/lib/python3/dist-packages/twisted/names/test/test_rootresolve.py� getOnePayload& s r* c C s t | ��� S )z� From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the first IPv4 address from the answer section. )r* � dottedQuad�r$ r( r( r) � getOneAddress/ s r- c @ s� e Zd ZdZdd� Zdd� Zdd� Zg g g efdd �Zd&d d �Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%S )'�RootResolverTestsz3 Tests for L{twisted.names.root.Resolver}. c C s� t � }tg |d�}|�tdtt�dgd|�}|j�� \}}|j\\}}t � } | � |� | � | j tdtt�g� | � | j g � | � | jg � | � | jg � g } |�| j� | � | g � | j dd�= d| _| j �tdtd�d�� |j�| �� d� | d S ) aK Invoke L{Resolver._query} and verify that it sends the correct DNS query. Deliver a canned response to the query and return whatever the L{Deferred} returned by L{Resolver._query} fires with. @param filter: The value to pass for the C{filter} parameter to L{Resolver._query}. )�reactor� foo.example.com)�1.1.2.3i )� N� � 5.8.13.21r! r )r r �_queryr r r �udpPorts�popitem� _sentPacketsr �fromStr� assertEqual�queries�answers� authority� additional� addCallback�append�answerr r � _protocol�datagramReceived�toStr) �self�filterr/ �resolver�d� portNumber� transport�packet�address�message�responser( r( r) � _queryTest< s. � �z RootResolverTests._queryTestc C sJ | � d�\}}}| �|tdtddd�d�g� | �|g � | �|g � dS )a) L{Resolver._query} accepts a L{Query} instance and an address, issues the query, and returns a L{Deferred} which fires with the response to the query. If a true value is passed for the C{filter} parameter, the result is a three-tuple of lists of records. Tr0 r4 r ��ttlr! N)rO r: r r )rE rA r= r> r( r( r) �test_filteredQueryg s � z$RootResolverTests.test_filteredQueryc C sd | � d�}| �|t� | �|jg � | �|jtdtddd�d�g� | �|jg � | �|j g � dS )z� Similar to L{test_filteredQuery}, but for the case where a false value is passed for the C{filter} parameter. In this case, the result is a L{Message} instance. Fr0 r4 r rP r! N) rO �assertIsInstancer r: r; r< r r r= r> )rE rM r( r( r) �test_unfilteredQueryu s �z&RootResolverTests.test_unfilteredQueryc C sH t |d�}|j|f|j|f|j|ffD ]\}}|�dd� |D �� q|S )a� Create a L{Message} suitable for use as a response to a query. @param answers: A C{list} of two-tuples giving data for the answers section of the message. The first element of each tuple is a name for the L{RRHeader}. The second element is the payload. @param authority: A C{list} like C{answers}, but for the authority section of the response. @param additional: A C{list} like C{answers}, but for the additional section of the response. @param rCode: The response code the message will be created with. @return: A new L{Message} initialized with the given values. )�rCodec S s* g | ]\}}t ||jt|d t�|d��qS )�CLASSr! )r �TYPE�getattrr )�.0�name�recordr( r( r) � <listcomp>� s ���z.RootResolverTests._respond.<locals>.<listcomp>)r r< r= r> �extend)rE r< r= r> rU rN �section�datar( r( r) �_respond� s ���zRootResolverTests._respond� c s( dg}t ||�}� �fdd�}||_|S )a� Create and return a new L{root.Resolver} modified to resolve queries against the record data represented by C{servers}. @param serverResponses: A mapping from dns server addresses to mappings. The inner mappings are from query two-tuples (name, type) to dictionaries suitable for use as **arguments to L{_respond}. See that method for details. r1 c sl t d| j� d|��� |D ]&}z�| }W n ty Y q w || jj| jf }t� jdi |��� S d S )NzQuery for QNAME z at r( )r rZ �KeyError�typer r` )�query�serverAddresses�timeoutrF �addr�server�records�rE �serverResponsesr( r) rd � s ��z-RootResolverTests._getResolver.<locals>.query)r r5 )rE rk �maximumQueries�rootsrG rd r( rj r) � _getResolver� s z RootResolverTests._getResolverc C sr dt fdtd�fgdtd�fgd�idt fddtd�fgiid�}| �|�}|�d�}|�t� |�| jd� |S )a L{root.Resolver.lookupAddress} looks up the I{A} records for the specified hostname by first querying one of the root servers the resolver was created with and then following the authority delegations until a result is received. r0 � ns1.example.com� 34.55.89.144�r= r> r< �10.0.0.1)�r1 �5 )rp rt �r r r rn � lookupAddressr? r- r: �rE �serversrG rH r( r( r) �test_lookupAddress� s ����� z$RootResolverTests.test_lookupAddressc C s� t d�}t|_dtfd|fgdtd�fgdt d�fgd�idtfddt d�fgiid�}| �|�}|�d�}|�t� |�| j t d�� |S ) z� If a response includes a record with a class different from the one in the query, it is ignored and lookup continues until a record with the right class is found. rr r0 ro �10.0.0.2)r< r= r> r< �10.0.0.3)rs �rz rt ) r r rV r r rn rv r? r* r: )rE �badClassrx rG rH r( r( r) �test_lookupChecksClass� s$ ����� z(RootResolverTests.test_lookupChecksClassc C s| dt fddtd�fgidt fddtd�fgiidt fddtd�fgiid�}| �|�}|�d�}|�t� |�| jd� |S )z� If an intermediate response includes no glue records for the authorities, separate queries are made to find those addresses. r0 r= s ns1.example.orgr< rr rz )rs )rr rt ru rw r( r( r) �test_missingGlue� s" ��� ��� z"RootResolverTests.test_missingGluec C s4 ddt fdtiii}| �|�}|�d�}| �|t�S )z� If a name is missing, L{Resolver.lookupAddress} returns a L{Deferred} which fails with L{DNSNameError}. rs r0 rU )r r rn rv � assertFailurer rw r( r( r) �test_missingName s ��� z"RootResolverTests.test_missingNamec C s0 ddt fi ii}| �|�}|�d�}| �|t�S )z� If a query is responded to with no answers or nameserver records, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. rs � example.com)r rn rv r� r rw r( r( r) �test_answerless s �� z!RootResolverTests.test_answerlessc C sJ ddt fddtd�fgidt fdtiii}| �|�}|�d�}| �|t�S )z� If there is an error resolving the nameserver in a delegation response, the L{Deferred} returned by L{Resolver.lookupAddress} fires with that error. rs r� r= ro rU )r r r rn rv r� r rw r( r( r) �test_delegationLookupError. s ���� z,RootResolverTests.test_delegationLookupErrorc C sF ddt fddtd�fgidt fi ii}| �|�}|�d�}| �|t�S )z� If there are no records in the response to a lookup of a delegation nameserver, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. rs r� r= ro )r r rn rv r� r rw r( r( r) �test_delegationLookupEmptyB s ��� z,RootResolverTests.test_delegationLookupEmptyc C sf ddt fdtidtfddtd�fgiii}| �|�}|�d�}dd� }|�|� |�| jtd�� |S )z� L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except it queries for I{NS} records instead of I{A} records. rs r� rU r< ro c S s | \}}}|d j jS �Nr )r" rZ r# r( r( r) � getOneNamef s z<RootResolverTests.test_lookupNameservers.<locals>.getOneName) r r r r rn �lookupNameserversr? r: r )rE rx rG rH r� r( r( r) �test_lookupNameserversT s ���� z(RootResolverTests.test_lookupNameserversc C s| ddt fddtd�fdtd�fgiii}| �|�}|�d�}|�dd� � |�| jtdttd�d�tdt td�d�g� |S ) z� If a I{CNAME} record is encountered as the answer to a query for another record type, that record is returned as the answer. rs r� r< � example.netz10.0.0.7c S � | d S r� r( r, r( r( r) �<lambda> � z<RootResolverTests.test_returnCanonicalName.<locals>.<lambda>r! � r r r rn rv r? r: r r rw r( r( r) �test_returnCanonicalNamen s& ���� ��z*RootResolverTests.test_returnCanonicalNamec C s� ddt fddtd�fgidt fddtd�fgiii}| �|�}|�d�}|�dd� � |�| jtdttd�d�tdt td�d�g� |S ) z� If no record of the requested type is included in a response, but a I{CNAME} record for the query name is included, queries are made to resolve the value of the I{CNAME}. rs r� r< r� z10.0.0.5c S r� r� r( r, r( r( r) r� � r� z<RootResolverTests.test_followCanonicalName.<locals>.<lambda>r! r� rw r( r( r) �test_followCanonicalName� s& ���� ��z*RootResolverTests.test_followCanonicalNamec C sH ddt fddtd�fdtd�fgiii}| �|�}|�d�}| �|t�S )z� If there is a cycle between I{CNAME} records in a response, this is detected and the L{Deferred} returned by the lookup method fails with L{ResolverError}. rs r� r< r� )r r rn rv r� r rw r( r( r) � test_detectCanonicalNameLoop� s ���� z.RootResolverTests.test_detectCanonicalNameLoopc C s� dt fddtd�fgidt fddtd�fgiidt fdtd�fgdtd�fgd�idt fddtd �fgiid �}| �|d �}| �|�d�t�}| �|d �}|�d�}|�t� |�| j td �� t ||g�S ) z� L{Resolver.lookupAddress} won't issue more queries following delegations than the limit passed to its initializer. r� r= ro r< rz s ns2.example.comr{ rq z10.0.0.4)rs r| )r{ rt � � ) r r r rn r� rv r r? r* r: r )rE rx �failer�failD� succeeder�succeedDr( r( r) �test_boundedQueries� s0 ��� �� ��� ! z%RootResolverTests.test_boundedQueriesN)ra )�__name__� __module__� __qualname__�__doc__rO rR rT r r` rn ry r~ r r� r� r� r� r� r� r� r� r� r( r( r( r) r. 7 s& + r. c @ � e Zd ZdZdd� ZdS )�ResolverFactoryArgumentszf Raised by L{raisingResolverFactory} with the *args and **kwargs passed to that function. c C s || _ || _dS )z� Store the supplied args and kwargs as attributes. @param args: Positional arguments. @param kwargs: Keyword arguments. N��args�kwargs)rE r� r� r( r( r) �__init__� � z!ResolverFactoryArguments.__init__N)r� r� r� r� r� r( r( r( r) r� � � r� c O s t | |��)a= Raise a L{ResolverFactoryArguments} exception containing the positional and keyword arguments passed to resolverFactory. @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. )r� r� r( r( r) �raisingResolverFactory� s r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � RootResolverResolverFactoryTestsz6 Tests for L{root.Resolver._resolverFactory}. c C s t dgtd�}| �|jt� dS )z� L{root.Resolver.__init__} accepts a C{resolverFactory} argument and assigns it to C{self._resolverFactory}. N)�hints�resolverFactory)r r� �assertIs�_resolverFactory�rE �rr( r( r) �#test_resolverFactoryArgumentPresent s zDRootResolverResolverFactoryTests.test_resolverFactoryArgumentPresentc C s t dgd�}| �|jtj � dS )z� L{root.Resolver.__init__} sets L{client.Resolver} as the C{_resolverFactory} if a C{resolverFactory} argument is not supplied. N)r� )r r� r� r r� r( r( r) �"test_resolverFactoryArgumentAbsent s zCRootResolverResolverFactoryTests.test_resolverFactoryArgumentAbsentc C sJ t � }tdgt|d�}| �t|jd�}| �d|dgd�f|j|jf� dS )zy L{root.Resolver._resolverFactory} is supplied with C{reactor} and C{servers} keyword arguments. � 192.0.2.101)r� r� r/ z example.comr( )r� rt )r/ rx N) �objectr r� � assertRaisesr� rv r: r� r� )rE � dummyReactorr� �er( r( r) �)test_resolverFactoryOnlyExpectedArguments s � �zJRootResolverResolverFactoryTests.test_resolverFactoryOnlyExpectedArgumentsN)r� r� r� r� r� r� r� r( r( r( r) r� s r� ) za.root-servers.netzb.root-servers.netzc.root-servers.netzd.root-servers.netze.root-servers.netzf.root-servers.netzg.root-servers.netzh.root-servers.netzi.root-servers.netzj.root-servers.netzk.root-servers.netzl.root-servers.netzm.root-servers.netc @ s e Zd ZdZdd� Zdd� ZdS )� StubResolverz� An L{IResolverSimple} implementer which traces all getHostByName calls and their deferred results. The deferred results can be accessed and fired synchronously. c C s g | _ g | _dS )z� @type calls: L{list} of L{tuple} containing C{args} and C{kwargs} supplied to C{getHostByName} calls. @type pendingResults: L{list} of L{Deferred} returned by C{getHostByName}. N)�calls�pendingResults)rE r( r( r) r� L r� zStubResolver.__init__c O s& | j �||f� t� }| j�|� |S )al A fake implementation of L{IResolverSimple.getHostByName} @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. @return: A L{Deferred} which may be fired later from the test fixture. )r� r@ r r� )rE r� r� rH r( r( r) � getHostByNameV s zStubResolver.getHostByNameN)r� r� r� r� r� r� r( r( r( r) r� D s r� c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�BootstrapTestsz% Tests for L{root.bootstrap} c C s t �t� �}| �|t j� dS )zl L{root.bootstrap} returns an object which is initially a L{root.DeferredResolver}. N)r � bootstrapr� rS �DeferredResolver)rE �deferredResolverr( r( r) � test_returnsDeferredResolverq s z+BootstrapTests.test_returnsDeferredResolverc C s, t � }t�|� | �|jdd� tD �� dS )z� The L{IResolverSimple} supplied to L{root.bootstrap} is used to lookup the IP addresses of the 13 root name servers. c S s g | ]}|fi f�qS r( r( )rY �sr( r( r) r\ � s z=BootstrapTests.test_resolves13RootServers.<locals>.<listcomp>N)r� r r� r: r� � ROOT_SERVERS)rE � stubResolverr( r( r) �test_resolves13RootServersy s z)BootstrapTests.test_resolves13RootServersc C s6 t � }t�|�}|jD ]}|�d� q | �|t� dS )z� The L{root.DeferredResolver} initially returned by L{root.bootstrap} becomes a L{root.Resolver} when the supplied resolver has successfully looked up all root hints. r� N)r� r r� r� �callbackrS r �rE r� r� rH r( r( r) �test_becomesResolver� s z#BootstrapTests.test_becomesResolverc C s> t � }t�|�}|jD ]}|�d� q | �|jdgd � dS )z� The L{root.Resolver} which eventually replaces L{root.DeferredResolver} is supplied with the IP addresses of the 13 root servers. r� � N)r� r r� r� r� r: r� r� r( r( r) � test_resolverReceivesRootHints� s z-BootstrapTests.test_resolverReceivesRootHintsc s^ t � }t�|�� t|j�}t|�}|D ]}|�d� q|�t� � � �fdd�}|� |� dS )z� The L{root.Resolver} is eventually created, even if some of the root hint lookups fail. Only the working root hint IP addresses are supplied to the L{root.Resolver}. r� c s �� � jdgd � d S )Nr� � �r: r� ��res�r� rE r( r) � checkHints� s zFBootstrapTests.test_continuesWhenSomeRootHintsFail.<locals>.checkHintsN) r� r r� �iterr� �nextr� �errbackr �addBoth�rE r� r$ �d1rH r� r( r� r) �#test_continuesWhenSomeRootHintsFail� s z2BootstrapTests.test_continuesWhenSomeRootHintsFailc sn t � }t�|�� t|j�}t|�}|D ]}|�t� � q|�t� � � �fdd�}|�|� �� �j t� dS )z� The L{root.Resolver} is eventually created, even if all of the root hint lookups fail. Pending and new lookups will then fail with AttributeError. c s �� � jg � d S �Nr� r� r� r( r) r� � s zEBootstrapTests.test_continuesWhenAllRootHintsFail.<locals>.checkHintsN) r� r r� r� r� r� r� r r� � addCleanup�flushLoggedErrorsr� r( r� r) �"test_continuesWhenAllRootHintsFail� s z1BootstrapTests.test_continuesWhenAllRootHintsFailc C s< t � }tj|td�}|jD ]}|�d� q | �|jt� dS )z� L{root.bootstrap} accepts a C{resolverFactory} argument which is passed as an argument to L{root.Resolver} when it has successfully looked up root hints. )r� r� N)r� r r� r� r� r� r� r� r� r( r( r) �test_passesResolverFactory� s � z)BootstrapTests.test_passesResolverFactoryN) r� r� r� r� r� r� r� r� r� r� r� r( r( r( r) r� l s r� c @ r� )�StubDNSDatagramProtocolz� A do-nothing stand-in for L{DNSDatagramProtocol} which can be used to avoid network traffic in tests where that kind of thing doesn't matter. c O s t � S r� )r )rE �a�kwr( r( r) rd � s z StubDNSDatagramProtocol.queryN)r� r� r� r� rd r( r( r( r) r� � r� r� zbtwisted.names.root.retry is deprecated since Twisted 10.0. Use a Resolver object for retry logic.)�categoryrM N):r� �zope.interfacer �zope.interface.verifyr �twisted.internet.deferr r r r �twisted.internet.interfacesr � twisted.namesr r �twisted.names.dnsr r r r r r r r r r r r r r �twisted.names.errorr r �twisted.names.rootr � twisted.names.test.test_utilr �twisted.python.logr � twisted.trialr �twisted.trial.unittestr r r* r- r. � Exceptionr� r� r� r� r� r� r� �suppress�DeprecationWarning�_retrySuppressionr( r( r( r) �<module> s@ @ 6* $f �PK y�ZS>�� � * test/__pycache__/test_util.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z m Z ddlmZ ee �G d d � d ��Zee e� ee �G d d � d e��Zee e� d S )z$ Utilities for Twisted.names tests. � )� randrange)� implementer)� verifyClass)� IPv4Address)�succeed)� IReactorUDP� IUDPTransport)�Clockc @ sJ e Zd ZdZdd� Zdd� Zdd� Zdd d �Zd d � Zd d� Z dd� Z dS )�MemoryDatagramTransporta� This L{IUDPTransport} implementation enforces the usual connection rules and captures sent traffic in a list for later inspection. @ivar _host: The host address to which this transport is bound. @ivar _protocol: The protocol connected to this transport. @ivar _sentPackets: A C{list} of two-tuples of the datagrams passed to C{write} and the addresses to which they are destined. @ivar _connectedTo: L{None} if this transport is unconnected, otherwise an address to which all traffic is supposedly sent. @ivar _maxPacketSize: An C{int} giving the maximum length of a datagram which will be successfully handled by C{write}. c C s" || _ || _g | _d | _|| _d S �N)�_host� _protocol� _sentPackets� _connectedTo�_maxPacketSize)�self�host�protocol� maxPacketSize� r �>/usr/lib/python3/dist-packages/twisted/names/test/test_util.py�__init__& s z MemoryDatagramTransport.__init__c C s t dg| j�R � S )z_ Return the address which this transport is pretending to be bound to. �UDP)r r �r r r r �getHost- s z MemoryDatagramTransport.getHostc C s | j dur td��||f| _ dS )z> Connect this transport to the given address. NzAlready connected)r � ValueError)r r �portr r r �connect4 s z MemoryDatagramTransport.connectNc C sH |du r| j }|du rtd��t|�| jkrtd��| j�||f� dS )z* Send the given datagram. NzNeed an addresszPacket too big)r r �lenr r �append)r �datagram�addrr r r �write< s z MemoryDatagramTransport.writec C s | j �� td�S )z+ Shut down this transport. N)r � stopProtocolr r r r r � stopListeningH s z%MemoryDatagramTransport.stopListeningc C � dS �zC Dummy implementation to satisfy L{IUDPTransport}. Nr )r �enabledr r r �setBroadcastAllowedO � z+MemoryDatagramTransport.setBroadcastAllowedc C r% r& r r r r r �getBroadcastAllowedU r) z+MemoryDatagramTransport.getBroadcastAllowedr ) �__name__� __module__� __qualname__�__doc__r r r r" r$ r( r* r r r r r s r c @ s" e Zd ZdZdd� Zd dd�ZdS ) � MemoryReactoraO An L{IReactorTime} and L{IReactorUDP} provider. Time is controlled deterministically via the base class, L{Clock}. UDP is handled in-memory by connecting protocols to instances of L{MemoryDatagramTransport}. @ivar udpPorts: A C{dict} mapping port numbers to instances of L{MemoryDatagramTransport}. c C s t �| � i | _d S r )r r �udpPortsr r r r r l s zMemoryReactor.__init__� � c C s\ |dkr t dd�}|| jvrnq|| jv rtd��t||f||�}|| j|< |�|� |S )zR Pretend to bind a UDP port and connect the given protocol to it. r T� i zAddress in use)r r0 r r �makeConnection)r r r � interfacer � transportr r r � listenUDPp s � zMemoryReactor.listenUDPN)r1 r2 )r+ r, r- r. r r7 r r r r r/ _ s r/ N)r. �randomr �zope.interfacer �zope.interface.verifyr �twisted.internet.addressr �twisted.internet.deferr �twisted.internet.interfacesr r �twisted.internet.taskr r r/ r r r r �<module> s G!PK y�Z ^��r� r� , test/__pycache__/test_client.cpython-310.pycnu �[��� o �b � � @ s� d Z ddlZddlmZmZ ddlmZ ddlmZm Z ddl m Z ddl m Z ddlmZ dd lmZmZmZmZmZ dd lmZ dd lmZ dd lmZ dd l m Z ddl m Z ddl m!Z! ddl"m#Z# ddl$m%Z% ddl&m'Z' e#�(� sydZ)ndZ)G dd� de�Z*G dd� d�Z+G dd� d�Z,G dd� de'j-�Z.G d d � d e'j-e �Z/G d d � d e'j-�Z0G d d!� d!e'j-�Z1G d"d#� d#e'j-�Z2G d$d%� d%�Z3G d&d'� d'e'j-�Z4G d(d)� d)e'j-�Z5dS )*z) Test cases for L{twisted.names.client}. � N)� verifyClass� verifyObject)�defer)�CannotListenError�ConnectionRefusedError)� IResolver)�Clock)�AlternateReactor)�cache�client�dns�error�hosts)� ResolverBase)�DNSQueryTimeoutError)� test_util)�GoodTempPathMixin)�failure)�FilePath)�platform)� proto_helpers)�unittestz:These tests need more work before they'll work on Windows.c @ s e Zd Zdd� ZdS )� FakeResolverc C sZ |dkrt j|t j|dt jddd�d�}n t j|||dd�}|g}g }g }t�|||f�S )z� The getHostByNameTest does a different type of query that requires it return an A record from an ALL_RECORDS lookup, so we accommodate that here. � getHostByNameTest�< � 127.0.0.1)�address�ttl)�name�type�clsr �payload)r r r r )r �RRHeader�A�Record_Ar �succeed) �selfr r �qtype�timeout�rr�results� authority� additional� r- �@/usr/lib/python3/dist-packages/twisted/names/test/test_client.py�_lookup$ s �zFakeResolver._lookupN)�__name__� __module__� __qualname__r/ r- r- r- r. r # s r c @ s e Zd ZdZdZdd� ZdS )�StubPortz� A partial implementation of L{IListeningPort} which only keeps track of whether it has been stopped. @ivar disconnected: A C{bool} which is C{False} until C{stopListening} is called, C{True} afterwards. Fc C s d| _ d S )NT)� disconnected�r& r- r- r. � stopListeningF s zStubPort.stopListeningN)r0 r1 r2 �__doc__r4 r6 r- r- r- r. r3 ; s r3 c @ s" e Zd ZdZdd� Zddd�ZdS ) �StubDNSDatagramProtocolz� L{dns.DNSDatagramProtocol}-alike. @ivar queries: A C{list} of tuples giving the arguments passed to C{query} along with the L{defer.Deferred} which was returned from the call. c C � g | _ t� | _d S �N��queriesr3 � transportr5 r- r- r. �__init__S � z StubDNSDatagramProtocol.__init__� Nc C s" t �� }| j�|||||f� |S )zv Record the given arguments and return a Deferred which will not be called back by this code. )r �Deferredr< �append)r& r r< r( �id�resultr- r- r. �queryW s z StubDNSDatagramProtocol.query�r@ N)r0 r1 r2 r7 r> rE r- r- r- r. r8 J s r8 c @ s$ e Zd ZdZeZdd� Zdd� ZdS )�GetResolverTestsz* Tests for L{client.getResolver}. c C sF t t� �� t�� }W d � n1 sw Y | �tt|�� dS )zQ L{client.getResolver} returns an object providing L{IResolver}. N)r r r � getResolver� assertTruer r �r& �resolverr- r- r. �test_interfaceh s �z GetResolverTests.test_interfacec C sJ t t� �� t�� }t�� }W d � n1 sw Y | �||� dS )zn Multiple calls to L{client.getResolver} return the same L{IResolver} implementation. N)r r r rH �assertIs)r& �a�br- r- r. �test_idempotentp s �z GetResolverTests.test_idempotentN)r0 r1 r2 r7 � windowsSkip�skiprL rP r- r- r- r. rG a s rG c @ sd e Zd ZdZeZdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� Zdd� ZdS )�CreateResolverTestsz- Tests for L{client.createResolver}. c C s6 dd� |j D �}| �dt|�� | �|d j|� d S )Nc S � g | ] }t |tj�r|�qS r- )� isinstancer �Resolver��.0�rr- r- r. � <listcomp>� � z2CreateResolverTests._hostsTest.<locals>.<listcomp>� r )� resolvers� assertEqual�len�file�r& rK �filename�resr- r- r. � _hostsTest� s z CreateResolverTests._hostsTestc C �B t t� �� t�� }W d � n1 sw Y | �|d� dS )z� L{client.createResolver} returns a L{resolve.ResolverChain} including a L{hosts.Resolver} using I{/etc/hosts} if no alternate hosts file is specified. Ns /etc/hosts�r r r �createResolverrd rJ r- r- r. �test_defaultHosts� � �z%CreateResolverTests.test_defaultHostsc C �F t t� �� tjdd�}W d � n1 sw Y | �|d� dS )z� The I{hosts} parameter to L{client.createResolver} overrides the hosts file used by the L{hosts.Resolver} in the L{resolve.ResolverChain} it returns. � /foo/bar)r Nrf rJ r- r- r. �test_overrideHosts� � �z&CreateResolverTests.test_overrideHostsc C s6 dd� |j D �}| �dt|�� | �|d j|� dS )z| Verify that C{resolver} has a L{client.Resolver} with a configuration filename set to C{filename}. c S rT r- �rU r rV rW r- r- r. rZ � r[ z7CreateResolverTests._resolvConfTest.<locals>.<listcomp>r\ r N)r] r^ r_ �resolvra r- r- r. �_resolvConfTest� s z#CreateResolverTests._resolvConfTestc C sl t � }t|�� t�� }W d � n1 sw Y dd� |jD �}| �dt|�� | �||d j� dS )z� The L{client.Resolver} included in the L{resolve.ResolverChain} returned by L{client.createResolver} uses the global reactor. Nc S rT r- rn rW r- r- r. rZ � r[ z4CreateResolverTests.test_reactor.<locals>.<listcomp>r\ r ) r r r rg r] r^ r_ rM �_reactor)r& �reactorrK rc r- r- r. � test_reactor� s �z CreateResolverTests.test_reactorc C re )z� L{client.createResolver} returns a L{resolve.ResolverChain} including a L{client.Resolver} using I{/etc/resolv.conf} if no alternate resolver configuration file is specified. Ns /etc/resolv.conf�r r r rg rp rJ r- r- r. �test_defaultResolvConf� ri z*CreateResolverTests.test_defaultResolvConfc C rj )z� The I{resolvconf} parameter to L{client.createResolver} overrides the resolver configuration file used by the L{client.Resolver} in the L{resolve.ResolverChain} it returns. rk �� resolvconfNrt rJ r- r- r. �test_overrideResolvConf� rm z+CreateResolverTests.test_overrideResolvConfc C s� | � � }|�d� tt� �� tj|j d�}W d � n1 s w Y dd� |jD �}| �dt|�� | �g |d j � | �dg|d j � dS ) z� If no servers are given, addresses are taken from the file given by the I{resolvconf} parameter to L{client.createResolver}. � nameserver 127.1.2.3 rv Nc S rT r- rn rW r- r- r. rZ � r[ z;CreateResolverTests.test_defaultServers.<locals>.<listcomp>r\ r �z 127.1.2.3�5 � �path� setContentr r r rg r] r^ r_ �servers� dynServers�r& rw rK rc r- r- r. �test_defaultServers� s �z'CreateResolverTests.test_defaultServersc C s� | � � }|�d� tt� �� tjdg|j d�}W d � n1 s"w Y dd� |jD �}| �dt|�� | �dg|d j � | �d g|d j � dS ) z� Servers passed to L{client.createResolver} are used in addition to any found in the file given by the I{resolvconf} parameter. ry )z 127.3.2.1r{ )r rw Nc S rT r- rn rW r- r- r. rZ � r[ z<CreateResolverTests.test_overrideServers.<locals>.<listcomp>r\ r rz r| r� r- r- r. �test_overrideServers� s � �z(CreateResolverTests.test_overrideServersc C sV t t� �� t�� }W d � n1 sw Y dd� |jD �}| �dt|�� dS )zy L{client.createResolver} returns a L{resolve.ResolverChain} including a L{cache.CacheResolver}. Nc S rT r- )rU r � CacheResolverrW r- r- r. rZ � r[ z2CreateResolverTests.test_cache.<locals>.<listcomp>r\ )r r r rg r] r^ r_ )r& rK rc r- r- r. � test_cache� s �z CreateResolverTests.test_cacheN)r0 r1 r2 r7 rQ rR rd rh rl rp rs ru rx r� r� r� r- r- r- r. rS { s rS c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:S );� ResolverTestsz' Tests for L{client.Resolver}. c C s t tt� dS )z] L{client} provides L{IResolver} through a series of free functions. N)r r r r5 r- r- r. � test_clientProvidesIResolver� s z*ResolverTests.test_clientProvidesIResolverc C s t ttj� dS )z; L{client.Resolver} provides L{IResolver}. N)r r r rV r5 r- r- r. �$test_clientResolverProvidesIResolver� � z2ResolverTests.test_clientResolverProvidesIResolverc C s | � ttj� dS )z� L{client.Resolver} raises L{ValueError} if constructed with neither servers nor a nameserver configuration file. N)� assertRaises� ValueErrorr rV r5 r- r- r. �test_noServers� s z ResolverTests.test_noServersc C s( t j| �� t� d�}| �dg|j� dS )z� A missing nameserver configuration file results in no server information being loaded from it (ie, not an exception) and a default server being provided. �ro rr �r r{ N)r rV �mktempr r^ r� rJ r- r- r. �test_missingConfiguration s z'ResolverTests.test_missingConfigurationc sR t | �� �}|jdd�� G � fdd�dtj�}|ddgdt� d� | �� j� d S ) z� As part of its constructor, C{StubResolver} opens C{/etc/resolv.conf}; then, explicitly closes it and does not count on the GC to do so for it. zw+)�modec � e Zd Z� fdd�ZdS )z9ResolverTests.test_closesResolvConf.<locals>.StubResolverc � � S r: r- )r& r �� resolvConfr- r. � _openFile s zCResolverTests.test_closesResolvConf.<locals>.StubResolver._openFileN)r0 r1 r2 r� r- r� r- r. � StubResolver � r� � example.comr{ z/etc/resolv.conf)r ro rr N)r r� �openr rV r rI �closed)r& �handler� r- r� r. �test_closesResolvConf s �z#ResolverTests.test_closesResolvConfc C s, t jdgd�}|�dg� | �d|j� dS )z� L{client.Resolver.parseConfig} treats a I{domain} line without an argument as indicating a domain of C{b""}. r� �r s domain � N)r rV � parseConfigr^ �domainrJ r- r- r. �test_domainEmptyArgument! � z&ResolverTests.test_domainEmptyArgumentc C s, t jdgd�}|�dg� | �g |j� dS )z� L{client.Resolver.parseConfig} treats a I{search} line without an argument as indicating an empty search suffix. r� r� s search N)r rV r� r^ �searchrJ r- r- r. �test_searchEmptyArgument* r� z&ResolverTests.test_searchEmptyArgumentc sd t � � ddg}ddg}tj|d�}||_� fdd�|_t� }|�d�}|�| j|� | �t � j �d � | � � j d d |d � � j d d � t d �� | �t � j �d � | � � j d d |d � � j d d � t d �� | �t � j �d � | � � j d d |d � � j d d � t d �� | �t � j �d� | � � j d d |d � � j d d �|� |S )a L{client.Resolver.queryUDP} should issue queries to its L{dns.DNSDatagramProtocol} with server addresses taken from its own C{servers} and C{dynServers} lists, proceeding through them in order as L{DNSQueryTimeoutError}s occur. �z::1r{ )z::2r{ )z::3r{ )z::4r{ r� c r� r: r- )� interface��protocolr- r. �<lambda>@ � z=ResolverTests.test_datagramQueryServerOrder.<locals>.<lambda>Nr\ r ���� � � )r8 r rV r� �_connectedProtocol�object�queryUDP� addCallbackr^ r_ r< rM �errbackr �callback)r& r r� rK �expectedResult� queryResultr- r� r. � test_datagramQueryServerOrder3 s, z+ResolverTests.test_datagramQueryServerOrderc s� t � �tjdgd�}�fdd�|_�j}t�dtjtj�}|� |�}�� t |�d� |� |�}�� t |�d� t � � t� � }|j�� � |�� d �|� t�||g�}� �fdd �}|�|� |S ) z� L{client.Resolver.query} only issues one request at a time per query. Subsequent requests made before responses to prior ones are received are queued and given the same response as is given to the first one. �r� r{ r� c r� r: r- r- r� r- r. r� ] r� z<ResolverTests.test_singleConcurrentRequest.<locals>.<lambda>� foo.example.comr\ r� c s4 | \}}�� |� gg g f� �� |� gg g f� d S r: �r^ )� responses� firstResponse�secondResponse)�answerr& r- r. � cbFinishedr s z>ResolverTests.test_singleConcurrentRequest.<locals>.cbFinished)r8 r rV r� r< r �Queryr# �INrE r^ r_ r� �Message�answersrB �popr� r � gatherResultsr� ) r& rK r< rE � firstResult� secondResult�response�dr� r- )r� r� r& r. � test_singleConcurrentRequestU s" z*ResolverTests.test_singleConcurrentRequestc s� t � � tjdgd�}� fdd�|_� j}t�dtj�}|�|� | � t |�d� t�dtj�}|�|� | � t |�d� t�dtj �}|�|� | � t |�d � d S ) zh L{client.Resolver.query} issues a request for each different concurrent query. r� r� c r� r: r- r- r� r- r. r� � r� z?ResolverTests.test_multipleConcurrentRequests.<locals>.<lambda>r� r\ � bar.example.comr� r� N) r8 r rV r� r< r r� r# rE r^ r_ �A6)r& rK r< � firstQuery� secondQuery� thirdQueryr- r� r. � test_multipleConcurrentRequestsz s z-ResolverTests.test_multipleConcurrentRequestsc s� t � � tjdgd�}� fdd�|_� j}t�dtj�}|�|� | � t |�d� |� � d � t� � � |�|� | � t |�d� dS ) z� After a response is received to a query issued with L{client.Resolver.query}, another query with the same parameters results in a new network request. r� r� c r� r: r- r- r� r- r. r� � r� z?ResolverTests.test_multipleSequentialRequests.<locals>.<lambda>r� r\ r� N)r8 r rV r� r< r r� r# rE r^ r_ r� r� r� )r& rK r< rE r- r� r. � test_multipleSequentialRequests� s z-ResolverTests.test_multipleSequentialRequestsc s� t � � tjdgd�}� fdd�|_� j}t�dtj�}|�|�}|�|�}G dd� dt �}|� � d � t � |� �� t�| �||�| �||�g�S ) z� If the result of a request is an error response, the Deferreds for all concurrently issued requests associated with that result fire with the L{Failure}. r� r� c r� r: r- r- r� r- r. r� � r� z>ResolverTests.test_multipleConcurrentFailure.<locals>.<lambda>r� c @ � e Zd ZdS )zGResolverTests.test_multipleConcurrentFailure.<locals>.ExpectedExceptionN�r0 r1 r2 r- r- r- r. �ExpectedException� � r� r� )r8 r rV r� r< r r� r# rE � Exceptionr� r� r �Failurer r� � assertFailure)r& rK r< rE r� r� r� r- r� r. � test_multipleConcurrentFailure� s ��z,ResolverTests.test_multipleConcurrentFailurec C st t jdgd�}|�� }|�� }| �|j� | �|j� | �|j�� j|j�� j� t� t� |jj �t� |jj �g�S )z� L{client.Resolver._connectedProtocol} returns a new L{DNSDatagramProtocol} connected to a new address with a cryptographically secure random port number. r� r� ) r rV r� �assertIsNotNoner= �assertNotEqual�getHost�portr r� � maybeDeferredr6 )r& rK � firstProto� secondProtor- r- r. �test_connectedProtocol� s � ��z$ResolverTests.test_connectedProtocolc C s4 t �� }tj| �� |d�}|�� }| �|j|� dS )z� If a reactor instance is supplied to L{client.Resolver} L{client.Resolver._connectedProtocol} should pass that reactor to L{twisted.names.dns.DNSDatagramProtocol}. r� N)r � MemoryReactorr rV r� r� rM rq )r& rr rK �protor- r- r. �)test_resolverUsesOnlyParameterizedReactor� s z7ResolverTests.test_resolverUsesOnlyParameterizedReactorc sb t jdgd�}g � G � fdd�d�}||_|�t�d�� |�t�d�� | �tt� ��d� dS ) z� L{client.Resolver._connectedProtocol} is called once each time a UDP request needs to be issued and the resulting protocol instance is used for that request. r� r� c s" e Zd Zdd� Zd� fdd� ZdS )z:ResolverTests.test_differentProtocol.<locals>.FakeProtocolc S � t � | _d S r: �r3 r= r5 r- r- r. r> � � zCResolverTests.test_differentProtocol.<locals>.FakeProtocol.__init__r@ Nc s � � | � t�t�� �S r: )rB r r% r r� �r& r rE r( rC �� protocolsr- r. rE � s z@ResolverTests.test_differentProtocol.<locals>.FakeProtocol.queryrF �r0 r1 r2 r> rE r- r� r- r. � FakeProtocol� s r� r� r� r� N) r rV r� rE r r� r^ r_ �set�r& rK r� r- r� r. �test_differentProtocol� s z$ResolverTests.test_differentProtocolc C sR t �� }tjdg|d�}|�t�d�� |j�� \\}}|� � j }| � d|� dS )z< If the resolver is ipv6, open a ipv6 port. r� �r rr r� z::N) r r� r rV rE r r� �udpPorts�itemsr� �hostr^ )r& �fakerK r� r= r� r- r- r. �test_ipv6Resolver s z ResolverTests.test_ipv6Resolverc sL g � G � fdd�d�}t jdgd�}|� |_|�� | �tt� ��d� dS )z� If a port number is initially selected which cannot be bound, the L{CannotListenError} is handled and another port number is attempted. c r� )z6ResolverTests.test_disallowedPort.<locals>.FakeReactorc s& � � |� t� �dkrtd |d ��d S )Nr\ )rB r_ r �r& r� �args�kwargs��portsr- r. � listenUDP s �z@ResolverTests.test_disallowedPort.<locals>.FakeReactor.listenUDPN�r0 r1 r2 r� r- r� r- r. � FakeReactor r� r� r� r� r� N)r rV rq r� r^ r_ r� �r& r� rK r- r� r. �test_disallowedPort s z!ResolverTests.test_disallowedPortc sN g � G � fdd�d�}t jdgd�}|� |_| �t|j� | �t� �d� dS )z� If port numbers that cannot be bound are repeatedly selected, L{resolver._connectedProtocol} will give up eventually. c r� )z@ResolverTests.test_disallowedPortRepeatedly.<locals>.FakeReactorc s � � |� td |d ��r: )rB r r� r� r- r. r� ' s zJResolverTests.test_disallowedPortRepeatedly.<locals>.FakeReactor.listenUDPNr� r- r� r- r. r� & r� r� r� r� i� N)r rV rq r� r r� r^ r_ r� r- r� r. � test_disallowedPortRepeatedly s z+ResolverTests.test_disallowedPortRepeatedlyc s` g � G � fdd�d�}t jdgd�}|� |_| �t|j�}| �|jjtj � | �t � �d� dS )zf If the process is out of files, L{Resolver._connectedProtocol} will give up. c r� )z5ResolverTests.test_runOutOfFiles.<locals>.FakeReactorc s" � � |� ttjd�}td ||��)NzOut of files :()rB �OSError�errno�EMFILEr )r& r� r� r� �errr� r- r. r� : s z?ResolverTests.test_runOutOfFiles.<locals>.FakeReactor.listenUDPNr� r- r� r- r. r� 9 r� r� r� r� r\ N) r rV rq r� r r� r^ � socketErrorr r r_ )r& r� rK �excr- r� r. �test_runOutOfFiles2 s z ResolverTests.test_runOutOfFilesc sv t jdgd�}g � t�t�td���t�t� � �g�G � �fdd�d�}||_ |� t� d�� | � tt� ��d� dS )z| When a query issued by L{client.Resolver.query} times out, the retry uses a new protocol instance. r� r� Nc �$ e Zd Zdd� Zd� �fdd� ZdS )zFResolverTests.test_differentProtocolAfterTimeout.<locals>.FakeProtocolc S r� r: r� r5 r- r- r. r> U r� zOResolverTests.test_differentProtocolAfterTimeout.<locals>.FakeProtocol.__init__r@ Nc � � � | � ��d�S �Nr �rB r� r� �r� r* r- r. rE X � zLResolverTests.test_differentProtocolAfterTimeout.<locals>.FakeProtocol.queryrF r� r- r r- r. r� T � r� r� r� )r rV r �failr r� r r% r r� r� rE r� r^ r_ r� r� r- r r. �"test_differentProtocolAfterTimeoutH s �z0ResolverTests.test_differentProtocolAfterTimeoutc sz t jdgd�}g � t�� �G � �fdd�d�}||_|�t�d�� | �� d j j � �� t� � � | � � d j j � dS )z� After the L{Deferred} returned by L{DNSDatagramProtocol.query} is called back, the L{DNSDatagramProtocol} is disconnected from its transport. r� r� c r )z9ResolverTests.test_protocolShutDown.<locals>.FakeProtocolc S r� r: r� r5 r- r- r. r> k r� zBResolverTests.test_protocolShutDown.<locals>.FakeProtocol.__init__r@ Nc � � � | � �S r: �rB r� �r� rD r- r. rE n � z?ResolverTests.test_protocolShutDown.<locals>.FakeProtocol.queryrF r� r- r r- r. r� j r r� r� r N)r rV r rA r� rE r r� � assertFalser= r4 r� r� rI r� r- r r. �test_protocolShutDown` s z#ResolverTests.test_protocolShutDownc s� t jdgd�}g � t�� }t�t�td���|g�G � �fdd�d�}||_|� t � d�� | � � d j j� |�t �� � | �� d j j� dS )z� The L{DNSDatagramProtocol} created when an interim timeout occurs is also disconnected from its transport after the Deferred returned by its query method completes. r� r� Nc r )zEResolverTests.test_protocolShutDownAfterTimeout.<locals>.FakeProtocolc S r� r: r� r5 r- r- r. r> � r� zNResolverTests.test_protocolShutDownAfterTimeout.<locals>.FakeProtocol.__init__r@ Nc r r r r� r r- r. rE � r zKResolverTests.test_protocolShutDownAfterTimeout.<locals>.FakeProtocol.queryrF r� r- r r- r. r� � r r� r� r\ )r rV r rA r r r� r r� rE r r� r r= r4 r� r� rI )r& rK rD r� r- r r. �!test_protocolShutDownAfterTimeouty s z/ResolverTests.test_protocolShutDownAfterTimeoutc s� G dd� dt �}tjdgd�}g � t�� �G � �fdd�d�}||_|�t�d��}| � � d j j � �� t �|� �� | �� d j j � | �||�S ) z� If the L{Deferred} returned by L{DNSDatagramProtocol.query} fires with a failure, the L{DNSDatagramProtocol} is still disconnected from its transport. c @ r� )zJResolverTests.test_protocolShutDownAfterFailure.<locals>.ExpectedExceptionNr� r- r- r- r. r� � r� r� r� r� c r )zEResolverTests.test_protocolShutDownAfterFailure.<locals>.FakeProtocolc S r� r: r� r5 r- r- r. r> � r� zNResolverTests.test_protocolShutDownAfterFailure.<locals>.FakeProtocol.__init__r@ Nc r r: r r� r r- r. rE � r zKResolverTests.test_protocolShutDownAfterFailure.<locals>.FakeProtocol.queryrF r� r- r r- r. r� � r r� r� r )r� r rV r rA r� rE r r� r r= r4 r� r r� rI r� )r& r� rK r� r� r- r r. �!test_protocolShutDownAfterFailure� s z/ResolverTests.test_protocolShutDownAfterFailurec C sN t jdgd�}|j�d�}|�d� | �||j� |�d� | �||j� dS )z� When a TCP DNS protocol associated with a Resolver disconnects, it is removed from the Resolver's connection list. r� r� N) r rV �factory� buildProtocol�makeConnection�assertIn� connections�connectionLost� assertNotIn)r& rK r� r- r- r. �(test_tcpDisconnectRemovesFromConnections� s z6ResolverTests.test_tcpDisconnectRemovesFromConnectionsc C sv t �� }tjdg|d�}|�t�d��}|jd \}}}}}G dd� dt�} |� |j d t � | � �� | � || � dS )z� The deferred returned by L{client.Resolver.queryTCP} will errback when the TCP connection attempt fails. The reason for the connection failure is passed as the argument to errback. �z 192.0.2.100r{ r� r� r c @ r� )zVResolverTests.test_singleTCPQueryErrbackOnConnectionFailure.<locals>.SentinelExceptionNr� r- r- r- r. �SentinelException� r� r# N)r r� r rV �queryTCPr r� � tcpClientsr� �clientConnectionFailed� connectorsr r� �failureResultOf) r& rr rK r� r� r� r r( � bindAddressr# r- r- r. �-test_singleTCPQueryErrbackOnConnectionFailure� s �z;ResolverTests.test_singleTCPQueryErrbackOnConnectionFailurec C s� t �� }tjdg|d�}|�t�d��}|�t�d��}|jd \}}}}} G dd� dt�} |� |j d t � | � �� | � || �} | � || �} | �| | � dS ) z� All pending L{resolver.queryTCP} C{deferred}s will C{errback} with the same C{Failure} if the connection attempt fails. r" r� r� z example.netr c @ r� )zXResolverTests.test_multipleTCPQueryErrbackOnConnectionFailure.<locals>.SentinelExceptionNr� r- r- r- r. r# � r� r# N)r r� r rV r$ r r� r% r� r& r' r r� r( rM ) r& rr rK �d1�d2r� r� r r( r) r# �f1�f2r- r- r. �/test_multipleTCPQueryErrbackOnConnectionFailure� s � z=ResolverTests.test_multipleTCPQueryErrbackOnConnectionFailurec s t �� }tjdg|d��t�d�� ��� �}� �fdd�}|�|� | �t |j �d� | �t |j �d� |j d \}}}}}t � t� �} |�|j d | � | �t |j �d� | �t |j �d� | �|� t � t� �} |�|j d | � | �|t�} | �| | � d S ) z{ An errback on the deferred returned by L{client.Resolver.queryTCP} may trigger another TCP query. )r iE' r� r� c s | � t� ��� �S r: )�trapr r$ )�e��qrK r- r. �reissue� r zOResolverTests.test_reentrantTCPQueryErrbackOnConnectionFailure.<locals>.reissuer\ r r� N)r r� r rV r r� r$ � addErrbackr^ r_ r% r' r r� r r& �assertNoResultr( rM ) r& rr r� r4 r� r� r r( r) r- r. �fr- r2 r. �0test_reentrantTCPQueryErrbackOnConnectionFailure� s$ z>ResolverTests.test_reentrantTCPQueryErrbackOnConnectionFailurec C s� t �� }tjdg|d�}|�t�d��}|jd \}}}}}|j} | � t | �d� G dd� dt �} |� |j d t�| � �� | �|| � | �|j| � | � t | �d� dS ) z� When the TCP connection attempt fails, the L{client.Resolver.pending} list is emptied in place. It is not replaced with a new empty list. r" r� r� r r\ c @ r� )zJResolverTests.test_pendingEmptiedInPlaceOnError.<locals>.SentinelExceptionNr� r- r- r- r. r# ' r� r# N)r r� r rV r$ r r� r% �pendingr^ r_ r� r& r' r r� r( rM ) r& rr rK r� r� r� r r( r) � prePendingr# r- r- r. �!test_pendingEmptiedInPlaceOnError s � z/ResolverTests.test_pendingEmptiedInPlaceOnErrorN) r0 r1 r2 r7 r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r! r* r/ r8 r; r- r- r- r. r� � s< "% +r� c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z d5d6� Z d7d8� Z d9d:� Z d;S )<� ClientTestsc C s t � t_d| _d| _dS )z: Replace the resolver with a FakeResolver � example.comr N)r r � theResolver�hostname�hostnameForGetHostByNamer5 r- r- r. �setUp4 s zClientTests.setUpc C s dt _dS )zp By setting the resolver to None, it will be recreated next time a name lookup is done. N)r r> r5 r- r- r. �tearDown< s zClientTests.tearDownc C s6 |\}}}|d }| � |jj| j� | � |j|� dS )zT Verify that the result is the same query type as what is expected. r N)r^ r r? r )r& r* r' r� r+ r, rD r- r- r. � checkResultC s zClientTests.checkResultc C s | � |d� dS )zR Test that the getHostByName query returns the 127.0.0.1 address. r Nr� �r& rD r- r- r. �checkGetHostByNameL r� z ClientTests.checkGetHostByNamec C s t �| j�}|�| j� |S )zM do a getHostByName of a value that should return 127.0.0.1. )r � getHostByNamer@ r� rE �r& r� r- r- r. �test_getHostByNameR s z ClientTests.test_getHostByNamec C � t �| j�}|�| jtj� |S )z� Do a lookup and test that the resolver will issue the correct type of query type. We do this by checking that FakeResolver returns a result record with the same query type as what we issued. )r � lookupAddressr? r� rC r r# rG r- r- r. �test_lookupAddressZ s z ClientTests.test_lookupAddressc C rI �z+ See L{test_lookupAddress} )r �lookupIPV6Addressr? r� rC r �AAAArG r- r- r. �test_lookupIPV6Addressd � z"ClientTests.test_lookupIPV6Addressc C rI rL )r �lookupAddress6r? r� rC r r� rG r- r- r. �test_lookupAddress6l rP z ClientTests.test_lookupAddress6c C rI rL )r �lookupNameserversr? r� rC r �NSrG r- r- r. �test_lookupNameserverst rP z"ClientTests.test_lookupNameserversc C rI rL )r �lookupCanonicalNamer? r� rC r �CNAMErG r- r- r. �test_lookupCanonicalName| rP z$ClientTests.test_lookupCanonicalNamec C rI rL )r �lookupAuthorityr? r� rC r �SOArG r- r- r. �test_lookupAuthority� rP z ClientTests.test_lookupAuthorityc C rI rL )r � lookupMailBoxr? r� rC r �MBrG r- r- r. �test_lookupMailBox� rP z ClientTests.test_lookupMailBoxc C rI rL )r �lookupMailGroupr? r� rC r �MGrG r- r- r. �test_lookupMailGroup� rP z ClientTests.test_lookupMailGroupc C rI rL )r �lookupMailRenamer? r� rC r �MRrG r- r- r. �test_lookupMailRename� rP z!ClientTests.test_lookupMailRenamec C rI rL )r � lookupNullr? r� rC r �NULLrG r- r- r. �test_lookupNull� rP zClientTests.test_lookupNullc C rI rL )r �lookupWellKnownServicesr? r� rC r �WKSrG r- r- r. � test_lookupWellKnownServices� rP z(ClientTests.test_lookupWellKnownServicesc C rI rL )r � lookupPointerr? r� rC r �PTRrG r- r- r. �test_lookupPointer� rP z ClientTests.test_lookupPointerc C rI rL )r �lookupHostInfor? r� rC r �HINFOrG r- r- r. �test_lookupHostInfo� rP z ClientTests.test_lookupHostInfoc C rI rL )r �lookupMailboxInfor? r� rC r �MINFOrG r- r- r. �test_lookupMailboxInfo� rP z"ClientTests.test_lookupMailboxInfoc C rI rL )r �lookupMailExchanger? r� rC r �MXrG r- r- r. �test_lookupMailExchange� rP z#ClientTests.test_lookupMailExchangec C rI rL )r � lookupTextr? r� rC r �TXTrG r- r- r. �test_lookupText� rP zClientTests.test_lookupTextc C rI rL )r �lookupSenderPolicyr? r� rC r �SPFrG r- r- r. �test_lookupSenderPolicy� rP z#ClientTests.test_lookupSenderPolicyc C rI rL )r �lookupResponsibilityr? r� rC r �RPrG r- r- r. �test_lookupResponsibility� rP z%ClientTests.test_lookupResponsibilityc C rI rL )r �lookupAFSDatabaser? r� rC r �AFSDBrG r- r- r. �test_lookupAFSDatabase� rP z"ClientTests.test_lookupAFSDatabasec C rI rL )r � lookupServicer? r� rC r �SRVrG r- r- r. �test_lookupService� rP z ClientTests.test_lookupServicec C rI rL )r � lookupZoner? r� rC r �AXFRrG r- r- r. �test_lookupZone� rP zClientTests.test_lookupZonec C rI rL )r �lookupAllRecordsr? r� rC r � ALL_RECORDSrG r- r- r. �test_lookupAllRecords rP z!ClientTests.test_lookupAllRecordsc C rI rL )r � lookupNamingAuthorityPointerr? r� rC r �NAPTRrG r- r- r. �!test_lookupNamingAuthorityPointer rP z-ClientTests.test_lookupNamingAuthorityPointerc C s. t �| jt j�}t�|�}|�| jt j� |S )a L{client.query} accepts a L{dns.Query} instance and dispatches it to L{client.theResolver}.C{query}, which in turn dispatches to an appropriate C{lookup*} method of L{client.theResolver}, based on the L{dns.Query} type. )r r� r? r# r rE r� rC )r& r3 r� r- r- r. � test_query s zClientTests.test_queryN) r0 r1 r2 rA rB rC rE rH rK rO rR rU rX r[ r^ ra rd rg rj rm rp rs rv ry r| r r� r� r� r� r� r� r- r- r- r. r< 3 s< r< c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�FilterAnswersTestsz| Test L{twisted.names.client.Resolver.filterAnswers}'s handling of various error conditions it might encounter. c C s t jdgd�| _d S )N)z0.0.0.0r r� )r rV rK r5 r- r- r. rA ' s zFilterAnswersTests.setUpc sV t jdd�� � �d� � �fdd�}|�j_�j�� �}|��jdgdgdgf� |S ) zf Test that a truncated message results in an equivalent request made via TCP. T)�truncr= c s8 �� | � j� t�� }dg|_dg|_dg|_t�|�S )Nr� r+ r, ) r^ r< r r� r� r+ r, r r% )r< r� ��mr& r- r. r$ 4 s z:FilterAnswersTests.test_truncatedMessage.<locals>.queryTCPr� r+ r, )r r� �addQueryrK r$ � filterAnswersr� r^ )r& r$ r� r- r� r. �test_truncatedMessage, s z(FilterAnswersTests.test_truncatedMessagec C s& t j|d�}| j�|�}|�|� d S )N)�rCode)r r� rK r� r0 )r& �rcoder r� r r- r- r. � _rcodeTestA s z FilterAnswersTests._rcodeTestc C � | � tjtj�S )z� Test that a message with a result code of C{EFORMAT} results in a failure wrapped around L{DNSFormatError}. )r� r �EFORMATr �DNSFormatErrorr5 r- r- r. �test_formatErrorF s z#FilterAnswersTests.test_formatErrorc C r� )zP Like L{test_formatError} but for C{ESERVER}/L{DNSServerError}. )r� r �ESERVERr �DNSServerErrorr5 r- r- r. �test_serverErrorM r� z#FilterAnswersTests.test_serverErrorc C r� )zL Like L{test_formatError} but for C{ENAME}/L{DNSNameError}. )r� r �ENAMEr � DNSNameErrorr5 r- r- r. �test_nameErrorS r� z!FilterAnswersTests.test_nameErrorc C r� )zX Like L{test_formatError} but for C{ENOTIMP}/L{DNSNotImplementedError}. )r� r �ENOTIMPr �DNSNotImplementedErrorr5 r- r- r. �test_notImplementedErrorY r� z+FilterAnswersTests.test_notImplementedErrorc C r� )zW Like L{test_formatError} but for C{EREFUSED}/L{DNSQueryRefusedError}. )r� r �EREFUSEDr �DNSQueryRefusedErrorr5 r- r- r. �test_refusedError_ r� z$FilterAnswersTests.test_refusedErrorc C s | � tjd tj�S )zm Like L{test_formatError} but for an unrecognized error code and L{DNSUnknownError}. r\ )r� r r� r �DNSUnknownErrorr5 r- r- r. �test_refusedErrorUnknowne s z+FilterAnswersTests.test_refusedErrorUnknownN) r0 r1 r2 r7 rA r� r� r� r� r� r� r� r� r- r- r- r. r� ! s r� c @ s& e Zd Zdd� Zd dd�Zdd� ZdS ) �FakeDNSDatagramProtocolc C r9 r: r; r5 r- r- r. r> n r? z FakeDNSDatagramProtocol.__init__r@ Nc C s$ | j �||||f� t�t�|��S r: )r< rB r r r r )r& r r< r( rC r- r- r. rE r s z FakeDNSDatagramProtocol.queryc C s d S r: r- )r& rC r- r- r. � removeResendv s z$FakeDNSDatagramProtocol.removeResendrF )r0 r1 r2 r> rE r� r- r- r- r. r� m s r� c @ s0 e Zd ZdZg d�Zdd� Zdd� Zdd� Zd S ) �RetryLogicTestszE Tests for query retrying implemented by L{client.Resolver}. )z1.2.3.4z4.3.2.1za.b.c.dzz.y.x.wc sN dd� | j D �}tjd|d�}t� � � fdd�|_|�d��| j��| j � �S )a When timeouts occur waiting for responses to queries, the next configured server is issued the query. When the query has been issued to all configured servers, the timeout is increased and the process begins again at the beginning. c S s g | ]}|d f�qS )r{ r- )rX �xr- r- r. rZ � s z:RetryLogicTests.test_roundRobinBackoff.<locals>.<listcomp>N)ro r c r� r: r- r- �r� r- r. r� � r� z8RetryLogicTests.test_roundRobinBackoff.<locals>.<lambda>r� ) � testServersr rV r� r� rJ r� �_cbRoundRobinBackoffr5 �_ebRoundRobinBackoff)r& �addrsrY r- r� r. �test_roundRobinBackoff� s �z&RetryLogicTests.test_roundRobinBackoffc C s | � d� d S )Nz/Lookup address succeeded, should have timed out)r rD r- r- r. r� � s z$RetryLogicTests._cbRoundRobinBackoffc C s� |� tj� dD ]>}|jd t| j�� }|jd t| j��= |�� t| j�}|�� t||�D ]\\}}}} } | � || df� | � ||� q/q| � |j� d S )N)r\ r� � �- r{ ) r0 r � TimeoutErrorr< r_ r� �sort�list�zipr^ r ) r& r � fakeProto�t�tries�expected�addrrE r( rC � expectedAddrr- r- r. r� � s �z$RetryLogicTests._ebRoundRobinBackoffN)r0 r1 r2 r7 r� r� r� r� r- r- r- r. r� { s r� c @ s e Zd ZdZdd� ZdS )�ThreadedResolverTestsz/ Tests for L{client.ThreadedResolver}. c C sT t �� | j| jgd�}| �|d d d� | �|d d t� | �t|�d� dS )z� L{client.ThreadedResolver} is deprecated. Instantiating it emits a deprecation warning pointing at the code that does the instantiation. )�offendingFunctionsr �messagezztwisted.names.client.ThreadedResolver is deprecated since Twisted 9.0, use twisted.internet.base.ThreadedResolver instead.�categoryr\ N)r �ThreadedResolver� flushWarnings�test_deprecatedr^ �DeprecationWarningr_ )r& �warningsr- r- r. r� � s �z%ThreadedResolverTests.test_deprecatedN)r0 r1 r2 r7 r� r- r- r- r. r� � s r� )6r7 r �zope.interface.verifyr r �twisted.internetr �twisted.internet.errorr r �twisted.internet.interfacesr �twisted.internet.taskr �#twisted.internet.test.modulehelpersr � twisted.namesr r r r r �twisted.names.commonr �twisted.names.errorr �twisted.names.testr � twisted.names.test.test_hostsr �twisted.pythonr �twisted.python.filepathr �twisted.python.runtimer � twisted.testr � twisted.trialr � isWindowsrQ r r3 r8 �TestCaserG rS r� r< r� r� r� r� r- r- r- r. �<module> sJ r J oL0PK y�Z�;� u u ) test/__pycache__/test_tap.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z m Z ddlmZ dd lmZ dd lmZ G d d � d e�Zd S )z! Tests for L{twisted.names.tap}. � )�ThreadedResolver)�Resolver)�PORT)� ResolverChain)�SecondaryAuthorityService)�Options�_buildResolvers)�platform)� UsageError)�SynchronousTestCasec @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � OptionsTestszf Tests for L{Options}, defining how command line arguments for the DNS server are parsed. c C sZ t � }| �t|jddg� | �t|jddg� | �t|jddg� | �t|jddg� dS )z� If the value supplied for an I{--secondary} option does not provide a server IP address, optional port number, and domain name, L{Options.parseOptions} raises L{UsageError}. � --secondary� �1.2.3.4z 1.2.3.4:helloz1.2.3.4:hello/example.comN)r � assertRaisesr � parseOptions��self�options� r �=/usr/lib/python3/dist-packages/twisted/names/test/test_tap.py�test_malformedSecondary s ��z$OptionsTests.test_malformedSecondaryc C s2 t � }|�ddg� | �dtfdgfg|j� dS )z� An argument of the form C{"ip/domain"} is parsed by L{Options} for the I{--secondary} option and added to its list of secondaries, using the default DNS port number. r z1.2.3.4/example.comr � example.comN)r r � assertEqualr � secondariesr r r r �test_secondary+ s zOptionsTests.test_secondaryc C s. t � }|�ddg� | �ddgfg|j� dS )z� An argument of the form C{"ip:port/domain"} can be used to specify an alternate port number for which to act as a secondary. r �1.2.3.4:5353/example.com)r �� r N)r r r r r r r r �test_secondaryExplicitPort5 s z'OptionsTests.test_secondaryExplicitPortc C s� t � }|�g d�� | �t|j�d� |jd }| �|jd t� | �|jd� | �|jd� |jd }| �|jd t� | �|jd� | �|jd� d S ) z� After parsing I{--secondary} options, L{Options} constructs a L{SecondaryAuthorityService} instance for each configured secondary. )r r r z1.2.3.5:5354/example.com� r r r � z1.2.3.5i� N) r r r �len�svcs�assertIsInstancer �primary�_port)r r � secondaryr r r � test_secondaryAuthorityServices> s � z,OptionsTests.test_secondaryAuthorityServicesc C s� t � }|�g d�� t|�\}}|D ]}t|t�r(|jd }t|t�r(|j�� qt � � dkrHddl m } |j D ]}| �|jjtj� |�� q8| �|d t� dS )z� Recursive DNS lookups, if enabled, should be a last-resort option. Any other lookup method (cache, local lookup, etc.) should take precedence over recursive lookups )z --hosts-filez hosts.txtz --recursive����posixr )�reactorN)r r r � isinstancer � resolversr � _parseCall�cancelr �getType�twisted.internetr* �_newTimedCallsr �func�__func__r �_cleanupr# )r r �ca�cl�x�recurserr* r r r �test_recursiveConfigurationV s � z(OptionsTests.test_recursiveConfigurationN) �__name__� __module__� __qualname__�__doc__r r r r' r9 r r r r r s r N)r= �twisted.internet.baser �twisted.names.clientr �twisted.names.dnsr �twisted.names.resolver �twisted.names.secondaryr �twisted.names.tapr r �twisted.python.runtimer �twisted.python.usager �twisted.trial.unittestr r r r r r �<module> s PK y�Z�Fa£ £ , test/__pycache__/test_server.cpython-310.pycnu �[��� o �bǢ � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZm Z m Z m Z ddl m Z mZ ddlmZ G dd � d e�Zd d � ZG d d � d e j�ZG dd� de j�ZG dd� d�ZG dd� d�ZG dd� d�ZG dd� d�Zdd� ZG dd� dej �Z d S ) z) Test cases for L{twisted.names.server}. � )� verifyClass)�defer)�IProtocolFactory)�dns�error�resolve�server)�failure�log)�unittestc @ � e Zd ZdZdd� ZdS )�RaisedArgumentszD An exception containing the arguments raised by L{raiser}. c C s || _ || _d S �N��args�kwargs��selfr r � r �@/usr/lib/python3/dist-packages/twisted/names/test/test_server.py�__init__ s zRaisedArguments.__init__N)�__name__� __module__� __qualname__�__doc__r r r r r r � r c O s t | |��)z� Raise a L{RaisedArguments} exception containing the supplied arguments. Used as a fake when testing the call signatures of methods and functions. )r r r r r �raiser s r c @ s e Zd ZdZdd� Zdd� ZdS )�NoResponseDNSServerFactorya A L{server.DNSServerFactory} subclass which does not attempt to reply to any received messages. Used for testing logged messages in C{messageReceived} without having to fake or patch the preceding code which attempts to deliver a response message. c C � dS )a Deny all queries. @param message: See L{server.DNSServerFactory.allowQuery} @param protocol: See L{server.DNSServerFactory.allowQuery} @param address: See L{server.DNSServerFactory.allowQuery} @return: L{False} @rtype: L{bool} Fr )r �message�protocol�addressr r r � allowQuery. s z%NoResponseDNSServerFactory.allowQueryc C r )z� A noop send reply. @param protocol: See L{server.DNSServerFactory.sendReply} @param message: See L{server.DNSServerFactory.sendReply} @param address: See L{server.DNSServerFactory.sendReply} Nr )r r r r! r r r � sendReply; � z$NoResponseDNSServerFactory.sendReplyN)r r r r r" r# r r r r r $ s r c @ �( e Zd ZdZG dd� de�Zdd� ZdS )�RaisingDNSServerFactoryz� A L{server.DNSServerFactory} subclass whose methods raise an exception containing the supplied arguments. Used for stopping L{messageReceived} and testing the arguments supplied to L{allowQuery}. c @ � e Zd ZdZdS )z+RaisingDNSServerFactory.AllowQueryArguments�G Contains positional and keyword arguments in C{args}. N�r r r r r r r r �AllowQueryArgumentsN � r* c O � | � ||��)aC Raise the arguments supplied to L{allowQuery}. @param args: Positional arguments which will be recorded in the raised exception. @type args: L{tuple} @param kwargs: Keyword args which will be recorded in the raised exception. @type kwargs: L{dict} )r* r r r r r" S s z"RaisingDNSServerFactory.allowQueryN)r r r r � Exceptionr* r" r r r r r& E s r& c @ r% )�RaisingProtocolzm A partial fake L{IProtocol} whose methods raise an exception containing the supplied arguments. c @ r' )z%RaisingProtocol.WriteMessageArgumentsr( Nr) r r r r �WriteMessageArgumentsh r+ r/ c O r, �z� Raises the supplied arguments. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} )r/ r r r r � writeMessagem � z RaisingProtocol.writeMessageN)r r r r r- r/ r1 r r r r r. b � r. c @ r )� NoopProtocolzT A partial fake L{dns.DNSProtocolMixin} with a noop L{writeMessage} method. c O r )z� A noop version of L{dns.DNSProtocolMixin.writeMessage}. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} Nr r r r r r1 r$ zNoopProtocol.writeMessageN)r r r r r1 r r r r r4 z r r4 c @ r% )�RaisingResolverzm A partial fake L{IResolver} whose methods raise an exception containing the supplied arguments. c @ r' )z RaisingResolver.QueryArgumentsr( Nr) r r r r �QueryArguments� r+ r6 c O r, r0 )r6 r r r r �query� r2 zRaisingResolver.queryN)r r r r r- r6 r7 r r r r r5 � r3 r5 c @ r% )� RaisingCachez} A partial fake L{twisted.names.cache.Cache} whose methods raise an exception containing the supplied arguments. c @ r' )z!RaisingCache.CacheResultArgumentsr( Nr) r r r r �CacheResultArguments� r+ r9 c O r, r0 )r9 r r r r � cacheResult� r2 zRaisingCache.cacheResultN)r r r r r- r9 r: r r r r r8 � r3 r8 c O sH g }t �|j� | �t j|j� ||i |�� | �dd� |D �|� dS )a Assert that the callable logs the expected messages when called. XXX: Put this somewhere where it can be re-used elsewhere. See #6677. @param testCase: The test case controlling the test which triggers the logged messages and on which assertions will be called. @type testCase: L{unittest.SynchronousTestCase} @param expectedMessages: A L{list} of the expected log messages @type expectedMessages: L{list} @param callable: The function which is expected to produce the C{expectedMessages} when called. @type callable: L{callable} @param args: Positional arguments to be passed to C{callable}. @type args: L{list} @param kwargs: Keyword arguments to be passed to C{callable}. @type kwargs: L{dict} c S s g | ]}|d d �qS )r r r )�.0�mr r r � <listcomp>� s z$assertLogMessage.<locals>.<listcomp>N)r � addObserver�append� addCleanup�removeObserver� assertEqual)�testCase�expectedMessages�callabler r �loggedMessagesr r r �assertLogMessage� s rG c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBdC� Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNdO� Z*dPdQ� Z+dRdS� Z,dTdU� Z-dVdW� Z.dXdY� Z/dZd[� Z0d\d]� Z1d^d_� Z2d`da� Z3dbdc� Z4ddde� Z5dfdg� Z6dhdi� Z7djdk� Z8dldm� Z9dndo� Z:dpdq� Z;drds� Z<dtdu� Z=dvdw� Z>dxdy� Z?dzd{� Z@d|d}� ZAd~d� ZBd�d�� ZCd�S )��DNSServerFactoryTestsz/ Tests for L{server.DNSServerFactory}. c C s | � t�� jtj� dS )zd L{server.DNSServerFactory.resolver} is a L{resolve.ResolverChain} instance N)�assertIsInstancer �DNSServerFactory�resolverr � ResolverChain�r r r r �test_resolverType� � z'DNSServerFactoryTests.test_resolverTypec C s | � t�� jjg � dS )zn L{server.DNSServerFactory.resolver} is an empty L{resolve.ResolverChain} by default. N�rB r rJ rK � resolversrM r r r �test_resolverDefaultEmpty� rO z/DNSServerFactoryTests.test_resolverDefaultEmptyc C �& t � }| �tj|gd�jj|g� dS )z� L{server.DNSServerFactory.__init__} accepts an C{authorities} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. )� authoritiesN��objectrB r rJ rK rQ �r � dummyResolverr r r �test_authorities� � �z&DNSServerFactoryTests.test_authoritiesc C rS )z� L{server.DNSServerFactory.__init__} accepts a C{caches} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. ��cachesNrU rW r r r � test_caches� rZ z!DNSServerFactoryTests.test_cachesc C rS )z� L{server.DNSServerFactory.__init__} accepts a C{clients} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. ��clientsNrU rW r r r � test_clients rZ z"DNSServerFactoryTests.test_clientsc C sV G dd� d�}G dd� d�}G dd� d�}| � tj|g|g|gd�jj|||g� dS ) zz L{server.DNSServerFactory.resolver} contains an ordered list of authorities, caches and clients. c @ � e Zd ZdS )z@DNSServerFactoryTests.test_resolverOrder.<locals>.DummyAuthorityN�r r r r r r r �DummyAuthority � rc c @ ra )z<DNSServerFactoryTests.test_resolverOrder.<locals>.DummyCacheNrb r r r r � DummyCache rd re c @ ra )z=DNSServerFactoryTests.test_resolverOrder.<locals>.DummyClientNrb r r r r � DummyClient rd rf )rT r\ r_ NrP )r rc re rf r r r �test_resolverOrder s ��z(DNSServerFactoryTests.test_resolverOrderc C � | � t�� j� dS )zI L{server.DNSServerFactory.cache} is L{None} by default. N)� assertIsNoner rJ �cacherM r r r �test_cacheDefault( � z'DNSServerFactoryTests.test_cacheDefaultc C s& t � }| �tjt � |gd�j|� dS )z� L{server.DNSServerFactory.__init__} assigns the last object in the C{caches} list to L{server.DNSServerFactory.cache}. r[ N)rV rB r rJ rj rW r r r �test_cacheOverride. s �z(DNSServerFactoryTests.test_cacheOverridec C rh )z� L{server.DNSServerFactory.canRecurse} is a flag indicating that this server is capable of performing recursive DNS lookups. It defaults to L{False}. N)� assertFalser rJ � canRecurserM r r r �test_canRecurseDefault9 s z,DNSServerFactoryTests.test_canRecurseDefaultc C s | � tjdgd�jd� dS )z~ L{server.DNSServerFactory.__init__} sets C{canRecurse} to L{True} if it is supplied with C{clients}. Nr^ T)rB r rJ ro rM r r r �test_canRecurseOverrideA s z-DNSServerFactoryTests.test_canRecurseOverridec C rh )zJ L{server.DNSServerFactory.verbose} defaults to L{False}. N)rn r rJ �verboserM r r r �test_verboseDefaultH rl z)DNSServerFactoryTests.test_verboseDefaultc C s | � tjdd�j� dS )z� L{server.DNSServerFactory.__init__} accepts a C{verbose} argument which overrides L{server.DNSServerFactory.verbose}. T�rr N)� assertTruer rJ rr rM r r r �test_verboseOverrideN rO z*DNSServerFactoryTests.test_verboseOverridec C s | � tttj�� dS )zL L{server.DNSServerFactory} implements L{IProtocolFactory}. N)ru r r r rJ rM r r r �test_interfaceU � z$DNSServerFactoryTests.test_interfacec C s | � tjjtj� dS )zU L{server.DNSServerFactory.protocol} defaults to L{dns.DNSProtocol}. N)�assertIsr rJ r r � DNSProtocolrM r r r �test_defaultProtocol[ rx z*DNSServerFactoryTests.test_defaultProtocolc s\ G dd� d�}|� � � fdd�}t �� }||_|jdd�}| �� |fi f||j|jf� dS )z� L{server.DNSServerFactory.buildProtocol} builds a protocol by calling L{server.DNSServerFactory.protocol} with its self as a positional argument. c @ s e Zd ZdZdZdZdS )zNDNSServerFactoryTests.test_buildProtocolProtocolOverride.<locals>.FakeProtocolN)r r r �factoryr r r r r r � FakeProtocolh s r} c s | � _ |� _� S r r r �� stubProtocolr r �fakeProtocolFactoryo s zUDNSServerFactoryTests.test_buildProtocolProtocolOverride.<locals>.fakeProtocolFactoryN)�addr)r rJ r � buildProtocolrB r r )r r} r� �f�pr r~ r �"test_buildProtocolProtocolOverridea s "z8DNSServerFactoryTests.test_buildProtocolProtocolOverridec C s t �� }t| g |jd� dS )zm L{server.DNSServerFactory._verboseLog} does not log messages unless C{verbose > 0}. �Foo BarN�r rJ rG � _verboseLog�r r� r r r �test_verboseLogQuietz s z*DNSServerFactoryTests.test_verboseLogQuietc C s" t jdd�}t| dg|jd� dS )zZ L{server.DNSServerFactory._verboseLog} logs a message if C{verbose > 0}. � rt r� Nr� r� r r r �test_verboseLogVerbose� s z,DNSServerFactoryTests.test_verboseLogVerbosec C s. t �� }tdd�}t| dg|j|ddd� dS )z� L{server.DNSServerFactory.messageReceived} logs about an empty query if the message had no queries and C{verbose} is C{>0}. r� rt z$Empty query from ('192.0.2.100', 53)N�z 192.0.2.100�5 �r �protor! )r �Messager rG �messageReceived�r r< r� r r r �"test_messageReceivedLoggingNoQuery� s �z8DNSServerFactoryTests.test_messageReceivedLoggingNoQueryc C �N t �� }|jdt jd� |jdt jd� tdd�}t| dg|j|ddd� dS ) z� L{server.DNSServerFactory.messageReceived} logs the query types of all queries in the message if C{verbose} is set to C{1}. � example.com��name�typer� rt z&MX AAAA query from ('192.0.2.100', 53)Nr� r� �r r� �addQuery�MX�AAAAr rG r� r� r r r � test_messageReceivedLogging1� s �z2DNSServerFactoryTests.test_messageReceivedLogging1c C r� ) z� L{server.DNSServerFactory.messageReceived} logs the repr of all queries in the message if C{verbose} is set to C{2}. r� r� � rt zT<Query example.com MX IN> <Query example.com AAAA IN> query from ('192.0.2.100', 53)Nr� r� r� r� r r r � test_messageReceivedLogging2� s � �z2DNSServerFactoryTests.test_messageReceivedLogging2c sN t �� }t� }t� � | �tjd� fdd�� |j|ddd� | �|j � � dS )zv L{server.DNSServerFactory.messageReceived} assigns a unix timestamp to the received message. �timec � � S r r r ��tr r �<lambda>� r$ zEDNSServerFactoryTests.test_messageReceivedTimestamp.<locals>.<lambda>Nr� ) r r� r rV �patchr r� r� rB � timeReceivedr� r r� r � test_messageReceivedTimestamp� s z3DNSServerFactoryTests.test_messageReceivedTimestampc C s^ t �� }t� }t� }t� }| jtj|j|||d�}|j\}}| �||||f� | �|i � dS )z� L{server.DNSServerFactory.messageReceived} passes all messages to L{server.DNSServerFactory.allowQuery} along with the receiving protocol and origin address. r� N) r r� rV r& � assertRaisesr* r� r rB )r r � dummyProtocol� dummyAddressr� �er r r r r � test_messageReceivedAllowQuery� s � z4DNSServerFactoryTests.test_messageReceivedAllowQueryc sj G dd� dt �� G � fdd�dtj�}|� }| j� |jt�� ddd�}|j\\}}}}| �|j tj � dS )z� If C{allowQuery} returns C{False}, L{server.DNSServerFactory.messageReceived} calls L{server.sendReply} with a message whose C{rCode} is L{dns.EREFUSED}. c @ ra )zFDNSServerFactoryTests.test_allowQueryFalse.<locals>.SendReplyExceptionNrb r r r r �SendReplyException� rd r� c s e Zd Zdd� Z� fdd�ZdS )zKDNSServerFactoryTests.test_allowQueryFalse.<locals>.RaisingDNSServerFactoryc _ r )NFr r r r r r" � � zVDNSServerFactoryTests.test_allowQueryFalse.<locals>.RaisingDNSServerFactory.allowQueryc s � ||��r r r �r� r r r# � s zUDNSServerFactoryTests.test_allowQueryFalse.<locals>.RaisingDNSServerFactory.sendReplyN)r r r r" r# r r� r r r& � s r& Nr� ) r- r rJ r� r� r r� r rB �rCode�EREFUSED)r r& r� r� r� r r! r r r� r �test_allowQueryFalse� s �z*DNSServerFactoryTests.test_allowQueryFalsec sX dg|_ g � � fdd�}t� }t�d�}t|||� |�||� | �� ||dfg� dS )a� Assert that the named method is called with the given message when it is passed to L{DNSServerFactory.messageReceived}. @param methodName: The name of the method which is expected to be called. @type methodName: L{str} @param message: The message which is expected to be passed to the C{methodName} method. @type message: L{dns.Message} Nc s � � | ||f� d S r �r? �r r r! ��receivedMessagesr r � fakeHandler s z?DNSServerFactoryTests._messageReceivedTest.<locals>.fakeHandler)�queriesr4 r rJ �setattrr� rB )r � methodNamer r� r r| r r� r �_messageReceivedTest s z*DNSServerFactoryTests._messageReceivedTestc C � | � dtjtjd�� dS )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_QUERY} on to L{DNSServerFactory.handleQuery}. � handleQuery��opCodeN)r� r r� �OP_QUERYrM r r r �test_queryMessageReceived � z/DNSServerFactoryTests.test_queryMessageReceivedc C r� )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_INVERSE} on to L{DNSServerFactory.handleInverseQuery}. �handleInverseQueryr� N)r� r r� � OP_INVERSErM r r r � test_inverseQueryMessageReceived& s �z6DNSServerFactoryTests.test_inverseQueryMessageReceivedc C r� )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_STATUS} on to L{DNSServerFactory.handleStatus}. � handleStatusr� N)r� r r� � OP_STATUSrM r r r �test_statusMessageReceived/ r� z0DNSServerFactoryTests.test_statusMessageReceivedc C r� )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_NOTIFY} on to L{DNSServerFactory.handleNotify}. � handleNotifyr� N)r� r r� � OP_NOTIFYrM r r r �test_notifyMessageReceived6 r� z0DNSServerFactoryTests.test_notifyMessageReceivedc C r� )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_UPDATE} on to L{DNSServerFactory.handleOther}. This may change if the implementation ever covers update messages. � handleOtherr� N)r� r r� � OP_UPDATErM r r r �test_updateMessageReceived= s z0DNSServerFactoryTests.test_updateMessageReceivedc C s� t � t � }}t�� }|�|� | �|j|g� |�|� | �|j||g� |�|� | �|j|g� |�|� | �|jg � dS )z� The C{connectionMade} and C{connectionLost} methods of L{DNSServerFactory} cooperate to keep track of all L{DNSProtocol} objects created by a factory which are connected. N)rV r rJ �connectionMaderB � connections�connectionLost)r �protoA�protoBr| r r r �test_connectionTrackingF s z-DNSServerFactoryTests.test_connectionTrackingc C sh t �� }|�d� |�d� t�� }t� |_| jtj|j |t � dd�}|j \\}}| � ||j d � dS )z� L{server.DNSServerFactory.handleQuery} takes the first query from the supplied message and dispatches it to L{server.DNSServerFactory.resolver.query}. � one.example.coms two.example.comNr� r )r r� r� r rJ r5 rK r� r6 r� r4 r rB r� )r r< r� r� r7 r r r r �test_handleQueryW s � z&DNSServerFactoryTests.test_handleQueryc s� t �� }t�� � G � fdd�d�}|� |_g ��fdd�}||_t�� }|�d� t � }t � }|j |||d� t � }� � |� | � �||||fi fg� dS )aC L{server.DNSServerFactory.handleQuery} adds L{server.DNSServerFactory.resolver.gotResolverResponse} as a callback to the deferred returned by L{server.DNSServerFactory.resolver.query}. It is called with the query response, the original protocol, message and origin address. c � e Zd Z� fdd�ZdS )zDDNSServerFactoryTests.test_handleQueryCallback.<locals>.FakeResolverc r� r r r ��dr r r7 z r� zJDNSServerFactoryTests.test_handleQueryCallback.<locals>.FakeResolver.queryN�r r r r7 r r� r r � FakeResolvery � r� c � � � | |f� d S r r� r )�gotResolverResponseArgsr r �fakeGotResolverResponse� � zODNSServerFactoryTests.test_handleQueryCallback.<locals>.fakeGotResolverResponser� r� N)r rJ r �DeferredrK �gotResolverResponser r� r� r4 rV r� �callbackrB )r r� r� r� r< r r� � dummyResponser )r� r� r �test_handleQueryCallbackm s$ �z.DNSServerFactoryTests.test_handleQueryCallbackc s� t �� }t�� � G � fdd�d�}|� |_g ��fdd�}||_t�� }|�d� t � }t � }|j |||d� t � t� �}� �|� | ��||||fi fg� dS )a? L{server.DNSServerFactory.handleQuery} adds L{server.DNSServerFactory.resolver.gotResolverError} as an errback to the deferred returned by L{server.DNSServerFactory.resolver.query}. It is called with the query failure, the original protocol, message and origin address. c r� )zCDNSServerFactoryTests.test_handleQueryErrback.<locals>.FakeResolverc r� r r r r� r r r7 � r� zIDNSServerFactoryTests.test_handleQueryErrback.<locals>.FakeResolver.queryNr� r r� r r r� � r� r� c r� r r� r )�gotResolverErrorArgsr r �fakeGotResolverError� r� zKDNSServerFactoryTests.test_handleQueryErrback.<locals>.fakeGotResolverErrorr� r� N)r rJ r r� rK �gotResolverErrorr r� r� r4 rV r� r �Failurer- �errbackrB )r r� r� r� r< r r� � stubFailurer )r� r� r �test_handleQueryErrback� s" �z-DNSServerFactoryTests.test_handleQueryErrbackc C st t �� }g }g }g }| jtj|j|||ft� t�� dd�}|j\\}}| � |j |� | � |j |� | � |j |� dS )z� L{server.DNSServerFactory.gotResolverResponse} accepts a tuple of resource record lists and triggers a response message containing those resource record lists. N�r r r! ) r rJ r� r. r/ r� r r� r ry �answers� authority� additional)r r� r� r� r� r� r r r r r �test_gotResolverResponse� s � z.DNSServerFactoryTests.test_gotResolverResponsec C sd t � }t|_t�� }d|_| jt|jg g g fd|dd�}| � dt |tj g g g d�f|j |j f� dS )z� L{server.DNSServerFactory.gotResolverResponse} calls L{server.DNSServerFactory._responseFromMessage} to generate a response. r� Nr� r )r r� r� r� r� )r r �_responseFromMessager r� r� r� r r� rB �dict�OKr r �r r| �requestr� r r r �0test_gotResolverResponseCallsResponseFromMessage� s0 ��� �zFDNSServerFactoryTests.test_gotResolverResponseCallsResponseFromMessagec C s4 t �� }tjddd�}|j|d�f}| �||� dS )z� L{server.DNSServerFactory._responseFromMessage} generates a response message which is a copy of the request message. F)�answer�recAv�r N)r rJ r r� r� � assertIsNot�r r| r� �responser r r �"test_responseFromMessageNewMessage� s z8DNSServerFactoryTests.test_responseFromMessageNewMessagec C sT t �� }d|_|jtjdd�d�}d|_|jtjdd�d�}| �d|j|jf� dS )z� L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{recAV} attribute is L{True} if L{server.DNSServerFactory.canRecurse} is L{True}. TF)r� r� �TFN)r rJ ro r� r r� rB r� �r r| � response1� response2r r r �*test_responseFromMessageRecursionAvailable s z@DNSServerFactoryTests.test_responseFromMessageRecursionAvailablec C �6 t �� }t�� }d|_|j|d�}| �|j|j� dS )z� L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{timeReceived} attribute has the same value as that found on the request. i� r� N)r rJ r r� r� r� rB r� r r r �$test_responseFromMessageTimeReceived � z:DNSServerFactoryTests.test_responseFromMessageTimeReceivedc C r )z� L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{maxSize} attribute has the same value as that found on the request. r r� N)r rJ r r� �maxSizer� rB r� r r r � test_responseFromMessageMaxSize r z5DNSServerFactoryTests.test_responseFromMessageMaxSizec C s | � tjtjj� dS )z{ L{server.DNSServerFactory} has a C{_messageFactory} attribute which is L{dns.Message} by default. N)ry r r� r rJ �_messageFactoryrM r r r �test_messageFactory' � z)DNSServerFactoryTests.test_messageFactoryc C sd t �� }| �tdt� t�� }| jt|j|tj d�}| � dt |j |tj |j dd�f|j|jf� dS )a4 L{server.DNSServerFactory._responseFromMessage} calls C{dns._responseFromMessage} to generate a response message from the request message. It supplies the request message and other keyword arguments which should be passed to the response message initialiser. r� �r r� r F)�responseConstructorr r� r� �authN)r rJ r� r r r� r� r r� r� rB r� r ro r r r� r r r �+test_responseFromMessageCallsMessageFactory. s$ ��� �zADNSServerFactoryTests.test_responseFromMessageCallsMessageFactoryc C sX t �� }|jt�� tjdd�gd�}|jt�� tjdd�gd�}| �d|j|jf� dS )z� L{server.DNSServerFactory._responseFromMessage} marks the response message as authoritative if any of the answer records are authoritative. T)r )r r� Fr N)r rJ r� r r� �RRHeaderrB r r r r r �,test_responseFromMessageAuthoritativeMessageK s �� �zBDNSServerFactoryTests.test_responseFromMessageAuthoritativeMessagec C sR t dd�}t�� g}t�� g}t�� g}t| dg|j|||ft� t�� dd� dS )z� L{server.DNSServerFactory.gotResolverResponse} logs the total number of records in the response if C{verbose > 0}. r� rt zLookup found 3 recordsNr� )r r r rG r� r4 r� )r r� r� r� r� r r r � test_gotResolverResponseLogging\ s �z5DNSServerFactoryTests.test_gotResolverResponseLoggingc C s� t t� gd�}t�� }|�d� t�� g}g }g }| jtj|j|||ft � |dd�}|j \\}\}} } } | � |j j d� | � ||� | � | |� | � | |� dS )z� L{server.DNSServerFactory.gotResolverResponse} caches the response if at least one cache was provided in the constructor. r[ s example.comNr� )r r8 r r� r� r r� r9 r� r4 r rB r� ry ) r r� r< �expectedAnswers�expectedAuthority�expectedAdditionalr� r7 r� r� r� r r r r � test_gotResolverResponseCachingp s& � z5DNSServerFactoryTests.test_gotResolverResponseCachingc C sb t � }t|_t�� }d|_| jt|jt � t � � �d|dd�}| � dt|tjd�f|j|jf� dS )z� L{server.DNSServerFactory.gotResolverError} calls L{server.DNSServerFactory._responseFromMessage} to generate a response. r� Nr� r r )r r r� r r� r� r� r r� r r� r � DomainErrorrB r� �ENAMEr r r� r r r �-test_gotResolverErrorCallsResponseFromMessage� s ��zCDNSServerFactoryTests.test_gotResolverErrorCallsResponseFromMessagec C sL t �� }| jtj|jt�|�t� t� � dd�}|j \\}}| � |j |� dS )a{ L{server.DNSServerFactory.gotResolver} accepts a L{failure.Failure} and triggers a response message whose rCode corresponds to the DNS error contained in the C{Failure}. @param responseError: The L{Exception} instance which is expected to trigger C{expectedMessageCode} when it is supplied to C{gotResolverError} @type responseError: L{Exception} @param expectedMessageCode: The C{rCode} which is expected in the message returned by C{gotResolverError} in response to C{responseError}. @type expectedMessageCode: L{int} Nr� ) r rJ r� r. r/ r� r r� r r� r rB r� )r � responseError�expectedMessageCoder� r� r r r r r �_assertMessageRcodeForError� s � z1DNSServerFactoryTests._assertMessageRcodeForErrorc C � | � t�� tj� dS )z� L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ENAME} if supplied with a L{error.DomainError}. N)r r r r r rM r r r � test_gotResolverErrorDomainError� r z6DNSServerFactoryTests.test_gotResolverErrorDomainErrorc C r )z� L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ENAME} if supplied with a L{error.AuthoritativeDomainError}. N)r r �AuthoritativeDomainErrorr r rM r r r �-test_gotResolverErrorAuthoritativeDomainError� s zCDNSServerFactoryTests.test_gotResolverErrorAuthoritativeDomainErrorc C s. | � t� tj� | �t�}| �t|�d� dS )z� L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ESERVER} if supplied with another type of error and logs the error. r� N)r �KeyErrorr �ESERVER�flushLoggedErrorsrB �len)r r� r r r � test_gotResolverErrorOtherError� s z5DNSServerFactoryTests.test_gotResolverErrorOtherErrorc C s8 t dd�}t| dg|jt�t�� �t� t� � dd� dS )zZ L{server.DNSServerFactory.gotResolver} logs a message if C{verbose > 0}. r� rt z Lookup failedNr� ) r rG r� r r� r r r4 r r� r� r r r � test_gotResolverErrorLogging� s �z2DNSServerFactoryTests.test_gotResolverErrorLoggingc s� t �� }g � � fdd�|_tjddd�}t� t� g|_t� t� g|_t� t� g|_|j t � t � � �d|dd� | �tjddd�g� � dS ) z� L{server.DNSServerFactory.gotResolverError} does not allow request attributes to leak into the response ie it sends a response with AD, CD set to 0 and empty response record sections. c � � � |�S r r� �r r� r! �� responsesr r r� � � �zUDNSServerFactoryTests.test_gotResolverErrorResetsResponseAttributes.<locals>.<lambda>T�� authenticData�checkingDisabledNr� � �r� r� )r rJ r# r r� rV r� r� r� r� r r� r r rB �r r| r� r r* r �-test_gotResolverErrorResetsResponseAttributes� s � zCDNSServerFactoryTests.test_gotResolverErrorResetsResponseAttributesc s� t �� }g � � fdd�|_tjddd�}t� t� g|_t� t� g|_t� t� g|_|j g g g fd|dd� | � tjddd�g� � dS ) a L{server.DNSServerFactory.gotResolverResponse} does not allow request attributes to leak into the response ie it sends a response with AD, CD set to 0 and none of the records in the request answer sections are copied to the response. c r( r r� r) r* r r r� r, zXDNSServerFactoryTests.test_gotResolverResponseResetsResponseAttributes.<locals>.<lambda>Tr- Nr� r r1 ) r rJ r# r r� rV r� r� r� r� rB r2 r r* r �0test_gotResolverResponseResetsResponseAttributes s � zFDNSServerFactoryTests.test_gotResolverResponseResetsResponseAttributesc C sZ t �� }t� }t�� }| jtj|jt� ||d�}|j \}}| � |||f� | � |i � dS )z� If L{server.DNSServerFactory.sendReply} is supplied with a protocol *and* an address tuple it will supply that address to C{protocol.writeMessage}. r� N) r r� rV r rJ r� r. r/ r# r rB )r r< r� r� r� r r r r r �test_sendReplyWithAddress s � z/DNSServerFactoryTests.test_sendReplyWithAddressc C sR t �� }t�� }| jtj|jt� |dd�}|j\}}| � ||f� | � |i � dS )z� If L{server.DNSServerFactory.sendReply} is supplied with a protocol but no address tuple it will supply only a message to C{protocol.writeMessage}. Nr� ) r r� r rJ r� r. r/ r# r rB )r r< r� r� r r r r r � test_sendReplyWithoutAddress+ s � z2DNSServerFactoryTests.test_sendReplyWithoutAddressc C sN | � tjddd� � t�� }d|_tjdd�}t| ddg|jt � |d d � d S ) z� If L{server.DNSServerFactory.sendReply} logs a "no answers" message if the supplied message has no answers. r� c S r �Ni�Q r r r r r r� C r$ zFDNSServerFactoryTests.test_sendReplyLoggingNoAnswers.<locals>.<lambda>�Q r� rt zReplying with no answers� Processed query in 1.000 secondsNr� ) r� r r� r r� r� rJ rG r# r4 r� r r r � test_sendReplyLoggingNoAnswers> s �z4DNSServerFactoryTests.test_sendReplyLoggingNoAnswersc C s� | � tjddd� � t�� }|j�tjt�d�d�� |j �tjt�d�d�� |j �tjt�d�d�� d|_ tj dd�}t | g d �|jt� |d d � d S ) z� If L{server.DNSServerFactory.sendReply} logs a message for answers, authority, additional if the supplied a message has records in any of those sections. r� c S r r7 r r r r r r� V r$ zHDNSServerFactoryTests.test_sendReplyLoggingWithAnswers.<locals>.<lambda>z 127.0.0.1)�payloadr8 r� rt )z*Answers are <A address=127.0.0.1 ttl=None>z+Authority is <A address=127.0.0.1 ttl=None>z,Additional is <A address=127.0.0.1 ttl=None>r9 Nr� )r� r r� r r� r� r? r �Record_Ar� r� r� rJ rG r# r4 r� r r r � test_sendReplyLoggingWithAnswersP s �z6DNSServerFactoryTests.test_sendReplyLoggingWithAnswersc C �F t �� }| jtj|jt�� t� dd�}|j\\}}| � |j tj � dS )z� L{server.DNSServerFactory.handleInverseQuery} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. Nr� ) r rJ r� r. r/ r� r r� r rB r� �ENOTIMP�r r� r� r r r r r �test_handleInverseQueryk � � z-DNSServerFactoryTests.test_handleInverseQueryc C �, t dd�}t| dg|jt�� t� dd� dS )zz L{server.DNSServerFactory.handleInverseQuery} logs the message origin address if C{verbose > 0}. r� rt z Inverse query from ('::1', 53)�z::1r� r� N)r rG r� r r� r4 r� r r r � test_handleInverseQueryLogging| � �z4DNSServerFactoryTests.test_handleInverseQueryLoggingc C r> )z� L{server.DNSServerFactory.handleStatus} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. Nr� ) r rJ r� r. r/ r� r r� r rB r� r? r@ r r r �test_handleStatus� rB z'DNSServerFactoryTests.test_handleStatusc C rC )zt L{server.DNSServerFactory.handleStatus} logs the message origin address if C{verbose > 0}. r� rt z Status request from ('::1', 53)rD r� N)r rG r� r r� r4 r� r r r �test_handleStatusLogging� rF z.DNSServerFactoryTests.test_handleStatusLoggingc C r> )z� L{server.DNSServerFactory.handleNotify} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. Nr� ) r rJ r� r. r/ r� r r� r rB r� r? r@ r r r �test_handleNotify� rB z'DNSServerFactoryTests.test_handleNotifyc C rC )zt L{server.DNSServerFactory.handleNotify} logs the message origin address if C{verbose > 0}. r� rt z Notify message from ('::1', 53)rD r� N)r rG r� r r� r4 r� r r r �test_handleNotifyLogging� rF z.DNSServerFactoryTests.test_handleNotifyLoggingc C r> )z� L{server.DNSServerFactory.handleOther} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. Nr� ) r rJ r� r. r/ r� r r� r rB r� r? r@ r r r �test_handleOther� rB z&DNSServerFactoryTests.test_handleOtherc C rC )zs L{server.DNSServerFactory.handleOther} logs the message origin address if C{verbose > 0}. r� rt z$Unknown op code (0) from ('::1', 53)rD r� N)r rG r� r r� r4 r� r r r �test_handleOtherLogging� rF z-DNSServerFactoryTests.test_handleOtherLoggingN)Dr r r r rN rR rY r] r` rg rk rm rp rq rs rv rw r{ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r r r! r& r' r3 r4 r5 r6 r: r= rA rE rG rH rI rJ rK rL r r r r rH � s� ('! rH N) r �zope.interface.verifyr �twisted.internetr �twisted.internet.interfacesr � twisted.namesr r r r �twisted.pythonr r � twisted.trialr r- r r rJ r r& r. r4 r5 r8 rG �TestCaserH r r r r �<module> s" ! PK y�Z��h.5 5 , test/__pycache__/test_common.cpython-310.pycnu �[��� o �b � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZm Z m Z m Z m Z m Z ddlmZmZmZmZmZmZ ddlmZ ddlmZ G d d � d e�ZG d d � d e�Zd S )z$ Tests for L{twisted.names.common}. � )� verifyClass)� IResolver)� ResolverBase)�EFORMAT�ENAME�ENOTIMP�EREFUSED�ESERVER�Query)�DNSFormatError� DNSNameError�DNSNotImplementedError�DNSQueryRefusedError�DNSServerError�DNSUnknownError)�Failure)�SynchronousTestCasec @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�ExceptionForCodeTestsz5 Tests for L{ResolverBase.exceptionForCode}. c C s t � j| _d S �N)r �exceptionForCode��self� r �@/usr/lib/python3/dist-packages/twisted/names/test/test_common.py�setUp s zExceptionForCodeTests.setUpc C � | � | �t�t� dS )zd L{ResolverBase.exceptionForCode} converts L{EFORMAT} to L{DNSFormatError}. N)�assertIsr r r r r r r � test_eformat" � z"ExceptionForCodeTests.test_eformatc C r )zd L{ResolverBase.exceptionForCode} converts L{ESERVER} to L{DNSServerError}. N)r r r r r r r r � test_eserver) r z"ExceptionForCodeTests.test_eserverc C r )zX L{ResolverBase.exceptionForCode} converts L{ENAME} to L{DNSNameError}. N)r r r r r r r r � test_ename0 s z ExceptionForCodeTests.test_enamec C r )zl L{ResolverBase.exceptionForCode} converts L{ENOTIMP} to L{DNSNotImplementedError}. N)r r r r r r r r � test_enotimp6 r z"ExceptionForCodeTests.test_enotimpc C r )zk L{ResolverBase.exceptionForCode} converts L{EREFUSED} to L{DNSQueryRefusedError}. N)r r r r r r r r � test_erefused= r z#ExceptionForCodeTests.test_erefusedc C s | � | �t� �t� dS )zr L{ResolverBase.exceptionForCode} converts any other response code to L{DNSUnknownError}. N)r r �objectr r r r r � test_otherD s z ExceptionForCodeTests.test_otherN) �__name__� __module__� __qualname__�__doc__r r r r r! r" r$ r r r r r s r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � QueryTestsz* Tests for L{ResolverBase.query}. c C s t tt� dS )zF L{ResolverBase} provides the L{IResolver} interface. N)r r r r r r r �"test_resolverBaseProvidesIResolverQ s z-QueryTests.test_resolverBaseProvidesIResolverc sF g � t � }d� fdd�i|_tddd�}|�|d� | �dg� � dS ) z� L{ResolverBase.query} looks up a method to invoke using the type of the query passed to it and the C{typeToMethod} mapping on itself. �90 c s � � | |f�S r )�append��query�timeout��resultsr r �<lambda>_ s z6QueryTests.test_typeToMethodDispatch.<locals>.<lambda>� example.com��name�type�{ )r3 r7 N)r � typeToMethodr r. � assertEqual)r �resolverr. r r0 r �test_typeToMethodDispatchW s � z$QueryTests.test_typeToMethodDispatchc sZ t � � t� }d� fdd�i|_tddd�}|�|d�}g }|�|j� | �� |d � dS ) z� L{ResolverBase.query} returns a L{Deferred} which fires with the result of the method found in the C{typeToMethod} mapping for the type of the query passed to it. i1� c s � S r r r- ��expectedr r r2 m s z4QueryTests.test_typeToMethodResult.<locals>.<lambda>r3 r4 r7 r N)r# r r8 r r. �addBothr, r9 �r r: r. � queryDeferred�resultr r< r �test_typeToMethodResulte s z"QueryTests.test_typeToMethodResultc C sV t � }i |_tddd�}|�|d�}g }|�|j� | �|d t� |d �t � dS )z� L{ResolverBase.query} returns a L{Deferred} which fails with L{NotImplementedError} when called with a query of a type not present in its C{typeToMethod} dictionary. r3 r+ r4 r7 r N) r r8 r r. r> r, �assertIsInstancer �trap�NotImplementedErrorr? r r r �test_unknownQueryTypet s z QueryTests.test_unknownQueryTypeN)r% r& r' r( r* r; rB rF r r r r r) L s r) N)r( �zope.interface.verifyr �twisted.internet.interfacesr �twisted.names.commonr �twisted.names.dnsr r r r r r �twisted.names.errorr r r r r r �twisted.python.failurer �twisted.trial.unittestr r r) r r r r �<module> s 2PK y�Z����P% P% 0 test/__pycache__/test_srvconnect.cpython-310.pycnu �[��� o �b�$ � @ s� d Z ddlZddlmZ ddlmZmZ ddlmZm Z ddl m Z ddl m Z mZmZ ddlmZ dd lmZ dd lmZ dd lmZ G d d � d e�ZG dd� dej�ZG dd� dej�Z dS )z- Test cases for L{twisted.names.srvconnect}. � N)� verifyObject)�defer�protocol)�DNSLookupError�ServiceNameUnknownError)� IConnector)�client�dns� srvconnect)� ResolverBase)� DNSNameError)� MemoryReactor)�unittestc @ s" e Zd ZdZddd�Zdd� ZdS )� FakeResolvera� Resolver that only gives out one given result. Either L{results} or L{failure} must be set and will be used for the return value of L{_lookup} @ivar results: List of L{dns.RRHeader} for the desired result. @type results: C{list} @ivar failure: Failure with an exception from L{twisted.names.error}. @type failure: L{Failure<twisted.python.failure.Failure>} Nc C s || _ || _g | _d S �N)�results�failure�lookups)�selfr r � r �D/usr/lib/python3/dist-packages/twisted/names/test/test_srvconnect.py�__init__$ s zFakeResolver.__init__c C s< | j �||||f� | jdurt�| jg g f�S t�| j�S )z9 Return the result or failure on lookup. N)r �appendr r �succeed�failr )r �name�cls�qtype�timeoutr r r �_lookup) s zFakeResolver._lookup)NN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r c @ s e Zd ZdZdd� Zdd� ZdS )� DummyFactoryzL Dummy client factory that stores the reason of connection failure. c C s d | _ d S r ��reason�r r r r r 9 � zDummyFactory.__init__c C s || _ d S r r% )r � connectorr& r r r �clientConnectionFailed< r( z#DummyFactory.clientConnectionFailedN)r r! r" r# r r* r r r r r$ 4 s r$ c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd S )!�SRVConnectorTestsz/ Tests for L{srvconnect.SRVConnector}. c C sF | � tdt� � t� | _t� | _t�| jdd| j�| _ g | _ g | _ d S )N� theResolver� xmpp-server� example.org) �patchr r r �reactorr$ �factoryr � SRVConnectorr) � randIntArgs�randIntResultsr' r r r �setUpE s � zSRVConnectorTests.setUpc C s | j �||f� | j�d�S )a� Fake randint. Returns the first element of L{randIntResults} and records the arguments passed to it in L{randIntArgs}. @param min: Lower bound of the random number. @type min: L{int} @param max: Higher bound of the random number. @type max: L{int} @return: Fake random number from L{randIntResults}. @rtype: L{int} r )r3 r r4 �pop)r �min�maxr r r �_randintO s zSRVConnectorTests._randintc C s t t| j� dS )zF L{srvconnect.SRVConnector} implements L{IConnector}. N)r r r) r' r r r �test_interfaceb s z SRVConnectorTests.test_interfacec C sf t jdddd�}t jdt jt jd|d�gtj_| j� � | � | j j � | � | jj�� dd� d � dS ) zS Test connectTCP gets called with the address from the SRV record. �} �host.example.org�< ��port�target�ttlr. �r �typer rA �payloadN� )r< r; )r � Record_SRV�RRHeader�SRV�INr r, r r) �connect� assertIsNoner1 r& � assertEqualr0 � tcpClientsr6 �r rD r r r �test_SRVPresenth s �� z!SRVConnectorTests.test_SRVPresentc C sD t d�tj_| j�� | �| jj� | � | j j � � dd� d� dS )zS Test connectTCP gets called with fallback parameters on NXDOMAIN. s example.orgNrE �r. r- ) r r r, r r) rJ rK r1 r& rL r0 rM r6 r' r r r �test_SRVNotPresentw s �z$SRVConnectorTests.test_SRVNotPresentc C s@ g t j_| j�� | �| jj� | �| j j � � dd� d� dS )zW Test connectTCP gets called with fallback parameters on empty result. NrE rP ) r r, r r) rJ rK r1 r& rL r0 rM r6 r' r r r �test_SRVNoResult� s �z"SRVConnectorTests.test_SRVNoResultc C s\ t j| jdd| jdd�| _t� tj_| j� � | � | jj � | � | jj �� dd� d� dS )zY connectTCP gets called with default port if the service is not defined. �thisbetternotexistr. �f )� defaultPortNrE )r. rT )r r2 r0 r1 r) r r r, r rJ rK r& rL rM r6 r' r r r �)test_SRVNoResultUnknownServiceDefaultPort� s � z;SRVConnectorTests.test_SRVNoResultUnknownServiceDefaultPortc C sB t �| jdd| j�| _t� tj_| j� � | � | jj � t�� dS )zR Connect fails on no result, unknown service and no default port. rS r. N) r r2 r0 r1 r) r r r, r rJ � assertTruer& �checkr' r r r �+test_SRVNoResultUnknownServiceNoDefaultPort� s � z=SRVConnectorTests.test_SRVNoResultUnknownServiceNoDefaultPortc C sV t jdt jt jddd�gtj_| j�� | � | j j � | � | j j�� dd� d� dS )zU Test connectTCP gets called with fallback parameters on bad result. r. r= NrB rE rP )r rG �CNAMErI r r, r r) rJ rK r1 r& rL r0 rM r6 r' r r r �test_SRVBadResult� s �� �z#SRVConnectorTests.test_SRVBadResultc C sh t jdddd�}t jdt jt jd|d�gtj_| j� � | � | j j � | j j � t� | �| jjg � dS )zH Test that connecting fails when no service is present. i� � .r= r> r. rB N)r rF rG rH rI r r, r r) rJ �assertIsNotNoner1 r& �trapr rL r0 rM rN r r r �test_SRVNoService� s �� z#SRVConnectorTests.test_SRVNoServicec C s2 g t j_| j�� t jjd d }| �d|� dS )zW The lookup name is a native string from service, protocol and domain. ���r s _xmpp-server._tcp.example.orgN)r r, r r) rJ r rL )r r r r r �test_SRVLookupName� s z$SRVConnectorTests.test_SRVLookupNamec C s* t �| jdd| j�| _| �d| jj� dS )zq L{srvconnect.SRVConnector} automatically encodes unicode domain using C{idna} encoding. z xmpp-clientu échec.example.orgs xn--chec-9oa.example.orgN)r r2 r0 r1 r) rL �domainr' r r r �test_unicodeDomain� s �z$SRVConnectorTests.test_unicodeDomainc C s� t �dddd�}t �dddd�}||g| j_g | j_| �td| j� ddg| _| j� � | � | j d d � | j� � | � | j d d � ddg| _| j� � | � | j d d � | j� � | � | j d d� dS )a pickServer calculates running sum of weights and calls randint. This exercises the server selection algorithm specified in RFC 2782 by preparing fake L{random.randint} results and checking the values it was called with. � rT �host1.example.org� �host2.example.org�randint� r )r � � )r rd rE � )r rf N) r rF r) �orderedServers�serversr/ �randomr9 r4 � pickServerrL r3 �r �record1�record2r r r �test_pickServerWeights� s z(SRVConnectorTests.test_pickServerWeightsc C sv t �dddd�}t �dddd�}||g| j_g | j_| �td| j� ddg| _| � d| j� � � | � d | j� � � d S ) zR Two records with equal priorities compare on weight (ascending). rd rT re rf rg rh r �re rT �rg rT N� r rF r) rm rn r/ ro r9 r4 rL rp rq r r r � test_pickServerSamePriorities � z/SRVConnectorTests.test_pickServerSamePrioritiesc C sv t �dddd�}t �dddd�}||g| j_g | j_| �td| j� ddg| _| � d| j� � � | � d | j� � � d S ) zX Two records with differing priorities compare on priority (ascending). rd r rT re rf rg rh ru rv Nrw rq r r r �test_srvDifferentPriorities ry z-SRVConnectorTests.test_srvDifferentPrioritiesN)r r! r" r# r5 r9 r: rO rQ rR rV rY r[ r_ ra rc rt rx rz r r r r r+ @ s" ! r+ ) r# ro �zope.interface.verifyr �twisted.internetr r �twisted.internet.errorr r �twisted.internet.interfacesr � twisted.namesr r r �twisted.names.commonr �twisted.names.errorr �twisted.test.proto_helpersr � twisted.trialr r � ClientFactoryr$ �TestCaser+ r r r r �<module> s PK y�Z<�d( ( + test/__pycache__/test_hosts.cpython-310.pycnu �[��� o �b�& � @ s� d Z ddlmZ ddlmZmZmZmZmZm Z m Z m Z ddl m Z mZmZ ddlmZ ddlmZ G dd� d�ZG d d � d ee�ZG d d � d ee�ZG d d� dee�ZdS )zC Tests for the I{hosts(5)}-based resolver, L{twisted.names.hosts}. � )� gatherResults)�AAAA�IN�A� DomainError�Query�Record_A� Record_AAAA�RRHeader)�Resolver� searchFileFor�searchFileForAll)�FilePath)�SynchronousTestCasec @ s e Zd Zdd� ZdS )�GoodTempPathMixinc C s t | �� �d��S )Nzutf-8)r �mktemp�encode��self� r �?/usr/lib/python3/dist-packages/twisted/names/test/test_hosts.py�path s zGoodTempPathMixin.pathN)�__name__� __module__� __qualname__r r r r r r s r c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �SearchHostsFileTestsz� Tests for L{searchFileFor}, a helper which finds the first address for a particular hostname in a I{hosts(5)}-style file. c C �* | � � }|�d� | �dt|j d�� dS )zr If there is an IPv4 address for the hostname passed to L{searchFileFor}, it is returned. � 10.2.3.4 foo.example.com z10.2.3.4� foo.example.comN�r � setContent� assertEqualr �r �hostsr r r �test_findAddress$ s z%SearchHostsFileTests.test_findAddressc C s( | � � }|�d� | �t|j d�� dS )z~ If there is no address information for the hostname passed to L{searchFileFor}, L{None} is returned. r s bar.example.comN)r r! � assertIsNoner r# r r r �test_notFoundAddress- s z)SearchHostsFileTests.test_notFoundAddressc C r )zS The first address associated with the given hostname is returned. sV ::1 foo.example.com 10.1.2.3 foo.example.com fe80::21b:fcff:feee:5a1d foo.example.com �::1r Nr r# r r r �test_firstAddress6 s �z&SearchHostsFileTests.test_firstAddressc C sz | � � }|�d� | �t|j d�d� | �t|j d�d� | �t|j d�d� | �t|j d�d� | �t|j d�d� d S ) z� For a host with a canonical name and one or more aliases, L{searchFileFor} can find an address given any of the names. sY 127.0.1.1 helmut.example.org helmut # a comment ::1 localhost ip6-localhost ip6-loopback s helmutz 127.0.1.1s helmut.example.orgs ip6-localhostr( s ip6-loopbacks localhostNr r# r r r �test_searchFileForAliasesB s �z.SearchHostsFileTests.test_searchFileForAliasesN)r r r �__doc__r% r' r) r* r r r r r s r c @ r ) �SearchHostsFileForAllTestsz� Tests for L{searchFileForAll}, a helper which finds all addresses for a particular hostname in a I{hosts(5)}-style file. c C s, | � � }|�d� | �g d�t|d�� dS )zt L{searchFileForAll} returns a list of all addresses associated with the name passed to it. sc 127.0.0.1 foobar.example.com 127.0.0.2 foobar.example.com ::1 foobar.example.com )� 127.0.0.1z 127.0.0.2r( s foobar.example.comN�r r! r" r r# r r r �test_allAddressesZ s ��z,SearchHostsFileForAllTests.test_allAddressesc C s* | � � }|�d� | �dgt|d�� dS )zL L{searchFileForAll} searches for names case-insensitively. s! 127.0.0.1 foobar.EXAMPLE.com r- s FOOBAR.example.comNr. r# r r r �test_caseInsensitivelyj s z1SearchHostsFileForAllTests.test_caseInsensitivelyc C s | � g t| �� d�� dS )z� If there is an error reading the contents of the hosts file, L{searchFileForAll} returns an empty list. s example.comN)r" r r r r r r �test_readErrorr s z)SearchHostsFileForAllTests.test_readErrorc C s, | � � }|�d� | �ddgt|d�� dS )zw L{searchFileForAll} ignores any malformed IP addresses associated with the name passed to it. s[ 127.0.0.1 miser.example.org miser not-an-ip miser �not-ascii miser # miser miser ::1 miserr- r( s miserNr. r# r r r �test_malformedIPy s ��z+SearchHostsFileForAllTests.test_malformedIPN)r r r r+ r/ r0 r1 r2 r r r r r, T s r, c @ sx e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd S ) � HostsTestszJ Tests for the I{hosts(5)}-based L{twisted.names.hosts.Resolver}. c C s, | � � }|�d� d| _t|j | j�| _d S )Ns 1.1.1.1 EXAMPLE EXAMPLE.EXAMPLETHING ::2 mixed 1.1.1.2 MIXED ::1 ip6thingy 1.1.1.3 multiple 1.1.1.4 multiple ::3 ip6-multiple ::4 ip6-multiple not-an-ip malformed malformed # malformed 1.1.1.5 malformed ::5 malformed ih )r r! �ttlr �resolver)r �fr r r �setUp� s �zHostsTests.setUpc C s t � }| �d|j� dS )z� The default hosts file used by L{Resolver} is I{/etc/hosts} if no value is given for the C{file} initializer parameter. s /etc/hostsN)r r" �file)r r5 r r r �test_defaultPath� s zHostsTests.test_defaultPathc s, g d�}� fdd�|D �}� � t|�� dS )z� L{hosts.Resolver.getHostByName} returns a L{Deferred} which fires with a string giving the address of the queried name as found in the resolver's hosts file. ))� EXAMPLE�1.1.1.1)s EXAMPLE.EXAMPLETHINGr; )s MIXED�1.1.1.2c s& g | ]\}}� j �|��� j|��qS r )r5 � getHostByName� addCallbackr" )�.0�n�ipr r r � <listcomp>� s ��z1HostsTests.test_getHostByName.<locals>.<listcomp>N)�successResultOfr )r �data�dsr r r �test_getHostByName� s �z HostsTests.test_getHostByNamec C �\ | j �d�}| �|�\}}}| �tdtt| jtd| j��tdtt| jtd| j��f|� dS )z L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with A records from the hosts file. s multiplez1.1.1.3z1.1.1.4N� r5 � lookupAddressrC r" r r r r4 r �r �d�answers� authority� additionalr r r �test_lookupAddress� s ��z HostsTests.test_lookupAddressc C rG )z� L{hosts.Resolver.lookupIPV6Address} returns a L{Deferred} which fires with AAAA records from the hosts file. s ip6-multiplez::3z::4N� r5 �lookupIPV6AddressrC r" r r r r4 r rJ r r r �test_lookupIPV6Address� s ����z!HostsTests.test_lookupIPV6Addressc C sD | j �d�}| �|�\}}}| �tdtt| jtd| j��f|� dS )z� L{hosts.Resolver.lookupAllRecords} returns a L{Deferred} which fires with A records from the hosts file. s mixedr< N) r5 �lookupAllRecordsrC r" r r r r4 r rJ r r r �test_lookupAllRecords� s �z HostsTests.test_lookupAllRecordsc C � | � | j�d�t� dS )z| L{hosts.Resolver} fails with L{NotImplementedError} for L{IResolver} methods it doesn't implement. r: N)�failureResultOfr5 �lookupMailExchange�NotImplementedErrorr r r r �test_notImplemented� s �z HostsTests.test_notImplementedc C s8 | j �td��}| �|�\\}}}| �|j�� d� d S )Nr: r; )r5 �queryr rC r" �payload� dottedQuad�r rK �answerrM rN r r r � test_query� s zHostsTests.test_queryc C rU )z� L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with L{dns.DomainError} if the name passed in has no addresses in the hosts file. � foueoaN)rV r5 rI r r r r r �test_lookupAddressNotFound� s z%HostsTests.test_lookupAddressNotFoundc C rU )zj Like L{test_lookupAddressNotFound}, but for L{hosts.Resolver.lookupIPV6Address}. r` N)rV r5 rQ r r r r r � test_lookupIPV6AddressNotFound � z)HostsTests.test_lookupIPV6AddressNotFoundc C rU )zi Like L{test_lookupAddressNotFound}, but for L{hosts.Resolver.lookupAllRecords}. r` N)rV r5 rS r r r r r � test_lookupAllRecordsNotFound rc z(HostsTests.test_lookupAllRecordsNotFoundc C �D | j �d�}| �|�\\}}}| �tdtt| jtd| j��|� dS )z� L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with the valid addresses from the hosts file, ignoring any entries that aren't valid IP addresses. � malformedz1.1.1.5NrH r] r r r �test_lookupMalformed s �z HostsTests.test_lookupMalformedc C re )zk Like L{test_lookupAddressMalformed}, but for L{hosts.Resolver.lookupIPV6Address}. rf z::5NrP r] r r r �test_lookupIPV6Malformed s �z#HostsTests.test_lookupIPV6MalformedN)r r r r+ r7 r9 rF rO rR rT rY r_ ra rb rd rg rh r r r r r3 � s r3 N)r+ �twisted.internet.deferr �twisted.names.dnsr r r r r r r r �twisted.names.hostsr r r �twisted.python.filepathr �twisted.trial.unittestr r r r, r3 r r r r �<module> s ( 69PK y�Z ��% + test/__pycache__/test_cache.cpython-310.pycnu �[��� o �b� � @ sZ d Z ddlZddlmZ ddlmZmZ ddlmZm Z ddl m Z G dd� de j �Z dS ) z# Tests for L{twisted.names.cache}. � N)� verifyClass)� interfaces�task)�cache�dns)�unittestc @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� CachingTestsz+ Tests for L{cache.CacheResolver}. c C s t tjtj� dS )zK L{cache.CacheResolver} implements L{interfaces.IResolver} N)r r � IResolverr � CacheResolver��self� r �?/usr/lib/python3/dist-packages/twisted/names/test/test_cache.py�test_interface s zCachingTests.test_interfacec C sF t �tjdtjtjd�t�� g g g ffi�}|�d��| j g g g f�S )N� example.com��name�type�cls) r r r �Query�MX�IN�time�lookupMailExchange� addCallback� assertEqual)r �cr r r � test_lookup s ��� �zCachingTests.test_lookupc C s� t �dt jt jdt �dd��gt �dt jt jdt �dd��gt �dt jt jdt �dd��gf}t�� }t jdt jt jd�}tj ||� � |fi|d�}|� d� | � ||j� | � |�d�t j�S )z� Cache entries passed into L{cache.CacheResolver.__init__} get cancelled just like entries added with cacheResult r �< � 127.0.0.1�2 �( r ��reactor)r �RRHeader�Ar �Record_Ar �Clockr r r �seconds�advance� assertNotIn� assertFailure� lookupAddress� DomainError)r �r�clock�queryr r r r �test_constructorExpires* s& ������� z$CachingTests.test_constructorExpiresc s� t �dt jt jdt �dd��gt �dt jt jdt �dd��gt �dt jt jdt �dd��gf}t�� }tj|d�}|� t j dt jt jd�|� |� d� � fd d �}|� d�� |�S ) z� When a cache lookup finds a cached entry from 1 second ago, it is returned with a TTL of original TTL minus the elapsed 1 second. r r r r r! r" r � c s^ � � | d d jd� � � | d d jd� � � | d d jd� � � | d d jjd� d S )Nr �; r2 �1 � �' r )r �ttlr )�resultr r r �cbLookupl s z0CachingTests.test_normalLookup.<locals>.cbLookup)r r$ r% r r& r r' r r � cacheResultr r) r, r )r r. r/ r r9 r r r �test_normalLookupN s& ������� z CachingTests.test_normalLookupc C s� t �dt jt jdt �dd��gt �dt jt jdt �dd��gt �dt jt jdt �dd��gf}t�� }tj|d�}t j dt jt jd�}|� ||� |� d� | � ||j� | � |�d�t j�S )zW Once the TTL has been exceeded, the result is removed from the cache. r r r r r! r" r )r r$ r% r r& r r' r r r r: r) r* r+ r, r- )r r. r/ r r0 r r r �test_cachedResultExpirest s( ������� z%CachingTests.test_cachedResultExpiresc C s� t �dt jt jdt �dd��gt �dt jt jdt �dd��gt �dt jt jdt �dd��gf}t�� }dd� |_tj t j dt jt jd�|� � |fi|d �}|� d � | � |�d�t j�S ) z� When the cache is queried exactly as the cached entry should expire but before it has actually been cleared, the cache does not return the expired entry. r r r r r! c _ s d S )Nr )�args�kwargsr r r �<lambda>� s z4CachingTests.test_expiredTTLLookup.<locals>.<lambda>r r" g����� N@)r r$ r% r r& r r' � callLaterr r r r( r) r+ r, r- )r r. r/ r r r r �test_expiredTTLLookup� s2 ������� ��� z"CachingTests.test_expiredTTLLookupN) �__name__� __module__� __qualname__�__doc__r r r1 r; r< rA r r r r r s $& "r )rE r �zope.interface.verifyr �twisted.internetr r � twisted.namesr r � twisted.trialr �TestCaser r r r r �<module> s PK y�Z�����& �& test/test_hosts.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for the I{hosts(5)}-based resolver, L{twisted.names.hosts}. """ from twisted.internet.defer import gatherResults from twisted.names.dns import ( AAAA, IN, A, DomainError, Query, Record_A, Record_AAAA, RRHeader, ) from twisted.names.hosts import Resolver, searchFileFor, searchFileForAll from twisted.python.filepath import FilePath from twisted.trial.unittest import SynchronousTestCase class GoodTempPathMixin: def path(self): return FilePath(self.mktemp().encode("utf-8")) class SearchHostsFileTests(SynchronousTestCase, GoodTempPathMixin): """ Tests for L{searchFileFor}, a helper which finds the first address for a particular hostname in a I{hosts(5)}-style file. """ def test_findAddress(self): """ If there is an IPv4 address for the hostname passed to L{searchFileFor}, it is returned. """ hosts = self.path() hosts.setContent(b"10.2.3.4 foo.example.com\n") self.assertEqual("10.2.3.4", searchFileFor(hosts.path, b"foo.example.com")) def test_notFoundAddress(self): """ If there is no address information for the hostname passed to L{searchFileFor}, L{None} is returned. """ hosts = self.path() hosts.setContent(b"10.2.3.4 foo.example.com\n") self.assertIsNone(searchFileFor(hosts.path, b"bar.example.com")) def test_firstAddress(self): """ The first address associated with the given hostname is returned. """ hosts = self.path() hosts.setContent( b"::1 foo.example.com\n" b"10.1.2.3 foo.example.com\n" b"fe80::21b:fcff:feee:5a1d foo.example.com\n" ) self.assertEqual("::1", searchFileFor(hosts.path, b"foo.example.com")) def test_searchFileForAliases(self): """ For a host with a canonical name and one or more aliases, L{searchFileFor} can find an address given any of the names. """ hosts = self.path() hosts.setContent( b"127.0.1.1\thelmut.example.org\thelmut\n" b"# a comment\n" b"::1 localhost ip6-localhost ip6-loopback\n" ) self.assertEqual(searchFileFor(hosts.path, b"helmut"), "127.0.1.1") self.assertEqual(searchFileFor(hosts.path, b"helmut.example.org"), "127.0.1.1") self.assertEqual(searchFileFor(hosts.path, b"ip6-localhost"), "::1") self.assertEqual(searchFileFor(hosts.path, b"ip6-loopback"), "::1") self.assertEqual(searchFileFor(hosts.path, b"localhost"), "::1") class SearchHostsFileForAllTests(SynchronousTestCase, GoodTempPathMixin): """ Tests for L{searchFileForAll}, a helper which finds all addresses for a particular hostname in a I{hosts(5)}-style file. """ def test_allAddresses(self): """ L{searchFileForAll} returns a list of all addresses associated with the name passed to it. """ hosts = self.path() hosts.setContent( b"127.0.0.1 foobar.example.com\n" b"127.0.0.2 foobar.example.com\n" b"::1 foobar.example.com\n" ) self.assertEqual( ["127.0.0.1", "127.0.0.2", "::1"], searchFileForAll(hosts, b"foobar.example.com"), ) def test_caseInsensitively(self): """ L{searchFileForAll} searches for names case-insensitively. """ hosts = self.path() hosts.setContent(b"127.0.0.1 foobar.EXAMPLE.com\n") self.assertEqual(["127.0.0.1"], searchFileForAll(hosts, b"FOOBAR.example.com")) def test_readError(self): """ If there is an error reading the contents of the hosts file, L{searchFileForAll} returns an empty list. """ self.assertEqual([], searchFileForAll(self.path(), b"example.com")) def test_malformedIP(self): """ L{searchFileForAll} ignores any malformed IP addresses associated with the name passed to it. """ hosts = self.path() hosts.setContent( b"127.0.0.1\tmiser.example.org\tmiser\n" b"not-an-ip\tmiser\n" b"\xffnot-ascii\t miser\n" b"# miser\n" b"miser\n" b"::1 miser" ) self.assertEqual( ["127.0.0.1", "::1"], searchFileForAll(hosts, b"miser"), ) class HostsTests(SynchronousTestCase, GoodTempPathMixin): """ Tests for the I{hosts(5)}-based L{twisted.names.hosts.Resolver}. """ def setUp(self): f = self.path() f.setContent( b""" 1.1.1.1 EXAMPLE EXAMPLE.EXAMPLETHING ::2 mixed 1.1.1.2 MIXED ::1 ip6thingy 1.1.1.3 multiple 1.1.1.4 multiple ::3 ip6-multiple ::4 ip6-multiple not-an-ip malformed malformed # malformed 1.1.1.5 malformed ::5 malformed """ ) self.ttl = 4200 self.resolver = Resolver(f.path, self.ttl) def test_defaultPath(self): """ The default hosts file used by L{Resolver} is I{/etc/hosts} if no value is given for the C{file} initializer parameter. """ resolver = Resolver() self.assertEqual(b"/etc/hosts", resolver.file) def test_getHostByName(self): """ L{hosts.Resolver.getHostByName} returns a L{Deferred} which fires with a string giving the address of the queried name as found in the resolver's hosts file. """ data = [ (b"EXAMPLE", "1.1.1.1"), (b"EXAMPLE.EXAMPLETHING", "1.1.1.1"), (b"MIXED", "1.1.1.2"), ] ds = [ self.resolver.getHostByName(n).addCallback(self.assertEqual, ip) for n, ip in data ] self.successResultOf(gatherResults(ds)) def test_lookupAddress(self): """ L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with A records from the hosts file. """ d = self.resolver.lookupAddress(b"multiple") answers, authority, additional = self.successResultOf(d) self.assertEqual( ( RRHeader(b"multiple", A, IN, self.ttl, Record_A("1.1.1.3", self.ttl)), RRHeader(b"multiple", A, IN, self.ttl, Record_A("1.1.1.4", self.ttl)), ), answers, ) def test_lookupIPV6Address(self): """ L{hosts.Resolver.lookupIPV6Address} returns a L{Deferred} which fires with AAAA records from the hosts file. """ d = self.resolver.lookupIPV6Address(b"ip6-multiple") answers, authority, additional = self.successResultOf(d) self.assertEqual( ( RRHeader( b"ip6-multiple", AAAA, IN, self.ttl, Record_AAAA("::3", self.ttl) ), RRHeader( b"ip6-multiple", AAAA, IN, self.ttl, Record_AAAA("::4", self.ttl) ), ), answers, ) def test_lookupAllRecords(self): """ L{hosts.Resolver.lookupAllRecords} returns a L{Deferred} which fires with A records from the hosts file. """ d = self.resolver.lookupAllRecords(b"mixed") answers, authority, additional = self.successResultOf(d) self.assertEqual( (RRHeader(b"mixed", A, IN, self.ttl, Record_A("1.1.1.2", self.ttl)),), answers, ) def test_notImplemented(self): """ L{hosts.Resolver} fails with L{NotImplementedError} for L{IResolver} methods it doesn't implement. """ self.failureResultOf( self.resolver.lookupMailExchange(b"EXAMPLE"), NotImplementedError ) def test_query(self): d = self.resolver.query(Query(b"EXAMPLE")) [answer], authority, additional = self.successResultOf(d) self.assertEqual(answer.payload.dottedQuad(), "1.1.1.1") def test_lookupAddressNotFound(self): """ L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with L{dns.DomainError} if the name passed in has no addresses in the hosts file. """ self.failureResultOf(self.resolver.lookupAddress(b"foueoa"), DomainError) def test_lookupIPV6AddressNotFound(self): """ Like L{test_lookupAddressNotFound}, but for L{hosts.Resolver.lookupIPV6Address}. """ self.failureResultOf(self.resolver.lookupIPV6Address(b"foueoa"), DomainError) def test_lookupAllRecordsNotFound(self): """ Like L{test_lookupAddressNotFound}, but for L{hosts.Resolver.lookupAllRecords}. """ self.failureResultOf(self.resolver.lookupAllRecords(b"foueoa"), DomainError) def test_lookupMalformed(self): """ L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with the valid addresses from the hosts file, ignoring any entries that aren't valid IP addresses. """ d = self.resolver.lookupAddress(b"malformed") [answer], authority, additional = self.successResultOf(d) self.assertEqual( RRHeader(b"malformed", A, IN, self.ttl, Record_A("1.1.1.5", self.ttl)), answer, ) def test_lookupIPV6Malformed(self): """ Like L{test_lookupAddressMalformed}, but for L{hosts.Resolver.lookupIPV6Address}. """ d = self.resolver.lookupIPV6Address(b"malformed") [answer], authority, additional = self.successResultOf(d) self.assertEqual( RRHeader(b"malformed", AAAA, IN, self.ttl, Record_AAAA("::5", self.ttl)), answer, ) PK y�ZI�Q��s �s test/test_dns.pynu �[��� # test-case-name: twisted.names.test.test_dns # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for twisted.names.dns. """ import struct from io import BytesIO from typing import cast from zope.interface.verify import verifyClass from twisted.internet import address, task from twisted.internet.error import CannotListenError, ConnectionDone from twisted.names import dns from twisted.python.failure import Failure from twisted.python.util import FancyEqMixin, FancyStrMixin from twisted.test import proto_helpers from twisted.test.testutils import ComparisonTestsMixin from twisted.trial import unittest RECORD_TYPES = [ dns.Record_NS, dns.Record_MD, dns.Record_MF, dns.Record_CNAME, dns.Record_MB, dns.Record_MG, dns.Record_MR, dns.Record_PTR, dns.Record_DNAME, dns.Record_A, dns.Record_SOA, dns.Record_NULL, dns.Record_WKS, dns.Record_SRV, dns.Record_AFSDB, dns.Record_RP, dns.Record_HINFO, dns.Record_MINFO, dns.Record_MX, dns.Record_TXT, dns.Record_AAAA, dns.Record_A6, dns.Record_NAPTR, dns.Record_SSHFP, dns.Record_TSIG, dns.UnknownRecord, ] class DomainStringTests(unittest.SynchronousTestCase): def test_bytes(self): """ L{dns.domainString} returns L{bytes} unchanged. """ self.assertEqual( b"twistedmatrix.com", dns.domainString(b"twistedmatrix.com"), ) def test_native(self): """ L{dns.domainString} converts a native string to L{bytes} if necessary. """ self.assertEqual(b"example.com", dns.domainString("example.com")) def test_text(self): """ L{dns.domainString} always converts a unicode string to L{bytes}. """ self.assertEqual(b"foo.example", dns.domainString("foo.example")) def test_idna(self): """ L{dns.domainString} encodes Unicode using IDNA. """ self.assertEqual(b"xn--fwg.test", dns.domainString("\u203D.test")) def test_nonsense(self): """ L{dns.domainString} encodes Unicode using IDNA. """ self.assertRaises(TypeError, dns.domainString, 9000) self.assertRaises(TypeError, dns.domainString, dns.Name("bar.example")) class Ord2ByteTests(unittest.TestCase): """ Tests for L{dns._ord2bytes}. """ def test_ord2byte(self): """ L{dns._ord2byte} accepts an integer and returns a byte string of length one with an ordinal value equal to the given integer. """ self.assertEqual(b"\x10", dns._ord2bytes(0x10)) class Str2TimeTests(unittest.TestCase): """ Tests for L{dns.str2name}. """ def test_nonString(self): """ When passed a non-string object, L{dns.str2name} returns it unmodified. """ time = object() self.assertIs(time, dns.str2time(time)) def test_seconds(self): """ Passed a string giving a number of seconds, L{dns.str2time} returns the number of seconds represented. For example, C{"10S"} represents C{10} seconds. """ self.assertEqual(10, dns.str2time("10S")) def test_minutes(self): """ Like C{test_seconds}, but for the C{"M"} suffix which multiplies the time value by C{60} (the number of seconds in a minute!). """ self.assertEqual(2 * 60, dns.str2time("2M")) def test_hours(self): """ Like C{test_seconds}, but for the C{"H"} suffix which multiplies the time value by C{3600}, the number of seconds in an hour. """ self.assertEqual(3 * 3600, dns.str2time("3H")) def test_days(self): """ Like L{test_seconds}, but for the C{"D"} suffix which multiplies the time value by C{86400}, the number of seconds in a day. """ self.assertEqual(4 * 86400, dns.str2time("4D")) def test_weeks(self): """ Like L{test_seconds}, but for the C{"W"} suffix which multiplies the time value by C{604800}, the number of seconds in a week. """ self.assertEqual(5 * 604800, dns.str2time("5W")) def test_years(self): """ Like L{test_seconds}, but for the C{"Y"} suffix which multiplies the time value by C{31536000}, the number of seconds in a year. """ self.assertEqual(6 * 31536000, dns.str2time("6Y")) def test_invalidPrefix(self): """ If a non-integer prefix is given, L{dns.str2time} raises L{ValueError}. """ self.assertRaises(ValueError, dns.str2time, "fooS") class NameTests(unittest.TestCase): """ Tests for L{Name}, the representation of a single domain name with support for encoding into and decoding from DNS message format. """ def test_nonStringName(self): """ When constructed with a name which is neither C{bytes} nor C{str}, L{Name} raises L{TypeError}. """ self.assertRaises(TypeError, dns.Name, 123) self.assertRaises(TypeError, dns.Name, object()) self.assertRaises(TypeError, dns.Name, []) def test_unicodeName(self): """ L{dns.Name} automatically encodes unicode domain name using C{idna} encoding. """ name = dns.Name("\u00e9chec.example.org") self.assertIsInstance(name.name, bytes) self.assertEqual(b"xn--chec-9oa.example.org", name.name) def test_decode(self): """ L{Name.decode} populates the L{Name} instance with name information read from the file-like object passed to it. """ n = dns.Name() n.decode(BytesIO(b"\x07example\x03com\x00")) self.assertEqual(n.name, b"example.com") def test_encode(self): """ L{Name.encode} encodes its name information and writes it to the file-like object passed to it. """ name = dns.Name(b"foo.example.com") stream = BytesIO() name.encode(stream) self.assertEqual(stream.getvalue(), b"\x03foo\x07example\x03com\x00") def test_encodeWithCompression(self): """ If a compression dictionary is passed to it, L{Name.encode} uses offset information from it to encode its name with references to existing labels in the stream instead of including another copy of them in the output. It also updates the compression dictionary with the location of the name it writes to the stream. """ name = dns.Name(b"foo.example.com") compression = {b"example.com": 0x17} # Some bytes already encoded into the stream for this message previous = b"some prefix to change .tell()" stream = BytesIO() stream.write(previous) # The position at which the encoded form of this new name will appear in # the stream. expected = len(previous) + dns.Message.headerSize name.encode(stream, compression) self.assertEqual(b"\x03foo\xc0\x17", stream.getvalue()[len(previous) :]) self.assertEqual( {b"example.com": 0x17, b"foo.example.com": expected}, compression ) def test_unknown(self): """ A resource record of unknown type and class is parsed into an L{UnknownRecord} instance with its data preserved, and an L{UnknownRecord} instance is serialized to a string equal to the one it was parsed from. """ wire = ( b"\x01\x00" # Message ID b"\x00" # answer bit, opCode nibble, auth bit, trunc bit, recursive # bit b"\x00" # recursion bit, empty bit, authenticData bit, # checkingDisabled bit, response code nibble b"\x00\x01" # number of queries b"\x00\x01" # number of answers b"\x00\x00" # number of authorities b"\x00\x01" # number of additionals # query b"\x03foo\x03bar\x00" # foo.bar b"\xde\xad" # type=0xdead b"\xbe\xef" # cls=0xbeef # 1st answer b"\xc0\x0c" # foo.bar - compressed b"\xde\xad" # type=0xdead b"\xbe\xef" # cls=0xbeef b"\x00\x00\x01\x01" # ttl=257 b"\x00\x08somedata" # some payload data # 1st additional b"\x03baz\x03ban\x00" # baz.ban b"\x00\x01" # type=A b"\x00\x01" # cls=IN b"\x00\x00\x01\x01" # ttl=257 b"\x00\x04" # len=4 b"\x01\x02\x03\x04" # 1.2.3.4 ) msg = dns.Message() msg.fromStr(wire) self.assertEqual( msg.queries, [ dns.Query(b"foo.bar", type=0xDEAD, cls=0xBEEF), ], ) self.assertEqual( msg.answers, [ dns.RRHeader( b"foo.bar", type=0xDEAD, cls=0xBEEF, ttl=257, payload=dns.UnknownRecord(b"somedata", ttl=257), ), ], ) self.assertEqual( msg.additional, [ dns.RRHeader( b"baz.ban", type=dns.A, cls=dns.IN, ttl=257, payload=dns.Record_A("1.2.3.4", ttl=257), ), ], ) enc = msg.toStr() self.assertEqual(enc, wire) def test_decodeWithCompression(self): """ If the leading byte of an encoded label (in bytes read from a stream passed to L{Name.decode}) has its two high bits set, the next byte is treated as a pointer to another label in the stream and that label is included in the name being decoded. """ # Slightly modified version of the example from RFC 1035, section 4.1.4. stream = BytesIO( b"x" * 20 + b"\x01f\x03isi\x04arpa\x00" b"\x03foo\xc0\x14" b"\x03bar\xc0\x20" ) stream.seek(20) name = dns.Name() name.decode(stream) # Verify we found the first name in the stream and that the stream # position is left at the first byte after the decoded name. self.assertEqual(b"f.isi.arpa", name.name) self.assertEqual(32, stream.tell()) # Get the second name from the stream and make the same assertions. name.decode(stream) self.assertEqual(name.name, b"foo.f.isi.arpa") self.assertEqual(38, stream.tell()) # Get the third and final name name.decode(stream) self.assertEqual(name.name, b"bar.foo.f.isi.arpa") self.assertEqual(44, stream.tell()) def test_rejectCompressionLoop(self): """ L{Name.decode} raises L{ValueError} if the stream passed to it includes a compression pointer which forms a loop, causing the name to be undecodable. """ name = dns.Name() stream = BytesIO(b"\xc0\x00") self.assertRaises(ValueError, name.decode, stream) def test_equality(self): """ L{Name} instances are equal as long as they have the same value for L{Name.name}, regardless of the case. """ name1 = dns.Name(b"foo.bar") name2 = dns.Name(b"foo.bar") self.assertEqual(name1, name2) name3 = dns.Name(b"fOO.bar") self.assertEqual(name1, name3) def test_inequality(self): """ L{Name} instances are not equal as long as they have different L{Name.name} attributes. """ name1 = dns.Name(b"foo.bar") name2 = dns.Name(b"bar.foo") self.assertNotEqual(name1, name2) class RoundtripDNSTests(unittest.TestCase): """ Encoding and then decoding various objects. """ names = [b"example.org", b"go-away.fish.tv", b"23strikesback.net"] def test_name(self): for n in self.names: # encode the name f = BytesIO() dns.Name(n).encode(f) # decode the name f.seek(0, 0) result = dns.Name() result.decode(f) self.assertEqual(result.name, n) def test_query(self): """ L{dns.Query.encode} returns a byte string representing the fields of the query which can be decoded into a new L{dns.Query} instance using L{dns.Query.decode}. """ for n in self.names: for dnstype in range(1, 17): for dnscls in range(1, 5): # encode the query f = BytesIO() dns.Query(n, dnstype, dnscls).encode(f) # decode the result f.seek(0, 0) result = dns.Query() result.decode(f) self.assertEqual(result.name.name, n) self.assertEqual(result.type, dnstype) self.assertEqual(result.cls, dnscls) def test_resourceRecordHeader(self): """ L{dns.RRHeader.encode} encodes the record header's information and writes it to the file-like object passed to it and L{dns.RRHeader.decode} reads from a file-like object to re-construct a L{dns.RRHeader} instance. """ # encode the RR f = BytesIO() dns.RRHeader(b"test.org", 3, 4, 17).encode(f) # decode the result f.seek(0, 0) result = dns.RRHeader() result.decode(f) self.assertEqual(result.name, dns.Name(b"test.org")) self.assertEqual(result.type, 3) self.assertEqual(result.cls, 4) self.assertEqual(result.ttl, 17) def test_resourceRecordHeaderTypeMismatch(self): """ L{RRHeader()} raises L{ValueError} when the given type and the type of the payload don't match. """ with self.assertRaisesRegex(ValueError, r"Payload type \(AAAA\) .* type \(A\)"): dns.RRHeader(type=dns.A, payload=dns.Record_AAAA()) def test_resources(self): """ L{dns.SimpleRecord.encode} encodes the record's name information and writes it to the file-like object passed to it and L{dns.SimpleRecord.decode} reads from a file-like object to re-construct a L{dns.SimpleRecord} instance. """ names = ( b"this.are.test.name", b"will.compress.will.this.will.name.will.hopefully", b"test.CASE.preSErVatIOn.YeAH", b"a.s.h.o.r.t.c.a.s.e.t.o.t.e.s.t", b"singleton", ) for s in names: f = BytesIO() dns.SimpleRecord(s).encode(f) f.seek(0, 0) result = dns.SimpleRecord() result.decode(f) self.assertEqual(result.name, dns.Name(s)) def test_hashable(self): """ Instances of all record types are hashable. """ for k in RECORD_TYPES: k1, k2 = k(), k() hk1 = hash(k1) hk2 = hash(k2) self.assertEqual(hk1, hk2, f"{hk1} != {hk2} (for {k})") def test_Charstr(self): """ Test L{dns.Charstr} encode and decode. """ for n in self.names: # encode the name f = BytesIO() dns.Charstr(n).encode(f) # decode the name f.seek(0, 0) result = dns.Charstr() result.decode(f) self.assertEqual(result.string, n) def _recordRoundtripTest(self, record): """ Assert that encoding C{record} and then decoding the resulting bytes creates a record which compares equal to C{record}. @type record: L{dns.IEncodable} @param record: A record instance to encode """ stream = BytesIO() record.encode(stream) length = stream.tell() stream.seek(0, 0) replica = record.__class__() replica.decode(stream, length) self.assertEqual(record, replica) def assertEncodedFormat(self, expectedEncoding, record): """ Assert that encoding C{record} produces the expected bytes. @type record: L{dns.IEncodable} @param record: A record instance to encode @type expectedEncoding: L{bytes} @param expectedEncoding: The value which C{record.encode()} should produce. """ stream = BytesIO() record.encode(stream) self.assertEqual(stream.getvalue(), expectedEncoding) def test_SOA(self): """ The byte stream written by L{dns.Record_SOA.encode} can be used by L{dns.Record_SOA.decode} to reconstruct the state of the original L{dns.Record_SOA} instance. """ self._recordRoundtripTest( dns.Record_SOA( mname=b"foo", rname=b"bar", serial=12, refresh=34, retry=56, expire=78, minimum=90, ) ) def test_A(self): """ The byte stream written by L{dns.Record_A.encode} can be used by L{dns.Record_A.decode} to reconstruct the state of the original L{dns.Record_A} instance. """ self._recordRoundtripTest(dns.Record_A("1.2.3.4")) def test_NULL(self): """ The byte stream written by L{dns.Record_NULL.encode} can be used by L{dns.Record_NULL.decode} to reconstruct the state of the original L{dns.Record_NULL} instance. """ self._recordRoundtripTest(dns.Record_NULL(b"foo bar")) def test_WKS(self): """ The byte stream written by L{dns.Record_WKS.encode} can be used by L{dns.Record_WKS.decode} to reconstruct the state of the original L{dns.Record_WKS} instance. """ self._recordRoundtripTest(dns.Record_WKS("1.2.3.4", 3, b"xyz")) def test_AAAA(self): """ The byte stream written by L{dns.Record_AAAA.encode} can be used by L{dns.Record_AAAA.decode} to reconstruct the state of the original L{dns.Record_AAAA} instance. """ self._recordRoundtripTest(dns.Record_AAAA("::1")) def test_A6(self): """ The byte stream written by L{dns.Record_A6.encode} can be used by L{dns.Record_A6.decode} to reconstruct the state of the original L{dns.Record_A6} instance. """ self._recordRoundtripTest(dns.Record_A6(8, "::1:2", b"foo")) def test_SRV(self): """ The byte stream written by L{dns.Record_SRV.encode} can be used by L{dns.Record_SRV.decode} to reconstruct the state of the original L{dns.Record_SRV} instance. """ self._recordRoundtripTest( dns.Record_SRV(priority=1, weight=2, port=3, target=b"example.com") ) def test_SSHFP(self): """ The byte stream written by L{dns.Record_SSHFP.encode} can be used by L{dns.Record_SSHFP.decode} to reconstruct the state of the original L{dns.Record_SSHFP} instance. """ fp = ( b"\xda\x39\xa3\xee\x5e\x6b\x4b\x0d" + b"\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09" ) rr = dns.Record_SSHFP( algorithm=dns.Record_SSHFP.ALGORITHM_DSS, fingerprintType=dns.Record_SSHFP.FINGERPRINT_TYPE_SHA1, fingerprint=fp, ) self._recordRoundtripTest(rr) self.assertEncodedFormat(b"\x02\x01" + fp, rr) def test_NAPTR(self): """ Test L{dns.Record_NAPTR} encode and decode. """ naptrs = [ (100, 10, b"u", b"sip+E2U", b"!^.*$!sip:information@domain.tld!", b""), (100, 50, b"s", b"http+I2L+I2C+I2R", b"", b"_http._tcp.gatech.edu"), ] for (order, preference, flags, service, regexp, replacement) in naptrs: rin = dns.Record_NAPTR( order, preference, flags, service, regexp, replacement ) e = BytesIO() rin.encode(e) e.seek(0, 0) rout = dns.Record_NAPTR() rout.decode(e) self.assertEqual(rin.order, rout.order) self.assertEqual(rin.preference, rout.preference) self.assertEqual(rin.flags, rout.flags) self.assertEqual(rin.service, rout.service) self.assertEqual(rin.regexp, rout.regexp) self.assertEqual(rin.replacement.name, rout.replacement.name) self.assertEqual(rin.ttl, rout.ttl) def test_AFSDB(self): """ The byte stream written by L{dns.Record_AFSDB.encode} can be used by L{dns.Record_AFSDB.decode} to reconstruct the state of the original L{dns.Record_AFSDB} instance. """ self._recordRoundtripTest(dns.Record_AFSDB(subtype=3, hostname=b"example.com")) def test_RP(self): """ The byte stream written by L{dns.Record_RP.encode} can be used by L{dns.Record_RP.decode} to reconstruct the state of the original L{dns.Record_RP} instance. """ self._recordRoundtripTest( dns.Record_RP(mbox=b"alice.example.com", txt=b"example.com") ) def test_HINFO(self): """ The byte stream written by L{dns.Record_HINFO.encode} can be used by L{dns.Record_HINFO.decode} to reconstruct the state of the original L{dns.Record_HINFO} instance. """ self._recordRoundtripTest(dns.Record_HINFO(cpu=b"fast", os=b"great")) def test_MINFO(self): """ The byte stream written by L{dns.Record_MINFO.encode} can be used by L{dns.Record_MINFO.decode} to reconstruct the state of the original L{dns.Record_MINFO} instance. """ self._recordRoundtripTest(dns.Record_MINFO(rmailbx=b"foo", emailbx=b"bar")) def test_MX(self): """ The byte stream written by L{dns.Record_MX.encode} can be used by L{dns.Record_MX.decode} to reconstruct the state of the original L{dns.Record_MX} instance. """ self._recordRoundtripTest(dns.Record_MX(preference=1, name=b"example.com")) def test_TSIG(self): """ The byte stream written by L{dns.Record_TSIG.encode} can be used by L{dns.Record_TSIG.decode} to reconstruct the state of the original L{dns.Record_TSIG} instance. """ mac = b"\x00\x01\x02\x03\x10\x11\x12\x13" b"\x20\x21\x22\x23\x30\x31\x32\x33" rr = dns.Record_TSIG( algorithm="hmac-md5.sig-alg.reg.int", timeSigned=1515548975, originalID=42, fudge=5, MAC=mac, ) self._recordRoundtripTest(rr) rdata = ( b"\x08hmac-md5\x07sig-alg\x03reg\x03int\x00" b"\x00\x00\x5a\x55\x71\x2f\x00\x05\x00\x10" + mac + b"\x00\x2A\x00\x00\x00\x00" ) self.assertEncodedFormat(rdata, rr) rr = dns.Record_TSIG( algorithm="hmac-sha256", timeSigned=4511798055, # More than 32 bits originalID=65535, error=dns.EBADTIME, otherData=b"\x80\x00\x00\x00\x00\x08", MAC=mac, ) self._recordRoundtripTest(rr) rdata = ( b"\x0Bhmac-sha256\x00" b"\x00\x01\x0c\xec\x93\x27\x00\x05\x00\x10" + mac + b"\xff\xff\x00\x12\x00\x06" b"\x80\x00\x00\x00\x00\x08" ) self.assertEncodedFormat(rdata, rr) def test_TXT(self): """ The byte stream written by L{dns.Record_TXT.encode} can be used by L{dns.Record_TXT.decode} to reconstruct the state of the original L{dns.Record_TXT} instance. """ self._recordRoundtripTest(dns.Record_TXT(b"foo", b"bar")) MESSAGE_AUTHENTIC_DATA_BYTES = ( b"\x00\x00" # ID b"\x00" # b"\x20" # RA, Z, AD=1, CD, RCODE b"\x00\x00" # Query count b"\x00\x00" # Answer count b"\x00\x00" # Authority count b"\x00\x00" # Additional count ) MESSAGE_CHECKING_DISABLED_BYTES = ( b"\x00\x00" # ID b"\x00" # b"\x10" # RA, Z, AD, CD=1, RCODE b"\x00\x00" # Query count b"\x00\x00" # Answer count b"\x00\x00" # Authority count b"\x00\x00" # Additional count ) class MessageTests(unittest.SynchronousTestCase): """ Tests for L{twisted.names.dns.Message}. """ def test_authenticDataDefault(self): """ L{dns.Message.authenticData} has default value 0. """ self.assertEqual(dns.Message().authenticData, 0) def test_authenticDataOverride(self): """ L{dns.Message.__init__} accepts a C{authenticData} argument which is assigned to L{dns.Message.authenticData}. """ self.assertEqual(dns.Message(authenticData=1).authenticData, 1) def test_authenticDataEncode(self): """ L{dns.Message.toStr} encodes L{dns.Message.authenticData} into byte4 of the byte string. """ self.assertEqual( dns.Message(authenticData=1).toStr(), MESSAGE_AUTHENTIC_DATA_BYTES ) def test_authenticDataDecode(self): """ L{dns.Message.fromStr} decodes byte4 and assigns bit3 to L{dns.Message.authenticData}. """ m = dns.Message() m.fromStr(MESSAGE_AUTHENTIC_DATA_BYTES) self.assertEqual(m.authenticData, 1) def test_checkingDisabledDefault(self): """ L{dns.Message.checkingDisabled} has default value 0. """ self.assertEqual(dns.Message().checkingDisabled, 0) def test_checkingDisabledOverride(self): """ L{dns.Message.__init__} accepts a C{checkingDisabled} argument which is assigned to L{dns.Message.checkingDisabled}. """ self.assertEqual(dns.Message(checkingDisabled=1).checkingDisabled, 1) def test_checkingDisabledEncode(self): """ L{dns.Message.toStr} encodes L{dns.Message.checkingDisabled} into byte4 of the byte string. """ self.assertEqual( dns.Message(checkingDisabled=1).toStr(), MESSAGE_CHECKING_DISABLED_BYTES ) def test_checkingDisabledDecode(self): """ L{dns.Message.fromStr} decodes byte4 and assigns bit4 to L{dns.Message.checkingDisabled}. """ m = dns.Message() m.fromStr(MESSAGE_CHECKING_DISABLED_BYTES) self.assertEqual(m.checkingDisabled, 1) def test_reprDefaults(self): """ L{dns.Message.__repr__} omits field values and sections which are identical to their defaults. The id field value is always shown. """ self.assertEqual("<Message id=0>", repr(dns.Message())) def test_reprFlagsIfSet(self): """ L{dns.Message.__repr__} displays flags if they are L{True}. """ m = dns.Message( answer=True, auth=True, trunc=True, recDes=True, recAv=True, authenticData=True, checkingDisabled=True, ) self.assertEqual( "<Message " "id=0 " "flags=answer,auth,trunc,recDes,recAv,authenticData," "checkingDisabled" ">", repr(m), ) def test_reprNonDefautFields(self): """ L{dns.Message.__repr__} displays field values if they differ from their defaults. """ m = dns.Message(id=10, opCode=20, rCode=30, maxSize=40) self.assertEqual( "<Message " "id=10 " "opCode=20 " "rCode=30 " "maxSize=40" ">", repr(m), ) def test_reprNonDefaultSections(self): """ L{dns.Message.__repr__} displays sections which differ from their defaults. """ m = dns.Message() m.queries = [1, 2, 3] m.answers = [4, 5, 6] m.authority = [7, 8, 9] m.additional = [10, 11, 12] self.assertEqual( "<Message " "id=0 " "queries=[1, 2, 3] " "answers=[4, 5, 6] " "authority=[7, 8, 9] " "additional=[10, 11, 12]" ">", repr(m), ) def test_emptyMessage(self): """ Test that a message which has been truncated causes an EOFError to be raised when it is parsed. """ msg = dns.Message() self.assertRaises(EOFError, msg.fromStr, b"") def test_emptyQuery(self): """ Test that bytes representing an empty query message can be decoded as such. """ msg = dns.Message() msg.fromStr( b"\x01\x00" # Message ID b"\x00" # answer bit, opCode nibble, auth bit, trunc bit, recursive bit b"\x00" # recursion bit, empty bit, authenticData bit, # checkingDisabled bit, response code nibble b"\x00\x00" # number of queries b"\x00\x00" # number of answers b"\x00\x00" # number of authorities b"\x00\x00" # number of additionals ) self.assertEqual(msg.id, 256) self.assertFalse(msg.answer, "Message was not supposed to be an answer.") self.assertEqual(msg.opCode, dns.OP_QUERY) self.assertFalse(msg.auth, "Message was not supposed to be authoritative.") self.assertFalse(msg.trunc, "Message was not supposed to be truncated.") self.assertEqual(msg.queries, []) self.assertEqual(msg.answers, []) self.assertEqual(msg.authority, []) self.assertEqual(msg.additional, []) def test_NULL(self): """ A I{NULL} record with an arbitrary payload can be encoded and decoded as part of a L{dns.Message}. """ bytes = b"".join([dns._ord2bytes(i) for i in range(256)]) rec = dns.Record_NULL(bytes) rr = dns.RRHeader(b"testname", dns.NULL, payload=rec) msg1 = dns.Message() msg1.answers.append(rr) s = BytesIO() msg1.encode(s) s.seek(0, 0) msg2 = dns.Message() msg2.decode(s) self.assertIsInstance(msg2.answers[0].payload, dns.Record_NULL) self.assertEqual(msg2.answers[0].payload.payload, bytes) def test_lookupRecordTypeDefault(self): """ L{Message.lookupRecordType} returns C{dns.UnknownRecord} if it is called with an integer which doesn't correspond to any known record type. """ # 65280 is the first value in the range reserved for private # use, so it shouldn't ever conflict with an officially # allocated value. self.assertIs(dns.Message().lookupRecordType(65280), dns.UnknownRecord) def test_nonAuthoritativeMessage(self): """ The L{RRHeader} instances created by L{Message} from a non-authoritative message are marked as not authoritative. """ buf = BytesIO() answer = dns.RRHeader(payload=dns.Record_A("1.2.3.4", ttl=0)) answer.encode(buf) message = dns.Message() message.fromStr( b"\x01\x00" # Message ID # answer bit, opCode nibble, auth bit, trunc bit, recursive bit b"\x00" # recursion bit, empty bit, authenticData bit, # checkingDisabled bit, response code nibble b"\x00" b"\x00\x00" # number of queries b"\x00\x01" # number of answers b"\x00\x00" # number of authorities b"\x00\x00" + buf.getvalue() # number of additionals ) self.assertEqual(message.answers, [answer]) self.assertFalse(message.answers[0].auth) def test_authoritativeMessage(self): """ The L{RRHeader} instances created by L{Message} from an authoritative message are marked as authoritative. """ buf = BytesIO() answer = dns.RRHeader(payload=dns.Record_A("1.2.3.4", ttl=0)) answer.encode(buf) message = dns.Message() message.fromStr( b"\x01\x00" # Message ID # answer bit, opCode nibble, auth bit, trunc bit, recursive bit b"\x04" # recursion bit, empty bit, authenticData bit, # checkingDisabled bit, response code nibble b"\x00" b"\x00\x00" # number of queries b"\x00\x01" # number of answers b"\x00\x00" # number of authorities b"\x00\x00" + buf.getvalue() # number of additionals ) answer.auth = True self.assertEqual(message.answers, [answer]) self.assertTrue(message.answers[0].auth) class MessageComparisonTests(ComparisonTestsMixin, unittest.SynchronousTestCase): """ Tests for the rich comparison of L{dns.Message} instances. """ def messageFactory(self, *args, **kwargs): """ Create a L{dns.Message}. The L{dns.Message} constructor doesn't accept C{queries}, C{answers}, C{authority}, C{additional} arguments, so we extract them from the kwargs supplied to this factory function and assign them to the message. @param args: Positional arguments. @param kwargs: Keyword arguments. @return: A L{dns.Message} instance. """ queries = kwargs.pop("queries", []) answers = kwargs.pop("answers", []) authority = kwargs.pop("authority", []) additional = kwargs.pop("additional", []) m = dns.Message(**kwargs) if queries: m.queries = queries if answers: m.answers = answers if authority: m.authority = authority if additional: m.additional = additional return m def test_id(self): """ Two L{dns.Message} instances compare equal if they have the same id value. """ self.assertNormalEqualityImplementation( self.messageFactory(id=10), self.messageFactory(id=10), self.messageFactory(id=20), ) def test_answer(self): """ Two L{dns.Message} instances compare equal if they have the same answer flag. """ self.assertNormalEqualityImplementation( self.messageFactory(answer=1), self.messageFactory(answer=1), self.messageFactory(answer=0), ) def test_opCode(self): """ Two L{dns.Message} instances compare equal if they have the same opCode value. """ self.assertNormalEqualityImplementation( self.messageFactory(opCode=10), self.messageFactory(opCode=10), self.messageFactory(opCode=20), ) def test_recDes(self): """ Two L{dns.Message} instances compare equal if they have the same recDes flag. """ self.assertNormalEqualityImplementation( self.messageFactory(recDes=1), self.messageFactory(recDes=1), self.messageFactory(recDes=0), ) def test_recAv(self): """ Two L{dns.Message} instances compare equal if they have the same recAv flag. """ self.assertNormalEqualityImplementation( self.messageFactory(recAv=1), self.messageFactory(recAv=1), self.messageFactory(recAv=0), ) def test_auth(self): """ Two L{dns.Message} instances compare equal if they have the same auth flag. """ self.assertNormalEqualityImplementation( self.messageFactory(auth=1), self.messageFactory(auth=1), self.messageFactory(auth=0), ) def test_rCode(self): """ Two L{dns.Message} instances compare equal if they have the same rCode value. """ self.assertNormalEqualityImplementation( self.messageFactory(rCode=10), self.messageFactory(rCode=10), self.messageFactory(rCode=20), ) def test_trunc(self): """ Two L{dns.Message} instances compare equal if they have the same trunc flag. """ self.assertNormalEqualityImplementation( self.messageFactory(trunc=1), self.messageFactory(trunc=1), self.messageFactory(trunc=0), ) def test_maxSize(self): """ Two L{dns.Message} instances compare equal if they have the same maxSize value. """ self.assertNormalEqualityImplementation( self.messageFactory(maxSize=10), self.messageFactory(maxSize=10), self.messageFactory(maxSize=20), ) def test_authenticData(self): """ Two L{dns.Message} instances compare equal if they have the same authenticData flag. """ self.assertNormalEqualityImplementation( self.messageFactory(authenticData=1), self.messageFactory(authenticData=1), self.messageFactory(authenticData=0), ) def test_checkingDisabled(self): """ Two L{dns.Message} instances compare equal if they have the same checkingDisabled flag. """ self.assertNormalEqualityImplementation( self.messageFactory(checkingDisabled=1), self.messageFactory(checkingDisabled=1), self.messageFactory(checkingDisabled=0), ) def test_queries(self): """ Two L{dns.Message} instances compare equal if they have the same queries. """ self.assertNormalEqualityImplementation( self.messageFactory(queries=[dns.Query(b"example.com")]), self.messageFactory(queries=[dns.Query(b"example.com")]), self.messageFactory(queries=[dns.Query(b"example.org")]), ) def test_answers(self): """ Two L{dns.Message} instances compare equal if they have the same answers. """ self.assertNormalEqualityImplementation( self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ), self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ), self.messageFactory( answers=[dns.RRHeader(b"example.org", payload=dns.Record_A("4.3.2.1"))] ), ) def test_authority(self): """ Two L{dns.Message} instances compare equal if they have the same authority records. """ self.assertNormalEqualityImplementation( self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ), self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ), self.messageFactory( authority=[ dns.RRHeader(b"example.org", type=dns.SOA, payload=dns.Record_SOA()) ] ), ) def test_additional(self): """ Two L{dns.Message} instances compare equal if they have the same additional records. """ self.assertNormalEqualityImplementation( self.messageFactory( additional=[ dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")) ] ), self.messageFactory( additional=[ dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")) ] ), self.messageFactory( additional=[ dns.RRHeader(b"example.org", payload=dns.Record_A("1.2.3.4")) ] ), ) class TestController: """ Pretend to be a DNS query processor for a DNSDatagramProtocol. @ivar messages: the list of received messages. @type messages: C{list} of (msg, protocol, address) """ def __init__(self): """ Initialize the controller: create a list of messages. """ self.messages = [] def messageReceived(self, msg, proto, addr=None): """ Save the message so that it can be checked during the tests. """ self.messages.append((msg, proto, addr)) class DatagramProtocolTests(unittest.TestCase): """ Test various aspects of L{dns.DNSDatagramProtocol}. """ def setUp(self): """ Create a L{dns.DNSDatagramProtocol} with a deterministic clock. """ self.clock = task.Clock() self.controller = TestController() self.proto = dns.DNSDatagramProtocol(self.controller) transport = proto_helpers.FakeDatagramTransport() self.proto.makeConnection(transport) self.proto.callLater = self.clock.callLater def test_truncatedPacket(self): """ Test that when a short datagram is received, datagramReceived does not raise an exception while processing it. """ self.proto.datagramReceived(b"", address.IPv4Address("UDP", "127.0.0.1", 12345)) self.assertEqual(self.controller.messages, []) def test_simpleQuery(self): """ Test content received after a query. """ d = self.proto.query(("127.0.0.1", 21345), [dns.Query(b"foo")]) self.assertEqual(len(self.proto.liveMessages.keys()), 1) m = dns.Message() m.id = next(iter(self.proto.liveMessages.keys())) m.answers = [dns.RRHeader(payload=dns.Record_A(address="1.2.3.4"))] def cb(result): self.assertEqual(result.answers[0].payload.dottedQuad(), "1.2.3.4") d.addCallback(cb) self.proto.datagramReceived(m.toStr(), ("127.0.0.1", 21345)) return d def test_queryTimeout(self): """ Test that query timeouts after some seconds. """ d = self.proto.query(("127.0.0.1", 21345), [dns.Query(b"foo")]) self.assertEqual(len(self.proto.liveMessages), 1) self.clock.advance(10) self.assertFailure(d, dns.DNSQueryTimeoutError) self.assertEqual(len(self.proto.liveMessages), 0) return d def test_writeError(self): """ Exceptions raised by the transport's write method should be turned into C{Failure}s passed to errbacks of the C{Deferred} returned by L{DNSDatagramProtocol.query}. """ def writeError(message, addr): raise RuntimeError("bar") self.proto.transport.write = writeError d = self.proto.query(("127.0.0.1", 21345), [dns.Query(b"foo")]) return self.assertFailure(d, RuntimeError) def test_listenError(self): """ Exception L{CannotListenError} raised by C{listenUDP} should be turned into a C{Failure} passed to errback of the C{Deferred} returned by L{DNSDatagramProtocol.query}. """ def startListeningError(): raise CannotListenError(None, None, None) self.proto.startListening = startListeningError # Clean up transport so that the protocol calls startListening again self.proto.transport = None d = self.proto.query(("127.0.0.1", 21345), [dns.Query(b"foo")]) return self.assertFailure(d, CannotListenError) def test_receiveMessageNotInLiveMessages(self): """ When receiving a message whose id is not in L{DNSDatagramProtocol.liveMessages} or L{DNSDatagramProtocol.resends}, the message will be received by L{DNSDatagramProtocol.controller}. """ message = dns.Message() message.id = 1 message.answers = [dns.RRHeader(payload=dns.Record_A(address="1.2.3.4"))] self.proto.datagramReceived(message.toStr(), ("127.0.0.1", 21345)) self.assertEqual(self.controller.messages[-1][0].toStr(), message.toStr()) class TestTCPController(TestController): """ Pretend to be a DNS query processor for a DNSProtocol. @ivar connections: A list of L{DNSProtocol} instances which have notified this controller that they are connected and have not yet notified it that their connection has been lost. """ def __init__(self): TestController.__init__(self) self.connections = [] def connectionMade(self, proto): self.connections.append(proto) def connectionLost(self, proto): self.connections.remove(proto) class DNSProtocolTests(unittest.TestCase): """ Test various aspects of L{dns.DNSProtocol}. """ def setUp(self): """ Create a L{dns.DNSProtocol} with a deterministic clock. """ self.clock = task.Clock() self.controller = TestTCPController() self.proto = dns.DNSProtocol(self.controller) self.proto.makeConnection(proto_helpers.StringTransport()) self.proto.callLater = self.clock.callLater def test_connectionTracking(self): """ L{dns.DNSProtocol} calls its controller's C{connectionMade} method with itself when it is connected to a transport and its controller's C{connectionLost} method when it is disconnected. """ self.assertEqual(self.controller.connections, [self.proto]) self.proto.connectionLost(Failure(ConnectionDone("Fake Connection Done"))) self.assertEqual(self.controller.connections, []) def test_queryTimeout(self): """ Test that query timeouts after some seconds. """ d = self.proto.query([dns.Query(b"foo")]) self.assertEqual(len(self.proto.liveMessages), 1) self.clock.advance(60) self.assertFailure(d, dns.DNSQueryTimeoutError) self.assertEqual(len(self.proto.liveMessages), 0) return d def test_simpleQuery(self): """ Test content received after a query. """ d = self.proto.query([dns.Query(b"foo")]) self.assertEqual(len(self.proto.liveMessages.keys()), 1) m = dns.Message() m.id = next(iter(self.proto.liveMessages.keys())) m.answers = [dns.RRHeader(payload=dns.Record_A(address="1.2.3.4"))] def cb(result): self.assertEqual(result.answers[0].payload.dottedQuad(), "1.2.3.4") d.addCallback(cb) s = m.toStr() s = struct.pack("!H", len(s)) + s self.proto.dataReceived(s) return d def test_writeError(self): """ Exceptions raised by the transport's write method should be turned into C{Failure}s passed to errbacks of the C{Deferred} returned by L{DNSProtocol.query}. """ def writeError(message): raise RuntimeError("bar") self.proto.transport.write = writeError d = self.proto.query([dns.Query(b"foo")]) return self.assertFailure(d, RuntimeError) def test_receiveMessageNotInLiveMessages(self): """ When receiving a message whose id is not in L{DNSProtocol.liveMessages} the message will be received by L{DNSProtocol.controller}. """ message = dns.Message() message.id = 1 message.answers = [dns.RRHeader(payload=dns.Record_A(address="1.2.3.4"))] string = message.toStr() string = struct.pack("!H", len(string)) + string self.proto.dataReceived(string) self.assertEqual(self.controller.messages[-1][0].toStr(), message.toStr()) class ReprTests(unittest.TestCase): """ Tests for the C{__repr__} implementation of record classes. """ def test_ns(self): """ The repr of a L{dns.Record_NS} instance includes the name of the nameserver and the TTL of the record. """ self.assertEqual( repr(dns.Record_NS(b"example.com", 4321)), "<NS name=example.com ttl=4321>" ) def test_md(self): """ The repr of a L{dns.Record_MD} instance includes the name of the mail destination and the TTL of the record. """ self.assertEqual( repr(dns.Record_MD(b"example.com", 4321)), "<MD name=example.com ttl=4321>" ) def test_mf(self): """ The repr of a L{dns.Record_MF} instance includes the name of the mail forwarder and the TTL of the record. """ self.assertEqual( repr(dns.Record_MF(b"example.com", 4321)), "<MF name=example.com ttl=4321>" ) def test_cname(self): """ The repr of a L{dns.Record_CNAME} instance includes the name of the mail forwarder and the TTL of the record. """ self.assertEqual( repr(dns.Record_CNAME(b"example.com", 4321)), "<CNAME name=example.com ttl=4321>", ) def test_mb(self): """ The repr of a L{dns.Record_MB} instance includes the name of the mailbox and the TTL of the record. """ self.assertEqual( repr(dns.Record_MB(b"example.com", 4321)), "<MB name=example.com ttl=4321>" ) def test_mg(self): """ The repr of a L{dns.Record_MG} instance includes the name of the mail group member and the TTL of the record. """ self.assertEqual( repr(dns.Record_MG(b"example.com", 4321)), "<MG name=example.com ttl=4321>" ) def test_mr(self): """ The repr of a L{dns.Record_MR} instance includes the name of the mail rename domain and the TTL of the record. """ self.assertEqual( repr(dns.Record_MR(b"example.com", 4321)), "<MR name=example.com ttl=4321>" ) def test_ptr(self): """ The repr of a L{dns.Record_PTR} instance includes the name of the pointer and the TTL of the record. """ self.assertEqual( repr(dns.Record_PTR(b"example.com", 4321)), "<PTR name=example.com ttl=4321>", ) def test_dname(self): """ The repr of a L{dns.Record_DNAME} instance includes the name of the non-terminal DNS name redirection and the TTL of the record. """ self.assertEqual( repr(dns.Record_DNAME(b"example.com", 4321)), "<DNAME name=example.com ttl=4321>", ) def test_a(self): """ The repr of a L{dns.Record_A} instance includes the dotted-quad string representation of the address it is for and the TTL of the record. """ self.assertEqual( repr(dns.Record_A("1.2.3.4", 567)), "<A address=1.2.3.4 ttl=567>" ) def test_soa(self): """ The repr of a L{dns.Record_SOA} instance includes all of the authority fields. """ self.assertEqual( repr( dns.Record_SOA( mname=b"mName", rname=b"rName", serial=123, refresh=456, retry=789, expire=10, minimum=11, ttl=12, ) ), "<SOA mname=mName rname=rName serial=123 refresh=456 " "retry=789 expire=10 minimum=11 ttl=12>", ) def test_null(self): """ The repr of a L{dns.Record_NULL} instance includes the repr of its payload and the TTL of the record. """ self.assertEqual( repr(dns.Record_NULL(b"abcd", 123)), "<NULL payload='abcd' ttl=123>" ) def test_wks(self): """ The repr of a L{dns.Record_WKS} instance includes the dotted-quad string representation of the address it is for, the IP protocol number it is for, and the TTL of the record. """ self.assertEqual( repr(dns.Record_WKS("2.3.4.5", 7, ttl=8)), "<WKS address=2.3.4.5 protocol=7 ttl=8>", ) def test_aaaa(self): """ The repr of a L{dns.Record_AAAA} instance includes the colon-separated hex string representation of the address it is for and the TTL of the record. """ self.assertEqual( repr(dns.Record_AAAA("8765::1234", ttl=10)), "<AAAA address=8765::1234 ttl=10>", ) def test_a6(self): """ The repr of a L{dns.Record_A6} instance includes the colon-separated hex string representation of the address it is for and the TTL of the record. """ self.assertEqual( repr(dns.Record_A6(0, "1234::5678", b"foo.bar", ttl=10)), "<A6 suffix=1234::5678 prefix=foo.bar ttl=10>", ) def test_srv(self): """ The repr of a L{dns.Record_SRV} instance includes the name and port of the target and the priority, weight, and TTL of the record. """ self.assertEqual( repr(dns.Record_SRV(1, 2, 3, b"example.org", 4)), "<SRV priority=1 weight=2 target=example.org port=3 ttl=4>", ) def test_naptr(self): """ The repr of a L{dns.Record_NAPTR} instance includes the order, preference, flags, service, regular expression, replacement, and TTL of the record. """ record = dns.Record_NAPTR(5, 9, b"S", b"http", b"/foo/bar/i", b"baz", 3) self.assertEqual( repr(record), "<NAPTR order=5 preference=9 flags=S service=http " "regexp=/foo/bar/i replacement=baz ttl=3>", ) def test_afsdb(self): """ The repr of a L{dns.Record_AFSDB} instance includes the subtype, hostname, and TTL of the record. """ self.assertEqual( repr(dns.Record_AFSDB(3, b"example.org", 5)), "<AFSDB subtype=3 hostname=example.org ttl=5>", ) def test_rp(self): """ The repr of a L{dns.Record_RP} instance includes the mbox, txt, and TTL fields of the record. """ self.assertEqual( repr(dns.Record_RP(b"alice.example.com", b"admin.example.com", 3)), "<RP mbox=alice.example.com txt=admin.example.com ttl=3>", ) def test_hinfo(self): """ The repr of a L{dns.Record_HINFO} instance includes the cpu, os, and TTL fields of the record. """ self.assertEqual( repr(dns.Record_HINFO(b"sparc", b"minix", 12)), "<HINFO cpu='sparc' os='minix' ttl=12>", ) def test_minfo(self): """ The repr of a L{dns.Record_MINFO} instance includes the rmailbx, emailbx, and TTL fields of the record. """ record = dns.Record_MINFO(b"alice.example.com", b"bob.example.com", 15) self.assertEqual( repr(record), "<MINFO responsibility=alice.example.com " "errors=bob.example.com ttl=15>", ) def test_mx(self): """ The repr of a L{dns.Record_MX} instance includes the preference, name, and TTL fields of the record. """ self.assertEqual( repr(dns.Record_MX(13, b"mx.example.com", 2)), "<MX preference=13 name=mx.example.com ttl=2>", ) def test_txt(self): """ The repr of a L{dns.Record_TXT} instance includes the data and ttl fields of the record. """ self.assertEqual( repr(dns.Record_TXT(b"foo", b"bar", ttl=15)), "<TXT data=['foo', 'bar'] ttl=15>", ) def test_spf(self): """ The repr of a L{dns.Record_SPF} instance includes the data and ttl fields of the record. """ self.assertEqual( repr(dns.Record_SPF(b"foo", b"bar", ttl=15)), "<SPF data=['foo', 'bar'] ttl=15>", ) def test_unknown(self): """ The repr of a L{dns.UnknownRecord} instance includes the data and ttl fields of the record. """ self.assertEqual( repr(dns.UnknownRecord(b"foo\x1fbar", 12)), "<UNKNOWN data='foo\\x1fbar' ttl=12>", ) class EqualityTests(ComparisonTestsMixin, unittest.TestCase): """ Tests for the equality and non-equality behavior of record classes. """ def _equalityTest(self, firstValueOne, secondValueOne, valueTwo): return self.assertNormalEqualityImplementation( firstValueOne, secondValueOne, valueTwo ) def test_charstr(self): """ Two L{dns.Charstr} instances compare equal if and only if they have the same string value. """ self._equalityTest( dns.Charstr(b"abc"), dns.Charstr(b"abc"), dns.Charstr(b"def") ) def test_name(self): """ Two L{dns.Name} instances compare equal if and only if they have the same name value. """ self._equalityTest(dns.Name(b"abc"), dns.Name(b"abc"), dns.Name(b"def")) def _simpleEqualityTest(self, cls): """ Assert that instances of C{cls} with the same attributes compare equal to each other and instances with different attributes compare as not equal. @param cls: A L{dns.SimpleRecord} subclass. """ # Vary the TTL self._equalityTest( cls(b"example.com", 123), cls(b"example.com", 123), cls(b"example.com", 321) ) # Vary the name self._equalityTest( cls(b"example.com", 123), cls(b"example.com", 123), cls(b"example.org", 123) ) def test_rrheader(self): """ Two L{dns.RRHeader} instances compare equal if and only if they have the same name, type, class, time to live, payload, and authoritative bit. """ # Vary the name self._equalityTest( dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.org", payload=dns.Record_A("1.2.3.4")), ) # Vary the payload self._equalityTest( dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.5")), ) # Vary the type. Leave the payload as None so that we don't have to # provide non-equal values. self._equalityTest( dns.RRHeader(b"example.com", dns.A), dns.RRHeader(b"example.com", dns.A), dns.RRHeader(b"example.com", dns.MX), ) # Probably not likely to come up. Most people use the internet. self._equalityTest( dns.RRHeader(b"example.com", cls=dns.IN, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", cls=dns.IN, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", cls=dns.CS, payload=dns.Record_A("1.2.3.4")), ) # Vary the ttl self._equalityTest( dns.RRHeader(b"example.com", ttl=60, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", ttl=60, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", ttl=120, payload=dns.Record_A("1.2.3.4")), ) # Vary the auth bit self._equalityTest( dns.RRHeader(b"example.com", auth=1, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", auth=1, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", auth=0, payload=dns.Record_A("1.2.3.4")), ) def test_ns(self): """ Two L{dns.Record_NS} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_NS) def test_md(self): """ Two L{dns.Record_MD} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MD) def test_mf(self): """ Two L{dns.Record_MF} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MF) def test_cname(self): """ Two L{dns.Record_CNAME} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_CNAME) def test_mb(self): """ Two L{dns.Record_MB} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MB) def test_mg(self): """ Two L{dns.Record_MG} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MG) def test_mr(self): """ Two L{dns.Record_MR} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MR) def test_ptr(self): """ Two L{dns.Record_PTR} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_PTR) def test_dname(self): """ Two L{dns.Record_MD} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_DNAME) def test_a(self): """ Two L{dns.Record_A} instances compare equal if and only if they have the same address and TTL. """ # Vary the TTL self._equalityTest( dns.Record_A("1.2.3.4", 5), dns.Record_A("1.2.3.4", 5), dns.Record_A("1.2.3.4", 6), ) # Vary the address self._equalityTest( dns.Record_A("1.2.3.4", 5), dns.Record_A("1.2.3.4", 5), dns.Record_A("1.2.3.5", 5), ) def test_soa(self): """ Two L{dns.Record_SOA} instances compare equal if and only if they have the same mname, rname, serial, refresh, minimum, expire, retry, and ttl. """ # Vary the mname self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"xname", b"rname", 123, 456, 789, 10, 20, 30), ) # Vary the rname self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"xname", 123, 456, 789, 10, 20, 30), ) # Vary the serial self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 1, 456, 789, 10, 20, 30), ) # Vary the refresh self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 1, 789, 10, 20, 30), ) # Vary the minimum self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 1, 10, 20, 30), ) # Vary the expire self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 1, 20, 30), ) # Vary the retry self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 1, 30), ) # Vary the ttl self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"xname", 123, 456, 789, 10, 20, 1), ) def test_null(self): """ Two L{dns.Record_NULL} instances compare equal if and only if they have the same payload and ttl. """ # Vary the payload self._equalityTest( dns.Record_NULL("foo bar", 10), dns.Record_NULL("foo bar", 10), dns.Record_NULL("bar foo", 10), ) # Vary the ttl self._equalityTest( dns.Record_NULL("foo bar", 10), dns.Record_NULL("foo bar", 10), dns.Record_NULL("foo bar", 100), ) def test_wks(self): """ Two L{dns.Record_WKS} instances compare equal if and only if they have the same address, protocol, map, and ttl. """ # Vary the address self._equalityTest( dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("4.3.2.1", 1, "foo", 2), ) # Vary the protocol self._equalityTest( dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 100, "foo", 2), ) # Vary the map self._equalityTest( dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "bar", 2), ) # Vary the ttl self._equalityTest( dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 200), ) def test_aaaa(self): """ Two L{dns.Record_AAAA} instances compare equal if and only if they have the same address and ttl. """ # Vary the address self._equalityTest( dns.Record_AAAA("1::2", 1), dns.Record_AAAA("1::2", 1), dns.Record_AAAA("2::1", 1), ) # Vary the ttl self._equalityTest( dns.Record_AAAA("1::2", 1), dns.Record_AAAA("1::2", 1), dns.Record_AAAA("1::2", 10), ) def test_a6(self): """ Two L{dns.Record_A6} instances compare equal if and only if they have the same prefix, prefix length, suffix, and ttl. """ # Note, A6 is crazy, I'm not sure these values are actually legal. # Hopefully that doesn't matter for this test. -exarkun # Vary the prefix length self._equalityTest( dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(32, "::abcd", b"example.com", 10), ) # Vary the suffix self._equalityTest( dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd:0", b"example.com", 10), ) # Vary the prefix self._equalityTest( dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.org", 10), ) # Vary the ttl self._equalityTest( dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 100), ) def test_srv(self): """ Two L{dns.Record_SRV} instances compare equal if and only if they have the same priority, weight, port, target, and ttl. """ # Vary the priority self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(100, 20, 30, b"example.com", 40), ) # Vary the weight self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 200, 30, b"example.com", 40), ) # Vary the port self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 300, b"example.com", 40), ) # Vary the target self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.org", 40), ) # Vary the ttl self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 400), ) def test_sshfp(self): """ Two L{dns.Record_SSHFP} instances compare equal if and only if they have the same key type, fingerprint type, fingerprint, and ttl. """ # Vary the key type. self._equalityTest( dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(2, 2, b"happyday", 40), ) # Vary the fingerprint type. self._equalityTest( dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 1, b"happyday", 40), ) # Vary the fingerprint itself. self._equalityTest( dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happxday", 40), ) # Vary the ttl. self._equalityTest( dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 45), ) def test_naptr(self): """ Two L{dns.Record_NAPTR} instances compare equal if and only if they have the same order, preference, flags, service, regexp, replacement, and ttl. """ # Vary the order self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(2, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), ) # Vary the preference self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 3, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), ) # Vary the flags self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"p", b"sip+E2U", b"/foo/bar/", b"baz", 12), ) # Vary the service self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"http", b"/foo/bar/", b"baz", 12), ) # Vary the regexp self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/bar/foo/", b"baz", 12), ) # Vary the replacement self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/bar/foo/", b"quux", 12), ) # Vary the ttl self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/bar/foo/", b"baz", 5), ) def test_afsdb(self): """ Two L{dns.Record_AFSDB} instances compare equal if and only if they have the same subtype, hostname, and ttl. """ # Vary the subtype self._equalityTest( dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(2, b"example.com", 2), ) # Vary the hostname self._equalityTest( dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.org", 2), ) # Vary the ttl self._equalityTest( dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.com", 3), ) def test_rp(self): """ Two L{Record_RP} instances compare equal if and only if they have the same mbox, txt, and ttl. """ # Vary the mbox self._equalityTest( dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"bob.example.com", b"alice is nice", 10), ) # Vary the txt self._equalityTest( dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is not nice", 10), ) # Vary the ttl self._equalityTest( dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is nice", 100), ) def test_hinfo(self): """ Two L{dns.Record_HINFO} instances compare equal if and only if they have the same cpu, os, and ttl. """ # Vary the cpu self._equalityTest( dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("i386", "plan9", 10), ) # Vary the os self._equalityTest( dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan11", 10), ) # Vary the ttl self._equalityTest( dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan9", 100), ) def test_minfo(self): """ Two L{dns.Record_MINFO} instances compare equal if and only if they have the same rmailbx, emailbx, and ttl. """ # Vary the rmailbx self._equalityTest( dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"someplace", b"emailbox", 10), ) # Vary the emailbx self._equalityTest( dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"something", 10), ) # Vary the ttl self._equalityTest( dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"emailbox", 100), ) def test_mx(self): """ Two L{dns.Record_MX} instances compare equal if and only if they have the same preference, name, and ttl. """ # Vary the preference self._equalityTest( dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.org", 20), dns.Record_MX(100, b"example.org", 20), ) # Vary the name self._equalityTest( dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.net", 20), ) # Vary the ttl self._equalityTest( dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.org", 200), ) def test_txt(self): """ Two L{dns.Record_TXT} instances compare equal if and only if they have the same data and ttl. """ # Vary the length of the data self._equalityTest( dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", "baz", ttl=10), ) # Vary the value of the data self._equalityTest( dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("bar", "foo", ttl=10), ) # Vary the ttl self._equalityTest( dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", ttl=100), ) def test_spf(self): """ L{dns.Record_SPF} instances compare equal if and only if they have the same data and ttl. """ # Vary the length of the data self._equalityTest( dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", "baz", ttl=10), ) # Vary the value of the data self._equalityTest( dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("bar", "foo", ttl=10), ) # Vary the ttl self._equalityTest( dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", ttl=100), ) def test_tsig(self): """ L{dns.Record_TSIG} instances compare equal if and only if they have the same RDATA (algorithm, timestamp, MAC, etc.) and ttl. """ baseargs = { "algorithm": "hmac-sha224", "timeSigned": 1515548975, "fudge": 5, "MAC": b"\x01\x02\x03\x04\x05", "originalID": 99, "error": dns.OK, "otherData": b"", "ttl": 40, } altargs = { "algorithm": "hmac-sha512", "timeSigned": 1515548875, "fudge": 0, "MAC": b"\x05\x04\x03\x02\x01", "originalID": 65437, "error": dns.EBADTIME, "otherData": b"\x00\x00", "ttl": 400, } for kw in baseargs.keys(): altered = baseargs.copy() altered[kw] = altargs[kw] self._equalityTest( dns.Record_TSIG(**altered), dns.Record_TSIG(**altered), dns.Record_TSIG(**baseargs), ) def test_unknown(self): """ L{dns.UnknownRecord} instances compare equal if and only if they have the same data and ttl. """ # Vary the length of the data self._equalityTest( dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foobar", ttl=10), ) # Vary the value of the data self._equalityTest( dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("bar", ttl=10), ) # Vary the ttl self._equalityTest( dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foo", ttl=100), ) class RRHeaderTests(unittest.TestCase): """ Tests for L{twisted.names.dns.RRHeader}. """ def test_negativeTTL(self): """ Attempting to create a L{dns.RRHeader} instance with a negative TTL causes L{ValueError} to be raised. """ self.assertRaises( ValueError, dns.RRHeader, "example.com", dns.A, dns.IN, -1, dns.Record_A("127.0.0.1"), ) def test_nonIntegralTTL(self): """ L{dns.RRHeader} converts TTLs to integers. """ ttlAsFloat = 123.45 header = dns.RRHeader( "example.com", dns.A, dns.IN, ttlAsFloat, dns.Record_A("127.0.0.1") ) self.assertEqual(header.ttl, int(ttlAsFloat)) def test_nonNumericTTLRaisesTypeError(self): """ Attempting to create a L{dns.RRHeader} instance with a TTL that L{int} cannot convert to an integer raises a L{TypeError}. """ self.assertRaises( ValueError, dns.RRHeader, "example.com", dns.A, dns.IN, "this is not a number", dns.Record_A("127.0.0.1"), ) class NameToLabelsTests(unittest.SynchronousTestCase): """ Tests for L{twisted.names.dns._nameToLabels}. """ def test_empty(self): """ L{dns._nameToLabels} returns a list containing a single empty label for an empty name. """ self.assertEqual(dns._nameToLabels(b""), [b""]) def test_onlyDot(self): """ L{dns._nameToLabels} returns a list containing a single empty label for a name containing only a dot. """ self.assertEqual(dns._nameToLabels(b"."), [b""]) def test_withoutTrailingDot(self): """ L{dns._nameToLabels} returns a list ending with an empty label for a name without a trailing dot. """ self.assertEqual(dns._nameToLabels(b"com"), [b"com", b""]) def test_withTrailingDot(self): """ L{dns._nameToLabels} returns a list ending with an empty label for a name with a trailing dot. """ self.assertEqual(dns._nameToLabels(b"com."), [b"com", b""]) def test_subdomain(self): """ L{dns._nameToLabels} returns a list containing entries for all labels in a subdomain name. """ self.assertEqual( dns._nameToLabels(b"foo.bar.baz.example.com."), [b"foo", b"bar", b"baz", b"example", b"com", b""], ) def test_casePreservation(self): """ L{dns._nameToLabels} preserves the case of ascii characters in labels. """ self.assertEqual(dns._nameToLabels(b"EXAMPLE.COM"), [b"EXAMPLE", b"COM", b""]) def assertIsSubdomainOf(testCase, descendant, ancestor): """ Assert that C{descendant} *is* a subdomain of C{ancestor}. @type testCase: L{unittest.SynchronousTestCase} @param testCase: The test case on which to run the assertions. @type descendant: C{str} @param descendant: The subdomain name to test. @type ancestor: C{str} @param ancestor: The superdomain name to test. """ testCase.assertTrue( dns._isSubdomainOf(descendant, ancestor), f"{descendant!r} is not a subdomain of {ancestor!r}", ) def assertIsNotSubdomainOf(testCase, descendant, ancestor): """ Assert that C{descendant} *is not* a subdomain of C{ancestor}. @type testCase: L{unittest.SynchronousTestCase} @param testCase: The test case on which to run the assertions. @type descendant: C{str} @param descendant: The subdomain name to test. @type ancestor: C{str} @param ancestor: The superdomain name to test. """ testCase.assertFalse( dns._isSubdomainOf(descendant, ancestor), f"{descendant!r} is a subdomain of {ancestor!r}", ) class IsSubdomainOfTests(unittest.SynchronousTestCase): """ Tests for L{twisted.names.dns._isSubdomainOf}. """ def test_identical(self): """ L{dns._isSubdomainOf} returns C{True} for identical domain names. """ assertIsSubdomainOf(self, b"example.com", b"example.com") def test_parent(self): """ L{dns._isSubdomainOf} returns C{True} when the first name is an immediate descendant of the second name. """ assertIsSubdomainOf(self, b"foo.example.com", b"example.com") def test_distantAncestor(self): """ L{dns._isSubdomainOf} returns C{True} when the first name is a distant descendant of the second name. """ assertIsSubdomainOf(self, b"foo.bar.baz.example.com", b"com") def test_superdomain(self): """ L{dns._isSubdomainOf} returns C{False} when the first name is an ancestor of the second name. """ assertIsNotSubdomainOf(self, b"example.com", b"foo.example.com") def test_sibling(self): """ L{dns._isSubdomainOf} returns C{False} if the first name is a sibling of the second name. """ assertIsNotSubdomainOf(self, b"foo.example.com", b"bar.example.com") def test_unrelatedCommonSuffix(self): """ L{dns._isSubdomainOf} returns C{False} even when domain names happen to share a common suffix. """ assertIsNotSubdomainOf(self, b"foo.myexample.com", b"example.com") def test_subdomainWithTrailingDot(self): """ L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name but the first name has a trailing ".". """ assertIsSubdomainOf(self, b"foo.example.com.", b"example.com") def test_superdomainWithTrailingDot(self): """ L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name but the second name has a trailing ".". """ assertIsSubdomainOf(self, b"foo.example.com", b"example.com.") def test_bothWithTrailingDot(self): """ L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name and both names have a trailing ".". """ assertIsSubdomainOf(self, b"foo.example.com.", b"example.com.") def test_emptySubdomain(self): """ L{dns._isSubdomainOf} returns C{False} if the first name is empty and the second name is not. """ assertIsNotSubdomainOf(self, b"", b"example.com") def test_emptySuperdomain(self): """ L{dns._isSubdomainOf} returns C{True} if the second name is empty and the first name is not. """ assertIsSubdomainOf(self, b"foo.example.com", b"") def test_caseInsensitiveComparison(self): """ L{dns._isSubdomainOf} does case-insensitive comparison of name labels. """ assertIsSubdomainOf(self, b"foo.example.com", b"EXAMPLE.COM") assertIsSubdomainOf(self, b"FOO.EXAMPLE.COM", b"example.com") class OPTNonStandardAttributes: """ Generate byte and instance representations of an L{dns._OPTHeader} where all attributes are set to non-default values. For testing whether attributes have really been read from the byte string during decoding. """ @classmethod def bytes(cls, excludeName=False, excludeOptions=False): """ Return L{bytes} representing an encoded OPT record. @param excludeName: A flag that controls whether to exclude the name field. This allows a non-standard name to be prepended during the test. @type excludeName: L{bool} @param excludeOptions: A flag that controls whether to exclude the RDLEN field. This allows encoded variable options to be appended during the test. @type excludeOptions: L{bool} @return: L{bytes} representing the encoded OPT record returned by L{object}. """ rdlen = b"\x00\x00" # RDLEN 0 if excludeOptions: rdlen = b"" return ( b"\x00" # 0 root zone b"\x00\x29" # type 41 b"\x02\x00" # udpPayloadsize 512 b"\x03" # extendedRCODE 3 b"\x04" # version 4 b"\x80\x00" # DNSSEC OK 1 + Z ) + rdlen @classmethod def object(cls): """ Return a new L{dns._OPTHeader} instance. @return: A L{dns._OPTHeader} instance with attributes that match the encoded record returned by L{bytes}. """ return dns._OPTHeader( udpPayloadSize=512, extendedRCODE=3, version=4, dnssecOK=True ) class OPTHeaderTests(ComparisonTestsMixin, unittest.TestCase): """ Tests for L{twisted.names.dns._OPTHeader}. """ def test_interface(self): """ L{dns._OPTHeader} implements L{dns.IEncodable}. """ verifyClass(dns.IEncodable, dns._OPTHeader) def test_name(self): """ L{dns._OPTHeader.name} is an instance attribute whose value is fixed as the root domain """ self.assertEqual(dns._OPTHeader().name, dns.Name(b"")) def test_nameReadonly(self): """ L{dns._OPTHeader.name} is readonly. """ h = dns._OPTHeader() self.assertRaises(AttributeError, setattr, h, "name", dns.Name(b"example.com")) def test_type(self): """ L{dns._OPTHeader.type} is an instance attribute with fixed value 41. """ self.assertEqual(dns._OPTHeader().type, 41) def test_typeReadonly(self): """ L{dns._OPTHeader.type} is readonly. """ h = dns._OPTHeader() self.assertRaises(AttributeError, setattr, h, "type", dns.A) def test_udpPayloadSize(self): """ L{dns._OPTHeader.udpPayloadSize} defaults to 4096 as recommended in rfc6891 section-6.2.5. """ self.assertEqual(dns._OPTHeader().udpPayloadSize, 4096) def test_udpPayloadSizeOverride(self): """ L{dns._OPTHeader.udpPayloadSize} can be overridden in the constructor. """ self.assertEqual(dns._OPTHeader(udpPayloadSize=512).udpPayloadSize, 512) def test_extendedRCODE(self): """ L{dns._OPTHeader.extendedRCODE} defaults to 0. """ self.assertEqual(dns._OPTHeader().extendedRCODE, 0) def test_extendedRCODEOverride(self): """ L{dns._OPTHeader.extendedRCODE} can be overridden in the constructor. """ self.assertEqual(dns._OPTHeader(extendedRCODE=1).extendedRCODE, 1) def test_version(self): """ L{dns._OPTHeader.version} defaults to 0. """ self.assertEqual(dns._OPTHeader().version, 0) def test_versionOverride(self): """ L{dns._OPTHeader.version} can be overridden in the constructor. """ self.assertEqual(dns._OPTHeader(version=1).version, 1) def test_dnssecOK(self): """ L{dns._OPTHeader.dnssecOK} defaults to False. """ self.assertFalse(dns._OPTHeader().dnssecOK) def test_dnssecOKOverride(self): """ L{dns._OPTHeader.dnssecOK} can be overridden in the constructor. """ self.assertTrue(dns._OPTHeader(dnssecOK=True).dnssecOK) def test_options(self): """ L{dns._OPTHeader.options} defaults to empty list. """ self.assertEqual(dns._OPTHeader().options, []) def test_optionsOverride(self): """ L{dns._OPTHeader.options} can be overridden in the constructor. """ h = dns._OPTHeader(options=[(1, 1, b"\x00")]) self.assertEqual(h.options, [(1, 1, b"\x00")]) def test_encode(self): """ L{dns._OPTHeader.encode} packs the header fields and writes them to a file like object passed in as an argument. """ b = BytesIO() OPTNonStandardAttributes.object().encode(b) self.assertEqual(b.getvalue(), OPTNonStandardAttributes.bytes()) def test_encodeWithOptions(self): """ L{dns._OPTHeader.options} is a list of L{dns._OPTVariableOption} instances which are packed into the rdata area of the header. """ h = OPTNonStandardAttributes.object() h.options = [ dns._OPTVariableOption(1, b"foobarbaz"), dns._OPTVariableOption(2, b"qux"), ] b = BytesIO() h.encode(b) self.assertEqual( b.getvalue(), OPTNonStandardAttributes.bytes(excludeOptions=True) + ( b"\x00\x14" # RDLEN 20 b"\x00\x01" # OPTION-CODE b"\x00\x09" # OPTION-LENGTH b"foobarbaz" # OPTION-DATA b"\x00\x02" # OPTION-CODE b"\x00\x03" # OPTION-LENGTH b"qux" # OPTION-DATA ), ) def test_decode(self): """ L{dns._OPTHeader.decode} unpacks the header fields from a file like object and populates the attributes of an existing L{dns._OPTHeader} instance. """ decodedHeader = dns._OPTHeader() decodedHeader.decode(BytesIO(OPTNonStandardAttributes.bytes())) self.assertEqual(decodedHeader, OPTNonStandardAttributes.object()) def test_decodeAllExpectedBytes(self): """ L{dns._OPTHeader.decode} reads all the bytes of the record that is being decoded. """ # Check that all the input data has been consumed. b = BytesIO(OPTNonStandardAttributes.bytes()) decodedHeader = dns._OPTHeader() decodedHeader.decode(b) self.assertEqual(b.tell(), len(b.getvalue())) def test_decodeOnlyExpectedBytes(self): """ L{dns._OPTHeader.decode} reads only the bytes from the current file position to the end of the record that is being decoded. Trailing bytes are not consumed. """ b = BytesIO(OPTNonStandardAttributes.bytes() + b"xxxx") # Trailing bytes decodedHeader = dns._OPTHeader() decodedHeader.decode(b) self.assertEqual(b.tell(), len(b.getvalue()) - len(b"xxxx")) def test_decodeDiscardsName(self): """ L{dns._OPTHeader.decode} discards the name which is encoded in the supplied bytes. The name attribute of the resulting L{dns._OPTHeader} instance will always be L{dns.Name(b'')}. """ b = BytesIO( OPTNonStandardAttributes.bytes(excludeName=True) + b"\x07example\x03com\x00" ) h = dns._OPTHeader() h.decode(b) self.assertEqual(h.name, dns.Name(b"")) def test_decodeRdlengthTooShort(self): """ L{dns._OPTHeader.decode} raises an exception if the supplied RDLEN is too short. """ b = BytesIO( OPTNonStandardAttributes.bytes(excludeOptions=True) + ( b"\x00\x05" # RDLEN 5 Too short - should be 6 b"\x00\x01" # OPTION-CODE b"\x00\x02" # OPTION-LENGTH b"\x00\x00" # OPTION-DATA ) ) h = dns._OPTHeader() self.assertRaises(EOFError, h.decode, b) def test_decodeRdlengthTooLong(self): """ L{dns._OPTHeader.decode} raises an exception if the supplied RDLEN is too long. """ b = BytesIO( OPTNonStandardAttributes.bytes(excludeOptions=True) + ( b"\x00\x07" # RDLEN 7 Too long - should be 6 b"\x00\x01" # OPTION-CODE b"\x00\x02" # OPTION-LENGTH b"\x00\x00" # OPTION-DATA ) ) h = dns._OPTHeader() self.assertRaises(EOFError, h.decode, b) def test_decodeWithOptions(self): """ If the OPT bytes contain variable options, L{dns._OPTHeader.decode} will populate a list L{dns._OPTHeader.options} with L{dns._OPTVariableOption} instances. """ b = BytesIO( OPTNonStandardAttributes.bytes(excludeOptions=True) + ( b"\x00\x14" # RDLEN 20 b"\x00\x01" # OPTION-CODE b"\x00\x09" # OPTION-LENGTH b"foobarbaz" # OPTION-DATA b"\x00\x02" # OPTION-CODE b"\x00\x03" # OPTION-LENGTH b"qux" # OPTION-DATA ) ) h = dns._OPTHeader() h.decode(b) self.assertEqual( h.options, [ dns._OPTVariableOption(1, b"foobarbaz"), dns._OPTVariableOption(2, b"qux"), ], ) def test_fromRRHeader(self): """ L{_OPTHeader.fromRRHeader} accepts an L{RRHeader} instance and returns an L{_OPTHeader} instance whose attribute values have been derived from the C{cls}, C{ttl} and C{payload} attributes of the original header. """ genericHeader = dns.RRHeader( b"example.com", type=dns.OPT, cls=0xFFFF, ttl=(0xFE << 24 | 0xFD << 16 | True << 15), payload=dns.UnknownRecord(b"\xff\xff\x00\x03abc"), ) decodedOptHeader = dns._OPTHeader.fromRRHeader(genericHeader) expectedOptHeader = dns._OPTHeader( udpPayloadSize=0xFFFF, extendedRCODE=0xFE, version=0xFD, dnssecOK=True, options=[dns._OPTVariableOption(code=0xFFFF, data=b"abc")], ) self.assertEqual(decodedOptHeader, expectedOptHeader) def test_repr(self): """ L{dns._OPTHeader.__repr__} displays the name and type and all the fixed and extended header values of the OPT record. """ self.assertEqual( repr(dns._OPTHeader()), "<_OPTHeader " "name= " "type=41 " "udpPayloadSize=4096 " "extendedRCODE=0 " "version=0 " "dnssecOK=False " "options=[]>", ) def test_equalityUdpPayloadSize(self): """ Two L{OPTHeader} instances compare equal if they have the same udpPayloadSize. """ self.assertNormalEqualityImplementation( dns._OPTHeader(udpPayloadSize=512), dns._OPTHeader(udpPayloadSize=512), dns._OPTHeader(udpPayloadSize=4096), ) def test_equalityExtendedRCODE(self): """ Two L{OPTHeader} instances compare equal if they have the same extendedRCODE. """ self.assertNormalEqualityImplementation( dns._OPTHeader(extendedRCODE=1), dns._OPTHeader(extendedRCODE=1), dns._OPTHeader(extendedRCODE=2), ) def test_equalityVersion(self): """ Two L{OPTHeader} instances compare equal if they have the same version. """ self.assertNormalEqualityImplementation( dns._OPTHeader(version=1), dns._OPTHeader(version=1), dns._OPTHeader(version=2), ) def test_equalityDnssecOK(self): """ Two L{OPTHeader} instances compare equal if they have the same dnssecOK flags. """ self.assertNormalEqualityImplementation( dns._OPTHeader(dnssecOK=True), dns._OPTHeader(dnssecOK=True), dns._OPTHeader(dnssecOK=False), ) def test_equalityOptions(self): """ Two L{OPTHeader} instances compare equal if they have the same options. """ self.assertNormalEqualityImplementation( dns._OPTHeader(options=[dns._OPTVariableOption(1, b"x")]), dns._OPTHeader(options=[dns._OPTVariableOption(1, b"x")]), dns._OPTHeader(options=[dns._OPTVariableOption(2, b"y")]), ) class OPTVariableOptionTests(ComparisonTestsMixin, unittest.TestCase): """ Tests for L{dns._OPTVariableOption}. """ def test_interface(self): """ L{dns._OPTVariableOption} implements L{dns.IEncodable}. """ verifyClass(dns.IEncodable, dns._OPTVariableOption) def test_constructorArguments(self): """ L{dns._OPTVariableOption.__init__} requires code and data arguments which are saved as public instance attributes. """ h = dns._OPTVariableOption(1, b"x") self.assertEqual(h.code, 1) self.assertEqual(h.data, b"x") def test_repr(self): """ L{dns._OPTVariableOption.__repr__} displays the code and data of the option. """ self.assertEqual( repr(dns._OPTVariableOption(1, b"x")), "<_OPTVariableOption " "code=1 " "data=x" ">", ) def test_equality(self): """ Two OPTVariableOption instances compare equal if they have the same code and data values. """ self.assertNormalEqualityImplementation( dns._OPTVariableOption(1, b"x"), dns._OPTVariableOption(1, b"x"), dns._OPTVariableOption(2, b"x"), ) self.assertNormalEqualityImplementation( dns._OPTVariableOption(1, b"x"), dns._OPTVariableOption(1, b"x"), dns._OPTVariableOption(1, b"y"), ) def test_encode(self): """ L{dns._OPTVariableOption.encode} encodes the code and data instance attributes to a byte string which also includes the data length. """ o = dns._OPTVariableOption(1, b"foobar") b = BytesIO() o.encode(b) self.assertEqual( b.getvalue(), b"\x00\x01" # OPTION-CODE 1 b"\x00\x06" # OPTION-LENGTH 6 b"foobar", # OPTION-DATA ) def test_decode(self): """ L{dns._OPTVariableOption.decode} is a classmethod that decodes a byte string and returns a L{dns._OPTVariableOption} instance. """ b = BytesIO( b"\x00\x01" # OPTION-CODE 1 b"\x00\x06" # OPTION-LENGTH 6 b"foobar" # OPTION-DATA ) o = dns._OPTVariableOption() o.decode(b) self.assertEqual(o.code, 1) self.assertEqual(o.data, b"foobar") class RaisedArgs(Exception): """ An exception which can be raised by fakes to test that the fake is called with expected arguments. """ def __init__(self, args, kwargs): """ Store the positional and keyword arguments as attributes. @param args: The positional args. @param kwargs: The keyword args. """ self.args = args self.kwargs = kwargs class MessageEmpty: """ Generate byte string and constructor arguments for an empty L{dns._EDNSMessage}. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # id: 256 b"\x97" # QR: 1, OPCODE: 2, AA: 0, TC: 0, RD: 1 b"\x8f" # RA: 1, Z, RCODE: 15 b"\x00\x00" # number of queries b"\x00\x00" # number of answers b"\x00\x00" # number of authorities b"\x00\x00" # number of additionals ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, answer=True, opCode=dns.OP_STATUS, auth=True, trunc=True, recDes=True, recAv=True, rCode=15, ednsVersion=None, ) class MessageTruncated: """ An empty response message whose TR bit is set to 1. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID: 256 b"\x82" # QR: 1, OPCODE: 0, AA: 0, TC: 1, RD: 0 b"\x00" # RA: 0, Z, RCODE: 0 b"\x00\x00" # Number of queries b"\x00\x00" # Number of answers b"\x00\x00" # Number of authorities b"\x00\x00" # Number of additionals ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, answer=1, opCode=0, auth=0, trunc=1, recDes=0, recAv=0, rCode=0, ednsVersion=None, ) class MessageNonAuthoritative: """ A minimal non-authoritative message. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID 256 b"\x00" # QR: 0, OPCODE: 0, AA: 0, TC: 0, RD: 0 b"\x00" # RA: 0, Z, RCODE: 0 b"\x00\x00" # Query count b"\x00\x01" # Answer count b"\x00\x00" # Authorities count b"\x00\x00" # Additionals count # Answer b"\x00" # RR NAME (root) b"\x00\x01" # RR TYPE 1 (A) b"\x00\x01" # RR CLASS 1 (IN) b"\x00\x00\x00\x00" # RR TTL b"\x00\x04" # RDLENGTH 4 b"\x01\x02\x03\x04" # IPv4 1.2.3.4 ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, auth=0, ednsVersion=None, answers=[ dns.RRHeader(b"", payload=dns.Record_A("1.2.3.4", ttl=0), auth=False) ], ) class MessageAuthoritative: """ A minimal authoritative message. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID: 256 b"\x04" # QR: 0, OPCODE: 0, AA: 1, TC: 0, RD: 0 b"\x00" # RA: 0, Z, RCODE: 0 b"\x00\x00" # Query count b"\x00\x01" # Answer count b"\x00\x00" # Authorities count b"\x00\x00" # Additionals count # Answer b"\x00" # RR NAME (root) b"\x00\x01" # RR TYPE 1 (A) b"\x00\x01" # RR CLASS 1 (IN) b"\x00\x00\x00\x00" # RR TTL b"\x00\x04" # RDLENGTH 4 b"\x01\x02\x03\x04" # IPv4 1.2.3.4 ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, auth=1, ednsVersion=None, answers=[ dns.RRHeader(b"", payload=dns.Record_A("1.2.3.4", ttl=0), auth=True) ], ) class MessageComplete: """ An example of a fully populated non-edns response message. Contains name compression, answers, authority, and additional records. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID: 256 b"\x95" # QR: 1, OPCODE: 2, AA: 1, TC: 0, RD: 1 b"\x8f" # RA: 1, Z, RCODE: 15 b"\x00\x01" # Query count b"\x00\x01" # Answer count b"\x00\x01" # Authorities count b"\x00\x01" # Additionals count # Query begins at Byte 12 b"\x07example\x03com\x00" # QNAME b"\x00\x06" # QTYPE 6 (SOA) b"\x00\x01" # QCLASS 1 (IN) # Answers b"\xc0\x0c" # RR NAME (compression ref b12) b"\x00\x06" # RR TYPE 6 (SOA) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x27" # RDLENGTH 39 b"\x03ns1\xc0\x0c" # Mname (ns1.example.com (compression ref b15) b"\x0ahostmaster\xc0\x0c" # rname (hostmaster.example.com) b"\xff\xff\xff\xfe" # Serial b"\x7f\xff\xff\xfd" # Refresh b"\x7f\xff\xff\xfc" # Retry b"\x7f\xff\xff\xfb" # Expire b"\xff\xff\xff\xfa" # Minimum # Authority b"\xc0\x0c" # RR NAME (example.com compression ref b12) b"\x00\x02" # RR TYPE 2 (NS) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x02" # RDLENGTH b"\xc0\x29" # RDATA (ns1.example.com (compression ref b41) # Additional b"\xc0\x29" # RR NAME (ns1.example.com compression ref b41) b"\x00\x01" # RR TYPE 1 (A) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x04" # RDLENGTH b"\x05\x06\x07\x08" # RDATA 5.6.7.8 ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, answer=1, opCode=dns.OP_STATUS, auth=1, recDes=1, recAv=1, rCode=15, ednsVersion=None, queries=[dns.Query(b"example.com", dns.SOA)], answers=[ dns.RRHeader( b"example.com", type=dns.SOA, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_SOA( ttl=0xFFFFFFFF, mname=b"ns1.example.com", rname=b"hostmaster.example.com", serial=0xFFFFFFFE, refresh=0x7FFFFFFD, retry=0x7FFFFFFC, expire=0x7FFFFFFB, minimum=0xFFFFFFFA, ), ) ], authority=[ dns.RRHeader( b"example.com", type=dns.NS, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_NS("ns1.example.com", ttl=0xFFFFFFFF), ) ], additional=[ dns.RRHeader( b"ns1.example.com", type=dns.A, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_A("5.6.7.8", ttl=0xFFFFFFFF), ) ], ) class MessageEDNSQuery: """ A minimal EDNS query message. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x00\x00" # ID: 0 b"\x00" # QR: 0, OPCODE: 0, AA: 0, TC: 0, RD: 0 b"\x00" # RA: 0, Z, RCODE: 0 b"\x00\x01" # Queries count b"\x00\x00" # Anwers count b"\x00\x00" # Authority count b"\x00\x01" # Additionals count # Queries b"\x03www\x07example\x03com\x00" # QNAME b"\x00\x01" # QTYPE (A) b"\x00\x01" # QCLASS (IN) # Additional OPT record b"\x00" # NAME (.) b"\x00\x29" # TYPE (OPT 41) b"\x10\x00" # UDP Payload Size (4096) b"\x00" # Extended RCODE b"\x03" # EDNS version b"\x00\x00" # DO: False + Z b"\x00\x00" # RDLENGTH ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=0, answer=0, opCode=dns.OP_QUERY, auth=0, recDes=0, recAv=0, rCode=0, ednsVersion=3, dnssecOK=False, queries=[dns.Query(b"www.example.com", dns.A)], additional=[], ) class MessageEDNSComplete: """ An example of a fully populated edns response message. Contains name compression, answers, authority, and additional records. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID: 256 b"\x95" # QR: 1, OPCODE: 2, AA: 1, TC: 0, RD: 1 b"\xbf" # RA: 1, AD: 1, RCODE: 15 b"\x00\x01" # Query count b"\x00\x01" # Answer count b"\x00\x01" # Authorities count b"\x00\x02" # Additionals count # Query begins at Byte 12 b"\x07example\x03com\x00" # QNAME b"\x00\x06" # QTYPE 6 (SOA) b"\x00\x01" # QCLASS 1 (IN) # Answers b"\xc0\x0c" # RR NAME (compression ref b12) b"\x00\x06" # RR TYPE 6 (SOA) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x27" # RDLENGTH 39 b"\x03ns1\xc0\x0c" # mname (ns1.example.com (compression ref b15) b"\x0ahostmaster\xc0\x0c" # rname (hostmaster.example.com) b"\xff\xff\xff\xfe" # Serial b"\x7f\xff\xff\xfd" # Refresh b"\x7f\xff\xff\xfc" # Retry b"\x7f\xff\xff\xfb" # Expire b"\xff\xff\xff\xfa" # Minimum # Authority b"\xc0\x0c" # RR NAME (example.com compression ref b12) b"\x00\x02" # RR TYPE 2 (NS) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x02" # RDLENGTH b"\xc0\x29" # RDATA (ns1.example.com (compression ref b41) # Additional b"\xc0\x29" # RR NAME (ns1.example.com compression ref b41) b"\x00\x01" # RR TYPE 1 (A) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x04" # RDLENGTH b"\x05\x06\x07\x08" # RDATA 5.6.7.8 # Additional OPT record b"\x00" # NAME (.) b"\x00\x29" # TYPE (OPT 41) b"\x04\x00" # UDP Payload Size (1024) b"\x00" # Extended RCODE b"\x03" # EDNS version b"\x80\x00" # DO: True + Z b"\x00\x00" # RDLENGTH ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, answer=1, opCode=dns.OP_STATUS, auth=1, trunc=0, recDes=1, recAv=1, rCode=15, ednsVersion=3, dnssecOK=True, authenticData=True, checkingDisabled=True, maxSize=1024, queries=[dns.Query(b"example.com", dns.SOA)], answers=[ dns.RRHeader( b"example.com", type=dns.SOA, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_SOA( ttl=0xFFFFFFFF, mname=b"ns1.example.com", rname=b"hostmaster.example.com", serial=0xFFFFFFFE, refresh=0x7FFFFFFD, retry=0x7FFFFFFC, expire=0x7FFFFFFB, minimum=0xFFFFFFFA, ), ) ], authority=[ dns.RRHeader( b"example.com", type=dns.NS, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_NS("ns1.example.com", ttl=0xFFFFFFFF), ) ], additional=[ dns.RRHeader( b"ns1.example.com", type=dns.A, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_A("5.6.7.8", ttl=0xFFFFFFFF), ) ], ) class MessageEDNSExtendedRCODE: """ An example of an EDNS message with an extended RCODE. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x00\x00" b"\x00" b"\x0c" # RA: 0, Z, RCODE: 12 b"\x00\x00" b"\x00\x00" b"\x00\x00" b"\x00\x01" # 1 additionals # Additional OPT record b"\x00" b"\x00\x29" b"\x10\x00" b"\xab" # Extended RCODE: 171 b"\x00" b"\x00\x00" b"\x00\x00" ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=0, answer=False, opCode=dns.OP_QUERY, auth=False, trunc=False, recDes=False, recAv=False, rCode=0xABC, # Combined OPT extended RCODE + Message RCODE ednsVersion=0, dnssecOK=False, maxSize=4096, queries=[], answers=[], authority=[], additional=[], ) class MessageComparable(FancyEqMixin, FancyStrMixin): """ A wrapper around L{dns.Message} which is comparable so that it can be tested using some of the L{dns._EDNSMessage} tests. """ showAttributes = compareAttributes = ( "id", "answer", "opCode", "auth", "trunc", "recDes", "recAv", "rCode", "queries", "answers", "authority", "additional", ) def __init__(self, original): self.original = original def __getattr__(self, key): return getattr(self.original, key) def verifyConstructorArgument( testCase, cls, argName, defaultVal, altVal, attrName=None ): """ Verify that an attribute has the expected default value and that a corresponding argument passed to a constructor is assigned to that attribute. @param testCase: The L{TestCase} whose assert methods will be called. @type testCase: L{unittest.TestCase} @param cls: The constructor under test. @type cls: L{type} @param argName: The name of the constructor argument under test. @type argName: L{str} @param defaultVal: The expected default value of C{attrName} / C{argName} @type defaultVal: L{object} @param altVal: A value which is different from the default. Used to test that supplied constructor arguments are actually assigned to the correct attribute. @type altVal: L{object} @param attrName: The name of the attribute under test if different from C{argName}. Defaults to C{argName} @type attrName: L{str} """ if attrName is None: attrName = argName actual = {} expected = {"defaultVal": defaultVal, "altVal": altVal} o = cls() actual["defaultVal"] = getattr(o, attrName) o = cls(**{argName: altVal}) actual["altVal"] = getattr(o, attrName) testCase.assertEqual(expected, actual) class ConstructorTestsMixin: """ Helper methods for verifying default attribute values and corresponding constructor arguments. """ def _verifyConstructorArgument(self, argName, defaultVal, altVal): """ Wrap L{verifyConstructorArgument} to provide simpler interface for testing Message and _EDNSMessage constructor arguments. @param argName: The name of the constructor argument. @param defaultVal: The expected default value. @param altVal: An alternative value which is expected to be assigned to a correspondingly named attribute. """ verifyConstructorArgument( testCase=self, cls=self.messageFactory, argName=argName, defaultVal=defaultVal, altVal=altVal, ) def _verifyConstructorFlag(self, argName, defaultVal): """ Wrap L{verifyConstructorArgument} to provide simpler interface for testing _EDNSMessage constructor flags. @param argName: The name of the constructor flag argument @param defaultVal: The expected default value of the flag """ assert defaultVal in (True, False) verifyConstructorArgument( testCase=self, cls=self.messageFactory, argName=argName, defaultVal=defaultVal, altVal=not defaultVal, ) class CommonConstructorTestsMixin: """ Tests for constructor arguments and their associated attributes that are common to both L{twisted.names.dns._EDNSMessage} and L{dns.Message}. TestCase classes that use this mixin must provide a C{messageFactory} method which accepts any argment supported by L{dns.Message.__init__}. TestCases must also mixin ConstructorTestsMixin which provides some custom assertions for testing constructor arguments. """ def test_id(self): """ L{dns._EDNSMessage.id} defaults to C{0} and can be overridden in the constructor. """ self._verifyConstructorArgument("id", defaultVal=0, altVal=1) def test_answer(self): """ L{dns._EDNSMessage.answer} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("answer", defaultVal=False) def test_opCode(self): """ L{dns._EDNSMessage.opCode} defaults to L{dns.OP_QUERY} and can be overridden in the constructor. """ self._verifyConstructorArgument( "opCode", defaultVal=dns.OP_QUERY, altVal=dns.OP_STATUS ) def test_auth(self): """ L{dns._EDNSMessage.auth} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("auth", defaultVal=False) def test_trunc(self): """ L{dns._EDNSMessage.trunc} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("trunc", defaultVal=False) def test_recDes(self): """ L{dns._EDNSMessage.recDes} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("recDes", defaultVal=False) def test_recAv(self): """ L{dns._EDNSMessage.recAv} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("recAv", defaultVal=False) def test_rCode(self): """ L{dns._EDNSMessage.rCode} defaults to C{0} and can be overridden in the constructor. """ self._verifyConstructorArgument("rCode", defaultVal=0, altVal=123) def test_maxSize(self): """ L{dns._EDNSMessage.maxSize} defaults to C{512} and can be overridden in the constructor. """ self._verifyConstructorArgument("maxSize", defaultVal=512, altVal=1024) def test_queries(self): """ L{dns._EDNSMessage.queries} defaults to C{[]}. """ self.assertEqual(self.messageFactory().queries, []) def test_answers(self): """ L{dns._EDNSMessage.answers} defaults to C{[]}. """ self.assertEqual(self.messageFactory().answers, []) def test_authority(self): """ L{dns._EDNSMessage.authority} defaults to C{[]}. """ self.assertEqual(self.messageFactory().authority, []) def test_additional(self): """ L{dns._EDNSMessage.additional} defaults to C{[]}. """ self.assertEqual(self.messageFactory().additional, []) class EDNSMessageConstructorTests( ConstructorTestsMixin, CommonConstructorTestsMixin, unittest.SynchronousTestCase ): """ Tests for L{twisted.names.dns._EDNSMessage} constructor arguments that are shared with L{dns.Message}. """ messageFactory = dns._EDNSMessage class MessageConstructorTests( ConstructorTestsMixin, CommonConstructorTestsMixin, unittest.SynchronousTestCase ): """ Tests for L{twisted.names.dns.Message} constructor arguments that are shared with L{dns._EDNSMessage}. """ messageFactory = dns.Message class EDNSMessageSpecificsTests(ConstructorTestsMixin, unittest.SynchronousTestCase): """ Tests for L{dns._EDNSMessage}. These tests are for L{dns._EDNSMessage} APIs which are not shared with L{dns.Message}. """ messageFactory = dns._EDNSMessage def test_ednsVersion(self): """ L{dns._EDNSMessage.ednsVersion} defaults to C{0} and can be overridden in the constructor. """ self._verifyConstructorArgument("ednsVersion", defaultVal=0, altVal=None) def test_dnssecOK(self): """ L{dns._EDNSMessage.dnssecOK} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("dnssecOK", defaultVal=False) def test_authenticData(self): """ L{dns._EDNSMessage.authenticData} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("authenticData", defaultVal=False) def test_checkingDisabled(self): """ L{dns._EDNSMessage.checkingDisabled} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("checkingDisabled", defaultVal=False) def test_queriesOverride(self): """ L{dns._EDNSMessage.queries} can be overridden in the constructor. """ msg = self.messageFactory(queries=[dns.Query(b"example.com")]) self.assertEqual(msg.queries, [dns.Query(b"example.com")]) def test_answersOverride(self): """ L{dns._EDNSMessage.answers} can be overridden in the constructor. """ msg = self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ) self.assertEqual( msg.answers, [dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ) def test_authorityOverride(self): """ L{dns._EDNSMessage.authority} can be overridden in the constructor. """ msg = self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ) self.assertEqual( msg.authority, [dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA())], ) def test_additionalOverride(self): """ L{dns._EDNSMessage.authority} can be overridden in the constructor. """ msg = self.messageFactory( additional=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ) self.assertEqual( msg.additional, [dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))], ) def test_reprDefaults(self): """ L{dns._EDNSMessage.__repr__} omits field values and sections which are identical to their defaults. The id field value is always shown. """ self.assertEqual("<_EDNSMessage id=0>", repr(self.messageFactory())) def test_reprFlagsIfSet(self): """ L{dns._EDNSMessage.__repr__} displays flags if they are L{True}. """ m = self.messageFactory( answer=True, auth=True, trunc=True, recDes=True, recAv=True, authenticData=True, checkingDisabled=True, dnssecOK=True, ) self.assertEqual( "<_EDNSMessage " "id=0 " "flags=answer,auth,trunc,recDes,recAv,authenticData," "checkingDisabled,dnssecOK" ">", repr(m), ) def test_reprNonDefautFields(self): """ L{dns._EDNSMessage.__repr__} displays field values if they differ from their defaults. """ m = self.messageFactory(id=10, opCode=20, rCode=30, maxSize=40, ednsVersion=50) self.assertEqual( "<_EDNSMessage " "id=10 " "opCode=20 " "rCode=30 " "maxSize=40 " "ednsVersion=50" ">", repr(m), ) def test_reprNonDefaultSections(self): """ L{dns.Message.__repr__} displays sections which differ from their defaults. """ m = self.messageFactory() m.queries = [1, 2, 3] m.answers = [4, 5, 6] m.authority = [7, 8, 9] m.additional = [10, 11, 12] self.assertEqual( "<_EDNSMessage " "id=0 " "queries=[1, 2, 3] " "answers=[4, 5, 6] " "authority=[7, 8, 9] " "additional=[10, 11, 12]" ">", repr(m), ) def test_fromStrCallsMessageFactory(self): """ L{dns._EDNSMessage.fromString} calls L{dns._EDNSMessage._messageFactory} to create a new L{dns.Message} instance which is used to decode the supplied bytes. """ class FakeMessageFactory: """ Fake message factory. """ def fromStr(self, *args, **kwargs): """ Fake fromStr method which raises the arguments it was passed. @param args: positional arguments @param kwargs: keyword arguments """ raise RaisedArgs(args, kwargs) m = dns._EDNSMessage() m._messageFactory = FakeMessageFactory dummyBytes = object() e = self.assertRaises(RaisedArgs, m.fromStr, dummyBytes) self.assertEqual(((dummyBytes,), {}), (e.args, e.kwargs)) def test_fromStrCallsFromMessage(self): """ L{dns._EDNSMessage.fromString} calls L{dns._EDNSMessage._fromMessage} with a L{dns.Message} instance """ m = dns._EDNSMessage() class FakeMessageFactory: """ Fake message factory. """ def fromStr(self, bytes): """ A noop fake version of fromStr @param bytes: the bytes to be decoded """ fakeMessage = FakeMessageFactory() m._messageFactory = lambda: fakeMessage def fakeFromMessage(*args, **kwargs): raise RaisedArgs(args, kwargs) m._fromMessage = fakeFromMessage e = self.assertRaises(RaisedArgs, m.fromStr, b"") self.assertEqual(((fakeMessage,), {}), (e.args, e.kwargs)) def test_toStrCallsToMessage(self): """ L{dns._EDNSMessage.toStr} calls L{dns._EDNSMessage._toMessage} """ m = dns._EDNSMessage() def fakeToMessage(*args, **kwargs): raise RaisedArgs(args, kwargs) m._toMessage = fakeToMessage e = self.assertRaises(RaisedArgs, m.toStr) self.assertEqual(((), {}), (e.args, e.kwargs)) def test_toStrCallsToMessageToStr(self): """ L{dns._EDNSMessage.toStr} calls C{toStr} on the message returned by L{dns._EDNSMessage._toMessage}. """ m = dns._EDNSMessage() dummyBytes = object() class FakeMessage: """ Fake Message """ def toStr(self): """ Fake toStr which returns dummyBytes. @return: dummyBytes """ return dummyBytes def fakeToMessage(*args, **kwargs): return FakeMessage() m._toMessage = fakeToMessage self.assertEqual(dummyBytes, m.toStr()) class EDNSMessageEqualityTests(ComparisonTestsMixin, unittest.SynchronousTestCase): """ Tests for equality between L{dns._EDNSMessage} instances. These tests will not work with L{dns.Message} because it does not use L{twisted.python.util.FancyEqMixin}. """ messageFactory = dns._EDNSMessage def test_id(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same id. """ self.assertNormalEqualityImplementation( self.messageFactory(id=1), self.messageFactory(id=1), self.messageFactory(id=2), ) def test_answer(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same answer flag. """ self.assertNormalEqualityImplementation( self.messageFactory(answer=True), self.messageFactory(answer=True), self.messageFactory(answer=False), ) def test_opCode(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same opCode. """ self.assertNormalEqualityImplementation( self.messageFactory(opCode=dns.OP_STATUS), self.messageFactory(opCode=dns.OP_STATUS), self.messageFactory(opCode=dns.OP_INVERSE), ) def test_auth(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same auth flag. """ self.assertNormalEqualityImplementation( self.messageFactory(auth=True), self.messageFactory(auth=True), self.messageFactory(auth=False), ) def test_trunc(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same trunc flag. """ self.assertNormalEqualityImplementation( self.messageFactory(trunc=True), self.messageFactory(trunc=True), self.messageFactory(trunc=False), ) def test_recDes(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same recDes flag. """ self.assertNormalEqualityImplementation( self.messageFactory(recDes=True), self.messageFactory(recDes=True), self.messageFactory(recDes=False), ) def test_recAv(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same recAv flag. """ self.assertNormalEqualityImplementation( self.messageFactory(recAv=True), self.messageFactory(recAv=True), self.messageFactory(recAv=False), ) def test_rCode(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same rCode. """ self.assertNormalEqualityImplementation( self.messageFactory(rCode=16), self.messageFactory(rCode=16), self.messageFactory(rCode=15), ) def test_ednsVersion(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same ednsVersion. """ self.assertNormalEqualityImplementation( self.messageFactory(ednsVersion=1), self.messageFactory(ednsVersion=1), self.messageFactory(ednsVersion=None), ) def test_dnssecOK(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same dnssecOK. """ self.assertNormalEqualityImplementation( self.messageFactory(dnssecOK=True), self.messageFactory(dnssecOK=True), self.messageFactory(dnssecOK=False), ) def test_authenticData(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same authenticData flags. """ self.assertNormalEqualityImplementation( self.messageFactory(authenticData=True), self.messageFactory(authenticData=True), self.messageFactory(authenticData=False), ) def test_checkingDisabled(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same checkingDisabled flags. """ self.assertNormalEqualityImplementation( self.messageFactory(checkingDisabled=True), self.messageFactory(checkingDisabled=True), self.messageFactory(checkingDisabled=False), ) def test_maxSize(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same maxSize. """ self.assertNormalEqualityImplementation( self.messageFactory(maxSize=2048), self.messageFactory(maxSize=2048), self.messageFactory(maxSize=1024), ) def test_queries(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same queries. """ self.assertNormalEqualityImplementation( self.messageFactory(queries=[dns.Query(b"example.com")]), self.messageFactory(queries=[dns.Query(b"example.com")]), self.messageFactory(queries=[dns.Query(b"example.org")]), ) def test_answers(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same answers. """ self.assertNormalEqualityImplementation( self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ), self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ), self.messageFactory( answers=[dns.RRHeader(b"example.org", payload=dns.Record_A("4.3.2.1"))] ), ) def test_authority(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same authority records. """ self.assertNormalEqualityImplementation( self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ), self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ), self.messageFactory( authority=[ dns.RRHeader(b"example.org", type=dns.SOA, payload=dns.Record_SOA()) ] ), ) def test_additional(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same additional records. """ self.assertNormalEqualityImplementation( self.messageFactory( additional=[ dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")) ] ), self.messageFactory( additional=[ dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")) ] ), self.messageFactory( additional=[ dns.RRHeader(b"example.org", payload=dns.Record_A("1.2.3.4")) ] ), ) class StandardEncodingTestsMixin: """ Tests for the encoding and decoding of various standard (not EDNS) messages. These tests should work with both L{dns._EDNSMessage} and L{dns.Message}. TestCase classes that use this mixin must provide a C{messageFactory} method which accepts any argment supported by L{dns._EDNSMessage.__init__}. EDNS specific arguments may be discarded if not supported by the message class under construction. """ def test_emptyMessageEncode(self): """ An empty message can be encoded. """ self.assertEqual( self.messageFactory(**MessageEmpty.kwargs()).toStr(), MessageEmpty.bytes() ) def test_emptyMessageDecode(self): """ An empty message byte sequence can be decoded. """ m = self.messageFactory() m.fromStr(MessageEmpty.bytes()) self.assertEqual(m, self.messageFactory(**MessageEmpty.kwargs())) def test_completeQueryEncode(self): """ A fully populated query message can be encoded. """ self.assertEqual( self.messageFactory(**MessageComplete.kwargs()).toStr(), MessageComplete.bytes(), ) def test_completeQueryDecode(self): """ A fully populated message byte string can be decoded. """ m = self.messageFactory() m.fromStr(MessageComplete.bytes()), self.assertEqual(m, self.messageFactory(**MessageComplete.kwargs())) def test_NULL(self): """ A I{NULL} record with an arbitrary payload can be encoded and decoded as part of a message. """ bytes = b"".join([dns._ord2bytes(i) for i in range(256)]) rec = dns.Record_NULL(bytes) rr = dns.RRHeader(b"testname", dns.NULL, payload=rec) msg1 = self.messageFactory() msg1.answers.append(rr) s = msg1.toStr() msg2 = self.messageFactory() msg2.fromStr(s) self.assertIsInstance(msg2.answers[0].payload, dns.Record_NULL) self.assertEqual(msg2.answers[0].payload.payload, bytes) def test_nonAuthoritativeMessageEncode(self): """ If the message C{authoritative} attribute is set to 0, the encoded bytes will have AA bit 0. """ self.assertEqual( self.messageFactory(**MessageNonAuthoritative.kwargs()).toStr(), MessageNonAuthoritative.bytes(), ) def test_nonAuthoritativeMessageDecode(self): """ The L{dns.RRHeader} instances created by a message from a non-authoritative message byte string are marked as not authoritative. """ m = self.messageFactory() m.fromStr(MessageNonAuthoritative.bytes()) self.assertEqual(m, self.messageFactory(**MessageNonAuthoritative.kwargs())) def test_authoritativeMessageEncode(self): """ If the message C{authoritative} attribute is set to 1, the encoded bytes will have AA bit 1. """ self.assertEqual( self.messageFactory(**MessageAuthoritative.kwargs()).toStr(), MessageAuthoritative.bytes(), ) def test_authoritativeMessageDecode(self): """ The message and its L{dns.RRHeader} instances created by C{decode} from an authoritative message byte string, are marked as authoritative. """ m = self.messageFactory() m.fromStr(MessageAuthoritative.bytes()) self.assertEqual(m, self.messageFactory(**MessageAuthoritative.kwargs())) def test_truncatedMessageEncode(self): """ If the message C{trunc} attribute is set to 1 the encoded bytes will have TR bit 1. """ self.assertEqual( self.messageFactory(**MessageTruncated.kwargs()).toStr(), MessageTruncated.bytes(), ) def test_truncatedMessageDecode(self): """ The message instance created by decoding a truncated message is marked as truncated. """ m = self.messageFactory() m.fromStr(MessageTruncated.bytes()) self.assertEqual(m, self.messageFactory(**MessageTruncated.kwargs())) class EDNSMessageStandardEncodingTests( StandardEncodingTestsMixin, unittest.SynchronousTestCase ): """ Tests for the encoding and decoding of various standard (non-EDNS) messages by L{dns._EDNSMessage}. """ messageFactory = dns._EDNSMessage class MessageStandardEncodingTests( StandardEncodingTestsMixin, unittest.SynchronousTestCase ): """ Tests for the encoding and decoding of various standard (non-EDNS) messages by L{dns.Message}. """ @staticmethod def messageFactory(**kwargs): """ This function adapts constructor arguments expected by _EDNSMessage.__init__ to arguments suitable for use with the Message.__init__. Also handles the fact that unlike L{dns._EDNSMessage}, L{dns.Message.__init__} does not accept queries, answers etc as arguments. Also removes any L{dns._EDNSMessage} specific arguments. @param args: The positional arguments which will be passed to L{dns.Message.__init__}. @param kwargs: The keyword arguments which will be stripped of EDNS specific arguments before being passed to L{dns.Message.__init__}. @return: An L{dns.Message} instance. """ queries = kwargs.pop("queries", []) answers = kwargs.pop("answers", []) authority = kwargs.pop("authority", []) additional = kwargs.pop("additional", []) kwargs.pop("ednsVersion", None) m = dns.Message(**kwargs) m.queries = queries m.answers = answers m.authority = authority m.additional = additional return MessageComparable(m) class EDNSMessageEDNSEncodingTests(unittest.SynchronousTestCase): """ Tests for the encoding and decoding of various EDNS messages. These test will not work with L{dns.Message}. """ messageFactory = dns._EDNSMessage def test_ednsMessageDecodeStripsOptRecords(self): """ The L(_EDNSMessage} instance created by L{dns._EDNSMessage.decode} from an EDNS query never includes OPT records in the additional section. """ m = self.messageFactory() m.fromStr(MessageEDNSQuery.bytes()) self.assertEqual(m.additional, []) def test_ednsMessageDecodeMultipleOptRecords(self): """ An L(_EDNSMessage} instance created from a byte string containing multiple I{OPT} records will discard all the C{OPT} records. C{ednsVersion} will be set to L{None}. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.1} """ m = dns.Message() m.additional = [dns._OPTHeader(version=2), dns._OPTHeader(version=3)] ednsMessage = dns._EDNSMessage() ednsMessage.fromStr(m.toStr()) self.assertIsNone(ednsMessage.ednsVersion) def test_fromMessageCopiesSections(self): """ L{dns._EDNSMessage._fromMessage} returns an L{_EDNSMessage} instance whose queries, answers, authority and additional lists are copies (not references to) the original message lists. """ standardMessage = dns.Message() standardMessage.fromStr(MessageEDNSQuery.bytes()) ednsMessage = dns._EDNSMessage._fromMessage(standardMessage) duplicates = [] for attrName in ("queries", "answers", "authority", "additional"): if getattr(standardMessage, attrName) is getattr(ednsMessage, attrName): duplicates.append(attrName) if duplicates: self.fail( "Message and _EDNSMessage shared references to the following " "section lists after decoding: %s" % (duplicates,) ) def test_toMessageCopiesSections(self): """ L{dns._EDNSMessage.toStr} makes no in place changes to the message instance. """ ednsMessage = dns._EDNSMessage(ednsVersion=1) ednsMessage.toStr() self.assertEqual(ednsMessage.additional, []) def test_optHeaderPosition(self): """ L{dns._EDNSMessage} can decode OPT records, regardless of their position in the additional records section. "The OPT RR MAY be placed anywhere within the additional data section." @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.1} """ # XXX: We need an _OPTHeader.toRRHeader method. See #6779. b = BytesIO() optRecord = dns._OPTHeader(version=1) optRecord.encode(b) optRRHeader = dns.RRHeader() b.seek(0) optRRHeader.decode(b) m = dns.Message() m.additional = [optRRHeader] actualMessages = [] actualMessages.append(dns._EDNSMessage._fromMessage(m).ednsVersion) m.additional.append(dns.RRHeader(type=dns.A)) actualMessages.append(dns._EDNSMessage._fromMessage(m).ednsVersion) m.additional.insert(0, dns.RRHeader(type=dns.A)) actualMessages.append(dns._EDNSMessage._fromMessage(m).ednsVersion) self.assertEqual([1] * 3, actualMessages) def test_ednsDecode(self): """ The L(_EDNSMessage} instance created by L{dns._EDNSMessage.fromStr} derives its edns specific values (C{ednsVersion}, etc) from the supplied OPT record. """ m = self.messageFactory() m.fromStr(MessageEDNSComplete.bytes()) self.assertEqual(m, self.messageFactory(**MessageEDNSComplete.kwargs())) def test_ednsEncode(self): """ The L(_EDNSMessage} instance created by L{dns._EDNSMessage.toStr} encodes its edns specific values (C{ednsVersion}, etc) into an OPT record added to the additional section. """ self.assertEqual( self.messageFactory(**MessageEDNSComplete.kwargs()).toStr(), MessageEDNSComplete.bytes(), ) def test_extendedRcodeEncode(self): """ The L(_EDNSMessage.toStr} encodes the extended I{RCODE} (>=16) by assigning the lower 4bits to the message RCODE field and the upper 4bits to the OPT pseudo record. """ self.assertEqual( self.messageFactory(**MessageEDNSExtendedRCODE.kwargs()).toStr(), MessageEDNSExtendedRCODE.bytes(), ) def test_extendedRcodeDecode(self): """ The L(_EDNSMessage} instance created by L{dns._EDNSMessage.fromStr} derives RCODE from the supplied OPT record. """ m = self.messageFactory() m.fromStr(MessageEDNSExtendedRCODE.bytes()) self.assertEqual(m, self.messageFactory(**MessageEDNSExtendedRCODE.kwargs())) def test_extendedRcodeZero(self): """ Note that EXTENDED-RCODE value 0 indicates that an unextended RCODE is in use (values 0 through 15). https://tools.ietf.org/html/rfc6891#section-6.1.3 """ ednsMessage = self.messageFactory(rCode=15, ednsVersion=0) standardMessage = ednsMessage._toMessage() self.assertEqual( (15, 0), (standardMessage.rCode, standardMessage.additional[0].extendedRCODE), ) class ResponseFromMessageTests(unittest.SynchronousTestCase): """ Tests for L{dns._responseFromMessage}. """ def test_responseFromMessageResponseType(self): """ L{dns.Message._responseFromMessage} is a constructor function which generates a new I{answer} message from an existing L{dns.Message} like instance. """ request = dns.Message() response = dns._responseFromMessage( responseConstructor=dns.Message, message=request ) self.assertIsNot(request, response) def test_responseType(self): """ L{dns._responseFromMessage} returns a new instance of C{cls} """ class SuppliedClass: id = 1 queries = [] expectedClass = dns.Message self.assertIsInstance( dns._responseFromMessage( responseConstructor=expectedClass, message=SuppliedClass() ), expectedClass, ) def test_responseId(self): """ L{dns._responseFromMessage} copies the C{id} attribute of the original message. """ self.assertEqual( 1234, dns._responseFromMessage( responseConstructor=dns.Message, message=dns.Message(id=1234) ).id, ) def test_responseAnswer(self): """ L{dns._responseFromMessage} sets the C{answer} flag to L{True} """ request = dns.Message() response = dns._responseFromMessage( responseConstructor=dns.Message, message=request ) self.assertEqual((False, True), (request.answer, response.answer)) def test_responseQueries(self): """ L{dns._responseFromMessage} copies the C{queries} attribute of the original message. """ request = dns.Message() expectedQueries = [object(), object(), object()] request.queries = expectedQueries[:] self.assertEqual( expectedQueries, dns._responseFromMessage( responseConstructor=dns.Message, message=request ).queries, ) def test_responseKwargs(self): """ L{dns._responseFromMessage} accepts other C{kwargs} which are assigned to the new message before it is returned. """ self.assertEqual( 123, dns._responseFromMessage( responseConstructor=dns.Message, message=dns.Message(), rCode=123 ).rCode, ) class Foo: """ An example class for use in L{dns._compactRepr} tests. It follows the pattern of initialiser settable flags, fields and sections found in L{dns.Message} and L{dns._EDNSMessage}. """ def __init__( self, field1=1, field2=2, alwaysShowField="AS", flagTrue=True, flagFalse=False, section1=None, ): """ Set some flags, fields and sections as public attributes. """ self.field1 = field1 self.field2 = field2 self.alwaysShowField = alwaysShowField self.flagTrue = flagTrue self.flagFalse = flagFalse if section1 is None: section1 = [] self.section1 = section1 def __repr__(self) -> str: """ Call L{dns._compactRepr} to generate a string representation. """ return cast( str, dns._compactRepr( self, alwaysShow="alwaysShowField".split(), fieldNames="field1 field2 alwaysShowField".split(), flagNames="flagTrue flagFalse".split(), sectionNames="section1 section2".split(), ), ) class CompactReprTests(unittest.SynchronousTestCase): """ Tests for L{dns._compactRepr}. """ messageFactory = Foo def test_defaults(self): """ L{dns._compactRepr} omits field values and sections which have the default value. Flags which are True are always shown. """ self.assertEqual( "<Foo alwaysShowField='AS' flags=flagTrue>", repr(self.messageFactory()) ) def test_flagsIfSet(self): """ L{dns._compactRepr} displays flags if they have a non-default value. """ m = self.messageFactory(flagTrue=True, flagFalse=True) self.assertEqual( "<Foo " "alwaysShowField='AS' " "flags=flagTrue,flagFalse" ">", repr(m), ) def test_nonDefautFields(self): """ L{dns._compactRepr} displays field values if they differ from their defaults. """ m = self.messageFactory(field1=10, field2=20) self.assertEqual( "<Foo " "field1=10 " "field2=20 " "alwaysShowField='AS' " "flags=flagTrue" ">", repr(m), ) def test_nonDefaultSections(self): """ L{dns._compactRepr} displays sections which differ from their defaults. """ m = self.messageFactory() m.section1 = [1, 1, 1] m.section2 = [2, 2, 2] self.assertEqual( "<Foo " "alwaysShowField='AS' " "flags=flagTrue " "section1=[1, 1, 1] " "section2=[2, 2, 2]" ">", repr(m), ) PK y�Z�H�4d 4d test/test_rootresolve.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for Twisted.names' root resolver. """ from zope.interface import implementer from zope.interface.verify import verifyClass from twisted.internet.defer import Deferred, TimeoutError, gatherResults, succeed from twisted.internet.interfaces import IResolverSimple from twisted.names import client, root from twisted.names.dns import ( CNAME, ENAME, HS, IN, NS, OK, A, Message, Name, Query, Record_A, Record_CNAME, Record_NS, RRHeader, ) from twisted.names.error import DNSNameError, ResolverError from twisted.names.root import Resolver from twisted.names.test.test_util import MemoryReactor from twisted.python.log import msg from twisted.trial import util from twisted.trial.unittest import SynchronousTestCase, TestCase def getOnePayload(results): """ From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the payload of the first record in the answer section. """ ans, auth, add = results return ans[0].payload def getOneAddress(results): """ From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the first IPv4 address from the answer section. """ return getOnePayload(results).dottedQuad() class RootResolverTests(TestCase): """ Tests for L{twisted.names.root.Resolver}. """ def _queryTest(self, filter): """ Invoke L{Resolver._query} and verify that it sends the correct DNS query. Deliver a canned response to the query and return whatever the L{Deferred} returned by L{Resolver._query} fires with. @param filter: The value to pass for the C{filter} parameter to L{Resolver._query}. """ reactor = MemoryReactor() resolver = Resolver([], reactor=reactor) d = resolver._query( Query(b"foo.example.com", A, IN), [("1.1.2.3", 1053)], (30,), filter ) # A UDP port should have been started. portNumber, transport = reactor.udpPorts.popitem() # And a DNS packet sent. [(packet, address)] = transport._sentPackets message = Message() message.fromStr(packet) # It should be a query with the parameters used above. self.assertEqual(message.queries, [Query(b"foo.example.com", A, IN)]) self.assertEqual(message.answers, []) self.assertEqual(message.authority, []) self.assertEqual(message.additional, []) response = [] d.addCallback(response.append) self.assertEqual(response, []) # Once a reply is received, the Deferred should fire. del message.queries[:] message.answer = 1 message.answers.append( RRHeader(b"foo.example.com", payload=Record_A("5.8.13.21")) ) transport._protocol.datagramReceived(message.toStr(), ("1.1.2.3", 1053)) return response[0] def test_filteredQuery(self): """ L{Resolver._query} accepts a L{Query} instance and an address, issues the query, and returns a L{Deferred} which fires with the response to the query. If a true value is passed for the C{filter} parameter, the result is a three-tuple of lists of records. """ answer, authority, additional = self._queryTest(True) self.assertEqual( answer, [RRHeader(b"foo.example.com", payload=Record_A("5.8.13.21", ttl=0))] ) self.assertEqual(authority, []) self.assertEqual(additional, []) def test_unfilteredQuery(self): """ Similar to L{test_filteredQuery}, but for the case where a false value is passed for the C{filter} parameter. In this case, the result is a L{Message} instance. """ message = self._queryTest(False) self.assertIsInstance(message, Message) self.assertEqual(message.queries, []) self.assertEqual( message.answers, [RRHeader(b"foo.example.com", payload=Record_A("5.8.13.21", ttl=0))], ) self.assertEqual(message.authority, []) self.assertEqual(message.additional, []) def _respond(self, answers=[], authority=[], additional=[], rCode=OK): """ Create a L{Message} suitable for use as a response to a query. @param answers: A C{list} of two-tuples giving data for the answers section of the message. The first element of each tuple is a name for the L{RRHeader}. The second element is the payload. @param authority: A C{list} like C{answers}, but for the authority section of the response. @param additional: A C{list} like C{answers}, but for the additional section of the response. @param rCode: The response code the message will be created with. @return: A new L{Message} initialized with the given values. """ response = Message(rCode=rCode) for (section, data) in [ (response.answers, answers), (response.authority, authority), (response.additional, additional), ]: section.extend( [ RRHeader( name, record.TYPE, getattr(record, "CLASS", IN), payload=record ) for (name, record) in data ] ) return response def _getResolver(self, serverResponses, maximumQueries=10): """ Create and return a new L{root.Resolver} modified to resolve queries against the record data represented by C{servers}. @param serverResponses: A mapping from dns server addresses to mappings. The inner mappings are from query two-tuples (name, type) to dictionaries suitable for use as **arguments to L{_respond}. See that method for details. """ roots = ["1.1.2.3"] resolver = Resolver(roots, maximumQueries) def query(query, serverAddresses, timeout, filter): msg(f"Query for QNAME {query.name} at {serverAddresses!r}") for addr in serverAddresses: try: server = serverResponses[addr] except KeyError: continue records = server[query.name.name, query.type] return succeed(self._respond(**records)) resolver._query = query return resolver def test_lookupAddress(self): """ L{root.Resolver.lookupAddress} looks up the I{A} records for the specified hostname by first querying one of the root servers the resolver was created with and then following the authority delegations until a result is received. """ servers = { ("1.1.2.3", 53): { (b"foo.example.com", A): { "authority": [(b"foo.example.com", Record_NS(b"ns1.example.com"))], "additional": [(b"ns1.example.com", Record_A("34.55.89.144"))], }, }, ("34.55.89.144", 53): { (b"foo.example.com", A): { "answers": [(b"foo.example.com", Record_A("10.0.0.1"))], } }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"foo.example.com") d.addCallback(getOneAddress) d.addCallback(self.assertEqual, "10.0.0.1") return d def test_lookupChecksClass(self): """ If a response includes a record with a class different from the one in the query, it is ignored and lookup continues until a record with the right class is found. """ badClass = Record_A("10.0.0.1") badClass.CLASS = HS servers = { ("1.1.2.3", 53): { (b"foo.example.com", A): { "answers": [(b"foo.example.com", badClass)], "authority": [(b"foo.example.com", Record_NS(b"ns1.example.com"))], "additional": [(b"ns1.example.com", Record_A("10.0.0.2"))], }, }, ("10.0.0.2", 53): { (b"foo.example.com", A): { "answers": [(b"foo.example.com", Record_A("10.0.0.3"))], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"foo.example.com") d.addCallback(getOnePayload) d.addCallback(self.assertEqual, Record_A("10.0.0.3")) return d def test_missingGlue(self): """ If an intermediate response includes no glue records for the authorities, separate queries are made to find those addresses. """ servers = { ("1.1.2.3", 53): { (b"foo.example.com", A): { "authority": [(b"foo.example.com", Record_NS(b"ns1.example.org"))], # Conspicuous lack of an additional section naming ns1.example.com }, (b"ns1.example.org", A): { "answers": [(b"ns1.example.org", Record_A("10.0.0.1"))], }, }, ("10.0.0.1", 53): { (b"foo.example.com", A): { "answers": [(b"foo.example.com", Record_A("10.0.0.2"))], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"foo.example.com") d.addCallback(getOneAddress) d.addCallback(self.assertEqual, "10.0.0.2") return d def test_missingName(self): """ If a name is missing, L{Resolver.lookupAddress} returns a L{Deferred} which fails with L{DNSNameError}. """ servers = { ("1.1.2.3", 53): { (b"foo.example.com", A): { "rCode": ENAME, }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"foo.example.com") return self.assertFailure(d, DNSNameError) def test_answerless(self): """ If a query is responded to with no answers or nameserver records, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): {}, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") return self.assertFailure(d, ResolverError) def test_delegationLookupError(self): """ If there is an error resolving the nameserver in a delegation response, the L{Deferred} returned by L{Resolver.lookupAddress} fires with that error. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "authority": [(b"example.com", Record_NS(b"ns1.example.com"))], }, (b"ns1.example.com", A): { "rCode": ENAME, }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") return self.assertFailure(d, DNSNameError) def test_delegationLookupEmpty(self): """ If there are no records in the response to a lookup of a delegation nameserver, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "authority": [(b"example.com", Record_NS(b"ns1.example.com"))], }, (b"ns1.example.com", A): {}, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") return self.assertFailure(d, ResolverError) def test_lookupNameservers(self): """ L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except it queries for I{NS} records instead of I{A} records. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "rCode": ENAME, }, (b"example.com", NS): { "answers": [(b"example.com", Record_NS(b"ns1.example.com"))], }, }, } resolver = self._getResolver(servers) d = resolver.lookupNameservers(b"example.com") def getOneName(results): ans, auth, add = results return ans[0].payload.name d.addCallback(getOneName) d.addCallback(self.assertEqual, Name(b"ns1.example.com")) return d def test_returnCanonicalName(self): """ If a I{CNAME} record is encountered as the answer to a query for another record type, that record is returned as the answer. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "answers": [ (b"example.com", Record_CNAME(b"example.net")), (b"example.net", Record_A("10.0.0.7")), ], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") d.addCallback(lambda results: results[0]) # Get the answer section d.addCallback( self.assertEqual, [ RRHeader(b"example.com", CNAME, payload=Record_CNAME(b"example.net")), RRHeader(b"example.net", A, payload=Record_A("10.0.0.7")), ], ) return d def test_followCanonicalName(self): """ If no record of the requested type is included in a response, but a I{CNAME} record for the query name is included, queries are made to resolve the value of the I{CNAME}. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "answers": [(b"example.com", Record_CNAME(b"example.net"))], }, (b"example.net", A): { "answers": [(b"example.net", Record_A("10.0.0.5"))], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") d.addCallback(lambda results: results[0]) # Get the answer section d.addCallback( self.assertEqual, [ RRHeader(b"example.com", CNAME, payload=Record_CNAME(b"example.net")), RRHeader(b"example.net", A, payload=Record_A("10.0.0.5")), ], ) return d def test_detectCanonicalNameLoop(self): """ If there is a cycle between I{CNAME} records in a response, this is detected and the L{Deferred} returned by the lookup method fails with L{ResolverError}. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "answers": [ (b"example.com", Record_CNAME(b"example.net")), (b"example.net", Record_CNAME(b"example.com")), ], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") return self.assertFailure(d, ResolverError) def test_boundedQueries(self): """ L{Resolver.lookupAddress} won't issue more queries following delegations than the limit passed to its initializer. """ servers = { ("1.1.2.3", 53): { # First query - force it to start over with a name lookup of # ns1.example.com (b"example.com", A): { "authority": [(b"example.com", Record_NS(b"ns1.example.com"))], }, # Second query - let it resume the original lookup with the # address of the nameserver handling the delegation. (b"ns1.example.com", A): { "answers": [(b"ns1.example.com", Record_A("10.0.0.2"))], }, }, ("10.0.0.2", 53): { # Third query - let it jump straight to asking the # delegation server by including its address here (different # case from the first query). (b"example.com", A): { "authority": [(b"example.com", Record_NS(b"ns2.example.com"))], "additional": [(b"ns2.example.com", Record_A("10.0.0.3"))], }, }, ("10.0.0.3", 53): { # Fourth query - give it the answer, we're done. (b"example.com", A): { "answers": [(b"example.com", Record_A("10.0.0.4"))], }, }, } # Make two resolvers. One which is allowed to make 3 queries # maximum, and so will fail, and on which may make 4, and so should # succeed. failer = self._getResolver(servers, 3) failD = self.assertFailure(failer.lookupAddress(b"example.com"), ResolverError) succeeder = self._getResolver(servers, 4) succeedD = succeeder.lookupAddress(b"example.com") succeedD.addCallback(getOnePayload) succeedD.addCallback(self.assertEqual, Record_A("10.0.0.4")) return gatherResults([failD, succeedD]) class ResolverFactoryArguments(Exception): """ Raised by L{raisingResolverFactory} with the *args and **kwargs passed to that function. """ def __init__(self, args, kwargs): """ Store the supplied args and kwargs as attributes. @param args: Positional arguments. @param kwargs: Keyword arguments. """ self.args = args self.kwargs = kwargs def raisingResolverFactory(*args, **kwargs): """ Raise a L{ResolverFactoryArguments} exception containing the positional and keyword arguments passed to resolverFactory. @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. """ raise ResolverFactoryArguments(args, kwargs) class RootResolverResolverFactoryTests(TestCase): """ Tests for L{root.Resolver._resolverFactory}. """ def test_resolverFactoryArgumentPresent(self): """ L{root.Resolver.__init__} accepts a C{resolverFactory} argument and assigns it to C{self._resolverFactory}. """ r = Resolver(hints=[None], resolverFactory=raisingResolverFactory) self.assertIs(r._resolverFactory, raisingResolverFactory) def test_resolverFactoryArgumentAbsent(self): """ L{root.Resolver.__init__} sets L{client.Resolver} as the C{_resolverFactory} if a C{resolverFactory} argument is not supplied. """ r = Resolver(hints=[None]) self.assertIs(r._resolverFactory, client.Resolver) def test_resolverFactoryOnlyExpectedArguments(self): """ L{root.Resolver._resolverFactory} is supplied with C{reactor} and C{servers} keyword arguments. """ dummyReactor = object() r = Resolver( hints=["192.0.2.101"], resolverFactory=raisingResolverFactory, reactor=dummyReactor, ) e = self.assertRaises(ResolverFactoryArguments, r.lookupAddress, "example.com") self.assertEqual( ((), {"reactor": dummyReactor, "servers": [("192.0.2.101", 53)]}), (e.args, e.kwargs), ) ROOT_SERVERS = [ "a.root-servers.net", "b.root-servers.net", "c.root-servers.net", "d.root-servers.net", "e.root-servers.net", "f.root-servers.net", "g.root-servers.net", "h.root-servers.net", "i.root-servers.net", "j.root-servers.net", "k.root-servers.net", "l.root-servers.net", "m.root-servers.net", ] @implementer(IResolverSimple) class StubResolver: """ An L{IResolverSimple} implementer which traces all getHostByName calls and their deferred results. The deferred results can be accessed and fired synchronously. """ def __init__(self): """ @type calls: L{list} of L{tuple} containing C{args} and C{kwargs} supplied to C{getHostByName} calls. @type pendingResults: L{list} of L{Deferred} returned by C{getHostByName}. """ self.calls = [] self.pendingResults = [] def getHostByName(self, *args, **kwargs): """ A fake implementation of L{IResolverSimple.getHostByName} @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. @return: A L{Deferred} which may be fired later from the test fixture. """ self.calls.append((args, kwargs)) d = Deferred() self.pendingResults.append(d) return d verifyClass(IResolverSimple, StubResolver) class BootstrapTests(SynchronousTestCase): """ Tests for L{root.bootstrap} """ def test_returnsDeferredResolver(self): """ L{root.bootstrap} returns an object which is initially a L{root.DeferredResolver}. """ deferredResolver = root.bootstrap(StubResolver()) self.assertIsInstance(deferredResolver, root.DeferredResolver) def test_resolves13RootServers(self): """ The L{IResolverSimple} supplied to L{root.bootstrap} is used to lookup the IP addresses of the 13 root name servers. """ stubResolver = StubResolver() root.bootstrap(stubResolver) self.assertEqual(stubResolver.calls, [((s,), {}) for s in ROOT_SERVERS]) def test_becomesResolver(self): """ The L{root.DeferredResolver} initially returned by L{root.bootstrap} becomes a L{root.Resolver} when the supplied resolver has successfully looked up all root hints. """ stubResolver = StubResolver() deferredResolver = root.bootstrap(stubResolver) for d in stubResolver.pendingResults: d.callback("192.0.2.101") self.assertIsInstance(deferredResolver, Resolver) def test_resolverReceivesRootHints(self): """ The L{root.Resolver} which eventually replaces L{root.DeferredResolver} is supplied with the IP addresses of the 13 root servers. """ stubResolver = StubResolver() deferredResolver = root.bootstrap(stubResolver) for d in stubResolver.pendingResults: d.callback("192.0.2.101") self.assertEqual(deferredResolver.hints, ["192.0.2.101"] * 13) def test_continuesWhenSomeRootHintsFail(self): """ The L{root.Resolver} is eventually created, even if some of the root hint lookups fail. Only the working root hint IP addresses are supplied to the L{root.Resolver}. """ stubResolver = StubResolver() deferredResolver = root.bootstrap(stubResolver) results = iter(stubResolver.pendingResults) d1 = next(results) for d in results: d.callback("192.0.2.101") d1.errback(TimeoutError()) def checkHints(res): self.assertEqual(deferredResolver.hints, ["192.0.2.101"] * 12) d1.addBoth(checkHints) def test_continuesWhenAllRootHintsFail(self): """ The L{root.Resolver} is eventually created, even if all of the root hint lookups fail. Pending and new lookups will then fail with AttributeError. """ stubResolver = StubResolver() deferredResolver = root.bootstrap(stubResolver) results = iter(stubResolver.pendingResults) d1 = next(results) for d in results: d.errback(TimeoutError()) d1.errback(TimeoutError()) def checkHints(res): self.assertEqual(deferredResolver.hints, []) d1.addBoth(checkHints) self.addCleanup(self.flushLoggedErrors, TimeoutError) def test_passesResolverFactory(self): """ L{root.bootstrap} accepts a C{resolverFactory} argument which is passed as an argument to L{root.Resolver} when it has successfully looked up root hints. """ stubResolver = StubResolver() deferredResolver = root.bootstrap( stubResolver, resolverFactory=raisingResolverFactory ) for d in stubResolver.pendingResults: d.callback("192.0.2.101") self.assertIs(deferredResolver._resolverFactory, raisingResolverFactory) class StubDNSDatagramProtocol: """ A do-nothing stand-in for L{DNSDatagramProtocol} which can be used to avoid network traffic in tests where that kind of thing doesn't matter. """ def query(self, *a, **kw): return Deferred() _retrySuppression = util.suppress( category=DeprecationWarning, message=( "twisted.names.root.retry is deprecated since Twisted 10.0. Use a " "Resolver object for retry logic." ), ) PK y�Z��4B^� ^� test/test_names.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for twisted.names. """ import copy import operator import socket from functools import partial, reduce from io import BytesIO from struct import pack from twisted.internet import defer, error, reactor from twisted.internet.defer import succeed from twisted.names import authority, client, common, dns, server from twisted.names.client import Resolver from twisted.names.dns import SOA, Message, Query, Record_A, Record_SOA, RRHeader from twisted.names.error import DomainError from twisted.names.secondary import SecondaryAuthority, SecondaryAuthorityService from twisted.python.compat import nativeString from twisted.python.filepath import FilePath from twisted.test.proto_helpers import ( MemoryReactorClock, StringTransport, waitUntilAllDisconnected, ) from twisted.trial import unittest def justPayload(results): return [r.payload for r in results[0]] class NoFileAuthority(authority.FileAuthority): def __init__(self, soa, records): # Yes, skip FileAuthority common.ResolverBase.__init__(self) self.soa, self.records = soa, records soa_record = dns.Record_SOA( mname=b"test-domain.com", rname="root.test-domain.com", serial=100, refresh=1234, minimum=7654, expire=19283784, retry=15, ttl=1, ) reverse_soa = dns.Record_SOA( mname=b"93.84.28.in-addr.arpa", rname=b"93.84.28.in-addr.arpa", serial=120, refresh=54321, minimum=382, expire=11193983, retry=30, ttl=3, ) my_soa = dns.Record_SOA( mname="my-domain.com", rname=b"postmaster.test-domain.com", serial=130, refresh=12345, minimum=1, expire=999999, retry=100, ) test_domain_com = NoFileAuthority( soa=(b"test-domain.com", soa_record), records={ b"test-domain.com": [ soa_record, dns.Record_A(b"127.0.0.1"), dns.Record_NS(b"39.28.189.39"), dns.Record_SPF(b"v=spf1 mx/30 mx:example.org/30 -all"), dns.Record_SPF(b"v=spf1 +mx a:\0colo", b".example.com/28 -all not valid"), dns.Record_MX(10, "host.test-domain.com"), dns.Record_HINFO(os=b"Linux", cpu=b"A Fast One, Dontcha know"), dns.Record_CNAME(b"canonical.name.com"), dns.Record_MB(b"mailbox.test-domain.com"), dns.Record_MG(b"mail.group.someplace"), dns.Record_TXT(b"A First piece of Text", b"a SecoNd piece"), dns.Record_A6(0, b"ABCD::4321", b""), dns.Record_A6(12, b"0:0069::0", b"some.network.tld"), dns.Record_A6(8, b"0:5634:1294:AFCB:56AC:48EF:34C3:01FF", b"tra.la.la.net"), dns.Record_TXT(b"Some more text, haha! Yes. \0 Still here?"), dns.Record_MR(b"mail.redirect.or.whatever"), dns.Record_MINFO(rmailbx=b"r mail box", emailbx=b"e mail box"), dns.Record_AFSDB(subtype=1, hostname=b"afsdb.test-domain.com"), dns.Record_RP(mbox=b"whatever.i.dunno", txt=b"some.more.text"), dns.Record_WKS( b"12.54.78.12", socket.IPPROTO_TCP, b"\x12\x01\x16\xfe\xc1\x00\x01" ), dns.Record_NAPTR( 100, 10, b"u", b"sip+E2U", b"!^.*$!sip:information@domain.tld!" ), dns.Record_AAAA(b"AF43:5634:1294:AFCB:56AC:48EF:34C3:01FF"), ], b"http.tcp.test-domain.com": [ dns.Record_SRV(257, 16383, 43690, b"some.other.place.fool") ], b"host.test-domain.com": [ dns.Record_A(b"123.242.1.5"), dns.Record_A(b"0.255.0.255"), ], b"host-two.test-domain.com": [ # # Python bug # dns.Record_A('255.255.255.255'), # dns.Record_A(b"255.255.255.254"), dns.Record_A(b"0.0.0.0"), ], b"cname.test-domain.com": [dns.Record_CNAME(b"test-domain.com")], b"anothertest-domain.com": [dns.Record_A(b"1.2.3.4")], }, ) reverse_domain = NoFileAuthority( soa=(b"93.84.28.in-addr.arpa", reverse_soa), records={ b"123.93.84.28.in-addr.arpa": [ dns.Record_PTR(b"test.host-reverse.lookup.com"), reverse_soa, ] }, ) my_domain_com = NoFileAuthority( soa=(b"my-domain.com", my_soa), records={ b"my-domain.com": [ my_soa, dns.Record_A(b"1.2.3.4", ttl="1S"), dns.Record_NS(b"ns1.domain", ttl=b"2M"), dns.Record_NS(b"ns2.domain", ttl="3H"), dns.Record_SRV(257, 16383, 43690, b"some.other.place.fool", ttl="4D"), ] }, ) class ServerDNSTests(unittest.TestCase): """ Test cases for DNS server and client. """ def setUp(self): self.factory = server.DNSServerFactory( [test_domain_com, reverse_domain, my_domain_com], verbose=2 ) p = dns.DNSDatagramProtocol(self.factory) while 1: listenerTCP = reactor.listenTCP(0, self.factory, interface="127.0.0.1") # It's simpler to do the stop listening with addCleanup, # even though we might not end up using this TCP port in # the test (if the listenUDP below fails). Cleaning up # this TCP port sooner than "cleanup time" would mean # adding more code to keep track of the Deferred returned # by stopListening. self.addCleanup(listenerTCP.stopListening) port = listenerTCP.getHost().port try: listenerUDP = reactor.listenUDP(port, p, interface="127.0.0.1") except error.CannotListenError: pass else: self.addCleanup(listenerUDP.stopListening) break self.listenerTCP = listenerTCP self.listenerUDP = listenerUDP self.resolver = client.Resolver(servers=[("127.0.0.1", port)]) def tearDown(self): """ Clean up any server connections associated with the L{DNSServerFactory} created in L{setUp} """ # It'd be great if DNSServerFactory had a method that # encapsulated this task. At least the necessary data is # available, though. for conn in self.factory.connections[:]: conn.transport.loseConnection() return waitUntilAllDisconnected(reactor, self.factory.connections[:]) def namesTest(self, querying, expectedRecords): """ Assert that the DNS response C{querying} will eventually fire with contains exactly a certain collection of records. @param querying: A L{Deferred} returned from one of the DNS client I{lookup} methods. @param expectedRecords: A L{list} of L{IRecord} providers which must be in the response or the test will be failed. @return: A L{Deferred} that fires when the assertion has been made. It fires with a success result if the assertion succeeds and with a L{Failure} if it fails. """ def checkResults(response): receivedRecords = justPayload(response) self.assertEqual(set(expectedRecords), set(receivedRecords)) querying.addCallback(checkResults) return querying def test_addressRecord1(self): """Test simple DNS 'A' record queries""" return self.namesTest( self.resolver.lookupAddress("test-domain.com"), [dns.Record_A("127.0.0.1", ttl=19283784)], ) def test_addressRecord2(self): """Test DNS 'A' record queries with multiple answers""" return self.namesTest( self.resolver.lookupAddress("host.test-domain.com"), [ dns.Record_A("123.242.1.5", ttl=19283784), dns.Record_A("0.255.0.255", ttl=19283784), ], ) def test_addressRecord3(self): """Test DNS 'A' record queries with edge cases""" return self.namesTest( self.resolver.lookupAddress("host-two.test-domain.com"), [ dns.Record_A("255.255.255.254", ttl=19283784), dns.Record_A("0.0.0.0", ttl=19283784), ], ) def test_authority(self): """Test DNS 'SOA' record queries""" return self.namesTest( self.resolver.lookupAuthority("test-domain.com"), [soa_record] ) def test_mailExchangeRecord(self): """ The DNS client can issue an MX query and receive a response including an MX record as well as any A record hints. """ return self.namesTest( self.resolver.lookupMailExchange(b"test-domain.com"), [ dns.Record_MX(10, b"host.test-domain.com", ttl=19283784), dns.Record_A(b"123.242.1.5", ttl=19283784), dns.Record_A(b"0.255.0.255", ttl=19283784), ], ) def test_nameserver(self): """Test DNS 'NS' record queries""" return self.namesTest( self.resolver.lookupNameservers("test-domain.com"), [dns.Record_NS("39.28.189.39", ttl=19283784)], ) def test_HINFO(self): """Test DNS 'HINFO' record queries""" return self.namesTest( self.resolver.lookupHostInfo("test-domain.com"), [ dns.Record_HINFO( os=b"Linux", cpu=b"A Fast One, Dontcha know", ttl=19283784 ) ], ) def test_PTR(self): """Test DNS 'PTR' record queries""" return self.namesTest( self.resolver.lookupPointer("123.93.84.28.in-addr.arpa"), [dns.Record_PTR("test.host-reverse.lookup.com", ttl=11193983)], ) def test_CNAME(self): """Test DNS 'CNAME' record queries""" return self.namesTest( self.resolver.lookupCanonicalName("test-domain.com"), [dns.Record_CNAME("canonical.name.com", ttl=19283784)], ) def test_MB(self): """Test DNS 'MB' record queries""" return self.namesTest( self.resolver.lookupMailBox("test-domain.com"), [dns.Record_MB("mailbox.test-domain.com", ttl=19283784)], ) def test_MG(self): """Test DNS 'MG' record queries""" return self.namesTest( self.resolver.lookupMailGroup("test-domain.com"), [dns.Record_MG("mail.group.someplace", ttl=19283784)], ) def test_MR(self): """Test DNS 'MR' record queries""" return self.namesTest( self.resolver.lookupMailRename("test-domain.com"), [dns.Record_MR("mail.redirect.or.whatever", ttl=19283784)], ) def test_MINFO(self): """Test DNS 'MINFO' record queries""" return self.namesTest( self.resolver.lookupMailboxInfo("test-domain.com"), [ dns.Record_MINFO( rmailbx="r mail box", emailbx="e mail box", ttl=19283784 ) ], ) def test_SRV(self): """Test DNS 'SRV' record queries""" return self.namesTest( self.resolver.lookupService("http.tcp.test-domain.com"), [dns.Record_SRV(257, 16383, 43690, "some.other.place.fool", ttl=19283784)], ) def test_AFSDB(self): """Test DNS 'AFSDB' record queries""" return self.namesTest( self.resolver.lookupAFSDatabase("test-domain.com"), [ dns.Record_AFSDB( subtype=1, hostname="afsdb.test-domain.com", ttl=19283784 ) ], ) def test_RP(self): """Test DNS 'RP' record queries""" return self.namesTest( self.resolver.lookupResponsibility("test-domain.com"), [ dns.Record_RP( mbox="whatever.i.dunno", txt="some.more.text", ttl=19283784 ) ], ) def test_TXT(self): """Test DNS 'TXT' record queries""" return self.namesTest( self.resolver.lookupText("test-domain.com"), [ dns.Record_TXT( b"A First piece of Text", b"a SecoNd piece", ttl=19283784 ), dns.Record_TXT( b"Some more text, haha! Yes. \0 Still here?", ttl=19283784 ), ], ) def test_spf(self): """ L{DNSServerFactory} can serve I{SPF} resource records. """ return self.namesTest( self.resolver.lookupSenderPolicy("test-domain.com"), [ dns.Record_SPF(b"v=spf1 mx/30 mx:example.org/30 -all", ttl=19283784), dns.Record_SPF( b"v=spf1 +mx a:\0colo", b".example.com/28 -all not valid", ttl=19283784, ), ], ) def test_WKS(self): """Test DNS 'WKS' record queries""" return self.namesTest( self.resolver.lookupWellKnownServices("test-domain.com"), [ dns.Record_WKS( "12.54.78.12", socket.IPPROTO_TCP, b"\x12\x01\x16\xfe\xc1\x00\x01", ttl=19283784, ) ], ) def test_someRecordsWithTTLs(self): result_soa = copy.copy(my_soa) result_soa.ttl = my_soa.expire return self.namesTest( self.resolver.lookupAllRecords("my-domain.com"), [ result_soa, dns.Record_A("1.2.3.4", ttl="1S"), dns.Record_NS("ns1.domain", ttl="2M"), dns.Record_NS("ns2.domain", ttl="3H"), dns.Record_SRV(257, 16383, 43690, "some.other.place.fool", ttl="4D"), ], ) def test_AAAA(self): """Test DNS 'AAAA' record queries (IPv6)""" return self.namesTest( self.resolver.lookupIPV6Address("test-domain.com"), [dns.Record_AAAA("AF43:5634:1294:AFCB:56AC:48EF:34C3:01FF", ttl=19283784)], ) def test_A6(self): """Test DNS 'A6' record queries (IPv6)""" return self.namesTest( self.resolver.lookupAddress6("test-domain.com"), [ dns.Record_A6(0, "ABCD::4321", "", ttl=19283784), dns.Record_A6(12, "0:0069::0", "some.network.tld", ttl=19283784), dns.Record_A6( 8, "0:5634:1294:AFCB:56AC:48EF:34C3:01FF", "tra.la.la.net", ttl=19283784, ), ], ) def test_zoneTransfer(self): """ Test DNS 'AXFR' queries (Zone transfer) """ default_ttl = soa_record.expire results = [ copy.copy(r) for r in reduce(operator.add, test_domain_com.records.values()) ] for r in results: if r.ttl is None: r.ttl = default_ttl return self.namesTest( self.resolver.lookupZone("test-domain.com").addCallback( lambda r: (r[0][:-1],) ), results, ) def test_zoneTransferConnectionFails(self): """ A failed AXFR TCP connection errbacks the L{Deferred} returned from L{Resolver.lookupZone}. """ resolver = Resolver(servers=[("nameserver.invalid", 53)]) return self.assertFailure( resolver.lookupZone("impossible.invalid"), error.DNSLookupError ) def test_similarZonesDontInterfere(self): """Tests that unrelated zones don't mess with each other.""" return self.namesTest( self.resolver.lookupAddress("anothertest-domain.com"), [dns.Record_A("1.2.3.4", ttl=19283784)], ) def test_NAPTR(self): """ Test DNS 'NAPTR' record queries. """ return self.namesTest( self.resolver.lookupNamingAuthorityPointer("test-domain.com"), [ dns.Record_NAPTR( 100, 10, b"u", b"sip+E2U", b"!^.*$!sip:information@domain.tld!", ttl=19283784, ) ], ) class HelperTests(unittest.TestCase): def test_serialGenerator(self): f = self.mktemp() a = authority.getSerial(f) for i in range(20): b = authority.getSerial(f) self.assertTrue(a < b) a = b class AXFRTests(unittest.TestCase): def setUp(self): self.results = None self.d = defer.Deferred() self.d.addCallback(self._gotResults) self.controller = client.AXFRController("fooby.com", self.d) self.soa = dns.RRHeader( name="fooby.com", type=dns.SOA, cls=dns.IN, ttl=86400, auth=False, payload=dns.Record_SOA( mname="fooby.com", rname="hooj.fooby.com", serial=100, refresh=200, retry=300, expire=400, minimum=500, ttl=600, ), ) self.records = [ self.soa, dns.RRHeader( name="fooby.com", type=dns.NS, cls=dns.IN, ttl=700, auth=False, payload=dns.Record_NS(name="ns.twistedmatrix.com", ttl=700), ), dns.RRHeader( name="fooby.com", type=dns.MX, cls=dns.IN, ttl=700, auth=False, payload=dns.Record_MX(preference=10, exchange="mail.mv3d.com", ttl=700), ), dns.RRHeader( name="fooby.com", type=dns.A, cls=dns.IN, ttl=700, auth=False, payload=dns.Record_A(address="64.123.27.105", ttl=700), ), self.soa, ] def _makeMessage(self): # hooray they all have the same message format return dns.Message( id=999, answer=1, opCode=0, recDes=0, recAv=1, auth=1, rCode=0, trunc=0, maxSize=0, ) def test_bindAndTNamesStyle(self): # Bind style = One big single message m = self._makeMessage() m.queries = [dns.Query("fooby.com", dns.AXFR, dns.IN)] m.answers = self.records self.controller.messageReceived(m, None) self.assertEqual(self.results, self.records) def _gotResults(self, result): self.results = result def test_DJBStyle(self): # DJB style = message per record records = self.records[:] while records: m = self._makeMessage() m.queries = [] # DJB *doesn't* specify any queries.. hmm.. m.answers = [records.pop(0)] self.controller.messageReceived(m, None) self.assertEqual(self.results, self.records) class ResolvConfHandlingTests(unittest.TestCase): def test_missing(self): resolvConf = self.mktemp() r = client.Resolver(resolv=resolvConf) self.assertEqual(r.dynServers, [("127.0.0.1", 53)]) r._parseCall.cancel() def test_empty(self): resolvConf = self.mktemp() open(resolvConf, "w").close() r = client.Resolver(resolv=resolvConf) self.assertEqual(r.dynServers, [("127.0.0.1", 53)]) r._parseCall.cancel() class AuthorityTests(unittest.TestCase): """ Tests for the basic response record selection code in L{FileAuthority} (independent of its fileness). """ def test_domainErrorForNameWithCommonSuffix(self): """ L{FileAuthority} lookup methods errback with L{DomainError} if the requested C{name} shares a common suffix with its zone but is not actually a descendant of its zone, in terms of its sequence of DNS name labels. eg www.the-example.com has nothing to do with the zone example.com. """ testDomain = test_domain_com testDomainName = b"nonexistent.prefix-" + testDomain.soa[0] f = self.failureResultOf(testDomain.lookupAddress(testDomainName)) self.assertIsInstance(f.value, DomainError) def test_recordMissing(self): """ If a L{FileAuthority} has a zone which includes an I{NS} record for a particular name and that authority is asked for another record for the same name which does not exist, the I{NS} record is not included in the authority section of the response. """ authority = NoFileAuthority( soa=(soa_record.mname.name, soa_record), records={ soa_record.mname.name: [ soa_record, dns.Record_NS("1.2.3.4"), ] }, ) answer, authority, additional = self.successResultOf( authority.lookupAddress(soa_record.mname.name) ) self.assertEqual(answer, []) self.assertEqual( authority, [ dns.RRHeader( soa_record.mname.name, soa_record.TYPE, ttl=soa_record.expire, payload=soa_record, auth=True, ) ], ) self.assertEqual(additional, []) def test_unknownTypeNXDOMAIN(self): """ Requesting a record of unknown type where no records exist for the name in question results in L{DomainError}. """ testDomain = test_domain_com testDomainName = b"nonexistent.prefix-" + testDomain.soa[0] unknownType = max(common.typeToMethod) + 1 f = self.failureResultOf( testDomain.query(Query(name=testDomainName, type=unknownType)) ) self.assertIsInstance(f.value, DomainError) def test_unknownTypeMissing(self): """ Requesting a record of unknown type where other records exist for the name in question results in an empty answer set. """ unknownType = max(common.typeToMethod) + 1 answer, authority, additional = self.successResultOf( my_domain_com.query(Query(name="my-domain.com", type=unknownType)) ) self.assertEqual(answer, []) def _referralTest(self, method): """ Create an authority and make a request against it. Then verify that the result is a referral, including no records in the answers or additional sections, but with an I{NS} record in the authority section. """ subdomain = b"example." + soa_record.mname.name nameserver = dns.Record_NS("1.2.3.4") authority = NoFileAuthority( soa=(soa_record.mname.name, soa_record), records={ subdomain: [ nameserver, ] }, ) d = getattr(authority, method)(subdomain) answer, authority, additional = self.successResultOf(d) self.assertEqual(answer, []) self.assertEqual( authority, [ dns.RRHeader( subdomain, dns.NS, ttl=soa_record.expire, payload=nameserver, auth=False, ) ], ) self.assertEqual(additional, []) def test_referral(self): """ When an I{NS} record is found for a child zone, it is included in the authority section of the response. It is marked as non-authoritative if the authority is not also authoritative for the child zone (RFC 2181, section 6.1). """ self._referralTest("lookupAddress") def test_allRecordsReferral(self): """ A referral is also generated for a request of type C{ALL_RECORDS}. """ self._referralTest("lookupAllRecords") class AdditionalProcessingTests(unittest.TestCase): """ Tests for L{FileAuthority}'s additional processing for those record types which require it (MX, CNAME, etc). """ _A = dns.Record_A(b"10.0.0.1") _AAAA = dns.Record_AAAA(b"f080::1") def _lookupSomeRecords(self, method, soa, makeRecord, target, addresses): """ Perform a DNS lookup against a L{FileAuthority} configured with records as defined by C{makeRecord} and C{addresses}. @param method: The name of the lookup method to use; for example, C{"lookupNameservers"}. @type method: L{str} @param soa: A L{Record_SOA} for the zone for which the L{FileAuthority} is authoritative. @param makeRecord: A one-argument callable which accepts a name and returns an L{IRecord} provider. L{FileAuthority} is constructed with this record. The L{FileAuthority} is queried for a record of the resulting type with the given name. @param target: The extra name which the record returned by C{makeRecord} will be pointed at; this is the name which might require extra processing by the server so that all the available, useful information is returned. For example, this is the target of a CNAME record or the mail exchange host pointed to by an MX record. @type target: L{bytes} @param addresses: A L{list} of records giving addresses of C{target}. @return: A L{Deferred} that fires with the result of the resolver method give by C{method}. """ authority = NoFileAuthority( soa=(soa.mname.name, soa), records={ soa.mname.name: [makeRecord(target)], target: addresses, }, ) return getattr(authority, method)(soa_record.mname.name) def assertRecordsMatch(self, expected, computed): """ Assert that the L{RRHeader} instances given by C{expected} and C{computed} carry all the same information but without requiring the records appear in the same order. @param expected: A L{list} of L{RRHeader} instances giving the expected records. @param computed: A L{list} of L{RRHeader} instances giving the records computed by the scenario under test. @raise self.failureException: If the two collections of records disagree. """ # RRHeader instances aren't inherently ordered. Impose an ordering # that's good enough for the purposes of these tests - in which we # never have more than one record of a particular type. key = lambda rr: rr.type self.assertEqual(sorted(expected, key=key), sorted(computed, key=key)) def _additionalTest(self, method, makeRecord, addresses): """ Verify that certain address records are included in the I{additional} section of a response generated by L{FileAuthority}. @param method: See L{_lookupSomeRecords} @param makeRecord: See L{_lookupSomeRecords} @param addresses: A L{list} of L{IRecord} providers which the I{additional} section of the response is required to match (ignoring order). @raise self.failureException: If the I{additional} section of the response consists of different records than those given by C{addresses}. """ target = b"mail." + soa_record.mname.name d = self._lookupSomeRecords(method, soa_record, makeRecord, target, addresses) answer, authority, additional = self.successResultOf(d) self.assertRecordsMatch( [ dns.RRHeader( target, address.TYPE, ttl=soa_record.expire, payload=address, auth=True, ) for address in addresses ], additional, ) def _additionalMXTest(self, addresses): """ Verify that a response to an MX query has certain records in the I{additional} section. @param addresses: See C{_additionalTest} """ self._additionalTest( "lookupMailExchange", partial(dns.Record_MX, 10), addresses ) def test_mailExchangeAdditionalA(self): """ If the name of the MX response has A records, they are included in the additional section of the response. """ self._additionalMXTest([self._A]) def test_mailExchangeAdditionalAAAA(self): """ If the name of the MX response has AAAA records, they are included in the additional section of the response. """ self._additionalMXTest([self._AAAA]) def test_mailExchangeAdditionalBoth(self): """ If the name of the MX response has both A and AAAA records, they are all included in the additional section of the response. """ self._additionalMXTest([self._A, self._AAAA]) def _additionalNSTest(self, addresses): """ Verify that a response to an NS query has certain records in the I{additional} section. @param addresses: See C{_additionalTest} """ self._additionalTest("lookupNameservers", dns.Record_NS, addresses) def test_nameserverAdditionalA(self): """ If the name of the NS response has A records, they are included in the additional section of the response. """ self._additionalNSTest([self._A]) def test_nameserverAdditionalAAAA(self): """ If the name of the NS response has AAAA records, they are included in the additional section of the response. """ self._additionalNSTest([self._AAAA]) def test_nameserverAdditionalBoth(self): """ If the name of the NS response has both A and AAAA records, they are all included in the additional section of the response. """ self._additionalNSTest([self._A, self._AAAA]) def _answerCNAMETest(self, addresses): """ Verify that a response to a CNAME query has certain records in the I{answer} section. @param addresses: See C{_additionalTest} """ target = b"www." + soa_record.mname.name d = self._lookupSomeRecords( "lookupCanonicalName", soa_record, dns.Record_CNAME, target, addresses ) answer, authority, additional = self.successResultOf(d) alias = dns.RRHeader( soa_record.mname.name, dns.CNAME, ttl=soa_record.expire, payload=dns.Record_CNAME(target), auth=True, ) self.assertRecordsMatch( [ dns.RRHeader( target, address.TYPE, ttl=soa_record.expire, payload=address, auth=True, ) for address in addresses ] + [alias], answer, ) def test_canonicalNameAnswerA(self): """ If the name of the CNAME response has A records, they are included in the answer section of the response. """ self._answerCNAMETest([self._A]) def test_canonicalNameAnswerAAAA(self): """ If the name of the CNAME response has AAAA records, they are included in the answer section of the response. """ self._answerCNAMETest([self._AAAA]) def test_canonicalNameAnswerBoth(self): """ If the name of the CNAME response has both A and AAAA records, they are all included in the answer section of the response. """ self._answerCNAMETest([self._A, self._AAAA]) class NoInitialResponseTests(unittest.TestCase): def test_noAnswer(self): """ If a request returns a L{dns.NS} response, but we can't connect to the given server, the request fails with the error returned at connection. """ def query(self, *args): # Pop from the message list, so that it blows up if more queries # are run than expected. return succeed(messages.pop(0)) def queryProtocol(self, *args, **kwargs): return defer.fail(socket.gaierror("Couldn't connect")) resolver = Resolver(servers=[("0.0.0.0", 0)]) resolver._query = query messages = [] # Let's patch dns.DNSDatagramProtocol.query, as there is no easy way to # customize it. self.patch(dns.DNSDatagramProtocol, "query", queryProtocol) records = [ dns.RRHeader( name="fooba.com", type=dns.NS, cls=dns.IN, ttl=700, auth=False, payload=dns.Record_NS(name="ns.twistedmatrix.com", ttl=700), ) ] m = dns.Message( id=999, answer=1, opCode=0, recDes=0, recAv=1, auth=1, rCode=0, trunc=0, maxSize=0, ) m.answers = records messages.append(m) return self.assertFailure(resolver.getHostByName("fooby.com"), socket.gaierror) class SecondaryAuthorityServiceTests(unittest.TestCase): """ Tests for L{SecondaryAuthorityService}, a service which keeps one or more authorities up to date by doing zone transfers from a master. """ def test_constructAuthorityFromHost(self): """ L{SecondaryAuthorityService} can be constructed with a C{str} giving a master server address and several domains, causing the creation of a secondary authority for each domain and that master server address and the default DNS port. """ primary = "192.168.1.2" service = SecondaryAuthorityService(primary, [b"example.com", "example.org"]) self.assertEqual(service.primary, primary) self.assertEqual(service._port, 53) self.assertEqual(service.domains[0].primary, primary) self.assertEqual(service.domains[0]._port, 53) self.assertEqual(service.domains[0].domain, b"example.com") self.assertEqual(service.domains[1].primary, primary) self.assertEqual(service.domains[1]._port, 53) self.assertEqual(service.domains[1].domain, b"example.org") def test_constructAuthorityFromHostAndPort(self): """ L{SecondaryAuthorityService.fromServerAddressAndDomains} constructs a new L{SecondaryAuthorityService} from a C{str} giving a master server address and DNS port and several domains, causing the creation of a secondary authority for each domain and that master server address and the given DNS port. """ primary = "192.168.1.3" port = 5335 service = SecondaryAuthorityService.fromServerAddressAndDomains( (primary, port), ["example.net", b"example.edu"] ) self.assertEqual(service.primary, primary) self.assertEqual(service._port, 5335) self.assertEqual(service.domains[0].primary, primary) self.assertEqual(service.domains[0]._port, port) self.assertEqual(service.domains[0].domain, b"example.net") self.assertEqual(service.domains[1].primary, primary) self.assertEqual(service.domains[1]._port, port) self.assertEqual(service.domains[1].domain, b"example.edu") def test_constructAuthorityFromBytes(self): """ L{SecondaryAuthorityService.fromServerAddressAndDomains} constructs a new L{SecondaryAuthorityService} from a C{bytes} giving a master server address and several domains, causing the creation of a secondary authority for each domain and that master server address and the given DNS port. """ primary = "192.168.1.3" service = SecondaryAuthorityService( primary.encode(), [b"example.net", "example.edu"], # Coerced to bytes. ) self.assertEqual(service.primary, primary) self.assertEqual(service.domains[0].primary, primary) self.assertEqual(service.domains[0].domain, b"example.net") self.assertEqual(service.domains[1].primary, primary) self.assertEqual(service.domains[1].domain, b"example.edu") class SecondaryAuthorityTests(unittest.TestCase): """ L{twisted.names.secondary.SecondaryAuthority} correctly constructs objects with a specified IP address and optionally specified DNS port. """ def test_defaultPort(self): """ When constructed using L{SecondaryAuthority.__init__}, the default port of 53 is used. """ secondary = SecondaryAuthority("192.168.1.1", "inside.com") self.assertEqual(secondary.primary, "192.168.1.1") self.assertEqual(secondary._port, 53) self.assertEqual(secondary.domain, b"inside.com") def test_explicitPort(self): """ When constructed using L{SecondaryAuthority.fromServerAddressAndDomain}, the specified port is used. """ secondary = SecondaryAuthority.fromServerAddressAndDomain( ("192.168.1.1", 5353), "inside.com" ) self.assertEqual(secondary.primary, "192.168.1.1") self.assertEqual(secondary._port, 5353) self.assertEqual(secondary.domain, b"inside.com") def test_transfer(self): """ An attempt is made to transfer the zone for the domain the L{SecondaryAuthority} was constructed with from the server address it was constructed with when L{SecondaryAuthority.transfer} is called. """ secondary = SecondaryAuthority.fromServerAddressAndDomain( ("192.168.1.2", 1234), "example.com" ) secondary._reactor = reactor = MemoryReactorClock() secondary.transfer() # Verify a connection attempt to the server address above host, port, factory, timeout, bindAddress = reactor.tcpClients.pop(0) self.assertEqual(host, "192.168.1.2") self.assertEqual(port, 1234) # See if a zone transfer query is issued. proto = factory.buildProtocol((host, port)) transport = StringTransport() proto.makeConnection(transport) msg = Message() # DNSProtocol.writeMessage length encodes the message by prepending a # 2 byte message length to the buffered value. msg.decode(BytesIO(transport.value()[2:])) self.assertEqual([dns.Query("example.com", dns.AXFR, dns.IN)], msg.queries) def test_lookupAddress(self): """ L{SecondaryAuthority.lookupAddress} returns a L{Deferred} that fires with the I{A} records the authority has cached from the primary. """ secondary = SecondaryAuthority.fromServerAddressAndDomain( ("192.168.1.2", 1234), b"example.com" ) secondary._reactor = reactor = MemoryReactorClock() secondary.transfer() host, port, factory, timeout, bindAddress = reactor.tcpClients.pop(0) proto = factory.buildProtocol((host, port)) transport = StringTransport() proto.makeConnection(transport) query = Message(answer=1, auth=1) query.decode(BytesIO(transport.value()[2:])) # Generate a response with some data we can check. soa = Record_SOA( mname=b"ns1.example.com", rname="admin.example.com", serial=123456, refresh=3600, minimum=4800, expire=7200, retry=9600, ttl=12000, ) a = Record_A(b"192.168.1.2", ttl=0) answer = Message(id=query.id, answer=1, auth=1) answer.answers.extend( [ RRHeader(b"example.com", type=SOA, payload=soa), RRHeader(b"example.com", payload=a), RRHeader(b"example.com", type=SOA, payload=soa), ] ) data = answer.toStr() proto.dataReceived(pack("!H", len(data)) + data) result = self.successResultOf(secondary.lookupAddress("example.com")) self.assertEqual( ([RRHeader(b"example.com", payload=a, auth=True)], [], []), result ) sampleBindZone = b"""\ $ORIGIN example.com. $TTL 1w example.com. IN SOA dns.example.com ( 2013120201 ; serial number of this zone file 1d ; slave refresh 2h ; slave retry time in case of a problem 4w ; slave expiration time 1h ; maximum caching time in case of failed lookups ) ; A comment. @ IN AAAA 2001:db8:10::1 example.com. IN A 10.0.0.1 no-in.example.com. A 10.0.0.2 ; technically wrong but used to work not-fqdn IN MX 10 mx.example.com www IN CNAME example.com""" class BindAuthorityTests(unittest.TestCase): """ Tests for L{twisted.names.authority.BindAuthority}. """ def loadBindString(self, s): """ Create a new L{twisted.names.authority.BindAuthority} from C{s}. @param s: A string with BIND zone data. @type s: bytes @return: a new bind authority @rtype: L{twisted.names.authority.BindAuthority} """ fp = FilePath(self.mktemp().encode("ascii")) fp.setContent(s) return authority.BindAuthority(fp.path) def setUp(self): self.auth = self.loadBindString(sampleBindZone) def test_ttl(self): """ Loads the default $TTL and applies it to all records. """ for dom in self.auth.records.keys(): for rec in self.auth.records[dom]: self.assertTrue(604800 == rec.ttl) def test_originFromFile(self): """ Loads the default $ORIGIN. """ self.assertEqual( b"example.com.", self.auth.origin, ) self.assertIn( b"not-fqdn.example.com", self.auth.records, ) def test_aRecords(self): """ A records are loaded. """ for dom, ip in [ (b"example.com", "10.0.0.1"), (b"no-in.example.com", "10.0.0.2"), ]: [[rr], [], []] = self.successResultOf(self.auth.lookupAddress(dom)) self.assertEqual( dns.Record_A( ip, 604800, ), rr.payload, ) def test_aaaaRecords(self): """ AAAA records are loaded. """ [[rr], [], []] = self.successResultOf( self.auth.lookupIPV6Address(b"example.com") ) self.assertEqual( dns.Record_AAAA( "2001:db8:10::1", 604800, ), rr.payload, ) def test_mxRecords(self): """ MX records are loaded. """ [[rr], [], []] = self.successResultOf( self.auth.lookupMailExchange(b"not-fqdn.example.com") ) self.assertEqual( dns.Record_MX( preference=10, name="mx.example.com", ttl=604800, ), rr.payload, ) def test_cnameRecords(self): """ CNAME records are loaded. """ [answers, [], []] = self.successResultOf( self.auth.lookupIPV6Address(b"www.example.com") ) rr = answers[0] self.assertEqual( dns.Record_CNAME( name="example.com", ttl=604800, ), rr.payload, ) def test_invalidRecordClass(self): """ loadBindString raises NotImplementedError on invalid records. """ with self.assertRaises(NotImplementedError) as e: self.loadBindString(b"example.com. IN LOL 192.168.0.1") self.assertEqual("Record type 'LOL' not supported", e.exception.args[0]) def test_invalidDirectives(self): """ $INCLUDE and $GENERATE raise NotImplementedError. """ for directive in (b"$INCLUDE", b"$GENERATE"): with self.assertRaises(NotImplementedError) as e: self.loadBindString(directive + b" doesNotMatter") self.assertEqual( nativeString(directive + b" directive not implemented"), e.exception.args[0], ) samplePySource = """\ zone = [ SOA( # For whom we are the authority 'example.com', # This nameserver's name mname = "dns.example.com", # Mailbox of individual who handles this rname = "root.example.com", # Unique serial identifying this SOA data serial = 86400, # Time interval before zone should be refreshed refresh = "2H", # Interval before failed refresh should be retried retry = "1H", # Upper limit on time interval before expiry expire = "1H", # Minimum TTL minimum = "3H" ), AAAA('example.com', '2001:db8:10::1'), A('example.com', '10.0.0.1'), NS('example.com', 'dns.example.com'), A('no-in.example.com', '10.0.0.2'), PTR('2.0.0.10.in-addr.arpa', 'no-in.example.com'), CNAME('www.example.com', 'example.com'), CNAME('ftp.example.com', 'example.com'), MX('not-fqdn.example.com', 10, 'mail.example.com'), ] """ class PySourceAuthorityTests(unittest.TestCase): """ Tests for L{twisted.names.authority.PySourceAuthority}. """ def loadPySourceString(self, s): """ Create a new L{twisted.names.authority.PySourceAuthority} from C{s}. @param s: A string with BIND zone data in a Python source file. @type s: L{str} @return: a new bind authority @rtype: L{twisted.names.authority.PySourceAuthority} """ fp = FilePath(self.mktemp()) with open(fp.path, "w") as f: f.write(s) return authority.PySourceAuthority(fp.path) def setUp(self): self.auth = self.loadPySourceString(samplePySource) def test_aRecords(self): """ A records are loaded. """ for dom, ip in [ (b"example.com", "10.0.0.1"), (b"no-in.example.com", "10.0.0.2"), ]: [[rr], [], []] = self.successResultOf(self.auth.lookupAddress(dom)) self.assertEqual( dns.Record_A(ip), rr.payload, ) def test_aaaaRecords(self): """ AAAA records are loaded. """ [[rr], [], []] = self.successResultOf( self.auth.lookupIPV6Address(b"example.com") ) self.assertEqual( dns.Record_AAAA("2001:db8:10::1"), rr.payload, ) def test_mxRecords(self): """ MX records are loaded. """ [[rr], [], []] = self.successResultOf( self.auth.lookupMailExchange(b"not-fqdn.example.com") ) self.assertEqual( dns.Record_MX( preference=10, name="mail.example.com", ), rr.payload, ) def test_cnameRecords(self): """ CNAME records are loaded. """ [answers, [], []] = self.successResultOf( self.auth.lookupIPV6Address(b"www.example.com") ) rr = answers[0] self.assertEqual( dns.Record_CNAME( name="example.com", ), rr.payload, ) def test_PTR(self): """ PTR records are loaded. """ [answers, [], []] = self.successResultOf( self.auth.lookupPointer(b"2.0.0.10.in-addr.arpa") ) rr = answers[0] self.assertEqual( dns.Record_PTR( name=b"no-in.example.com", ), rr.payload, ) def test_badInputNoZone(self): """ Input file has no zone variable """ badPySource = "nothing = []" self.assertRaises(ValueError, self.loadPySourceString, badPySource) PK y�ZG�O�� � test/test_util.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Utilities for Twisted.names tests. """ from random import randrange from zope.interface import implementer from zope.interface.verify import verifyClass from twisted.internet.address import IPv4Address from twisted.internet.defer import succeed from twisted.internet.interfaces import IReactorUDP, IUDPTransport from twisted.internet.task import Clock @implementer(IUDPTransport) class MemoryDatagramTransport: """ This L{IUDPTransport} implementation enforces the usual connection rules and captures sent traffic in a list for later inspection. @ivar _host: The host address to which this transport is bound. @ivar _protocol: The protocol connected to this transport. @ivar _sentPackets: A C{list} of two-tuples of the datagrams passed to C{write} and the addresses to which they are destined. @ivar _connectedTo: L{None} if this transport is unconnected, otherwise an address to which all traffic is supposedly sent. @ivar _maxPacketSize: An C{int} giving the maximum length of a datagram which will be successfully handled by C{write}. """ def __init__(self, host, protocol, maxPacketSize): self._host = host self._protocol = protocol self._sentPackets = [] self._connectedTo = None self._maxPacketSize = maxPacketSize def getHost(self): """ Return the address which this transport is pretending to be bound to. """ return IPv4Address("UDP", *self._host) def connect(self, host, port): """ Connect this transport to the given address. """ if self._connectedTo is not None: raise ValueError("Already connected") self._connectedTo = (host, port) def write(self, datagram, addr=None): """ Send the given datagram. """ if addr is None: addr = self._connectedTo if addr is None: raise ValueError("Need an address") if len(datagram) > self._maxPacketSize: raise ValueError("Packet too big") self._sentPackets.append((datagram, addr)) def stopListening(self): """ Shut down this transport. """ self._protocol.stopProtocol() return succeed(None) def setBroadcastAllowed(self, enabled): """ Dummy implementation to satisfy L{IUDPTransport}. """ pass def getBroadcastAllowed(self): """ Dummy implementation to satisfy L{IUDPTransport}. """ pass verifyClass(IUDPTransport, MemoryDatagramTransport) @implementer(IReactorUDP) class MemoryReactor(Clock): """ An L{IReactorTime} and L{IReactorUDP} provider. Time is controlled deterministically via the base class, L{Clock}. UDP is handled in-memory by connecting protocols to instances of L{MemoryDatagramTransport}. @ivar udpPorts: A C{dict} mapping port numbers to instances of L{MemoryDatagramTransport}. """ def __init__(self): Clock.__init__(self) self.udpPorts = {} def listenUDP(self, port, protocol, interface="", maxPacketSize=8192): """ Pretend to bind a UDP port and connect the given protocol to it. """ if port == 0: while True: port = randrange(1, 2 ** 16) if port not in self.udpPorts: break if port in self.udpPorts: raise ValueError("Address in use") transport = MemoryDatagramTransport((interface, port), protocol, maxPacketSize) self.udpPorts[port] = transport protocol.makeConnection(transport) return transport verifyClass(IReactorUDP, MemoryReactor) PK y�Z�l�� � test/test_tap.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names.tap}. """ from twisted.internet.base import ThreadedResolver from twisted.names.client import Resolver from twisted.names.dns import PORT from twisted.names.resolve import ResolverChain from twisted.names.secondary import SecondaryAuthorityService from twisted.names.tap import Options, _buildResolvers from twisted.python.runtime import platform from twisted.python.usage import UsageError from twisted.trial.unittest import SynchronousTestCase class OptionsTests(SynchronousTestCase): """ Tests for L{Options}, defining how command line arguments for the DNS server are parsed. """ def test_malformedSecondary(self): """ If the value supplied for an I{--secondary} option does not provide a server IP address, optional port number, and domain name, L{Options.parseOptions} raises L{UsageError}. """ options = Options() self.assertRaises(UsageError, options.parseOptions, ["--secondary", ""]) self.assertRaises(UsageError, options.parseOptions, ["--secondary", "1.2.3.4"]) self.assertRaises( UsageError, options.parseOptions, ["--secondary", "1.2.3.4:hello"] ) self.assertRaises( UsageError, options.parseOptions, ["--secondary", "1.2.3.4:hello/example.com"], ) def test_secondary(self): """ An argument of the form C{"ip/domain"} is parsed by L{Options} for the I{--secondary} option and added to its list of secondaries, using the default DNS port number. """ options = Options() options.parseOptions(["--secondary", "1.2.3.4/example.com"]) self.assertEqual([(("1.2.3.4", PORT), ["example.com"])], options.secondaries) def test_secondaryExplicitPort(self): """ An argument of the form C{"ip:port/domain"} can be used to specify an alternate port number for which to act as a secondary. """ options = Options() options.parseOptions(["--secondary", "1.2.3.4:5353/example.com"]) self.assertEqual([(("1.2.3.4", 5353), ["example.com"])], options.secondaries) def test_secondaryAuthorityServices(self): """ After parsing I{--secondary} options, L{Options} constructs a L{SecondaryAuthorityService} instance for each configured secondary. """ options = Options() options.parseOptions( [ "--secondary", "1.2.3.4:5353/example.com", "--secondary", "1.2.3.5:5354/example.com", ] ) self.assertEqual(len(options.svcs), 2) secondary = options.svcs[0] self.assertIsInstance(options.svcs[0], SecondaryAuthorityService) self.assertEqual(secondary.primary, "1.2.3.4") self.assertEqual(secondary._port, 5353) secondary = options.svcs[1] self.assertIsInstance(options.svcs[1], SecondaryAuthorityService) self.assertEqual(secondary.primary, "1.2.3.5") self.assertEqual(secondary._port, 5354) def test_recursiveConfiguration(self): """ Recursive DNS lookups, if enabled, should be a last-resort option. Any other lookup method (cache, local lookup, etc.) should take precedence over recursive lookups """ options = Options() options.parseOptions(["--hosts-file", "hosts.txt", "--recursive"]) ca, cl = _buildResolvers(options) # Extra cleanup, necessary on POSIX because client.Resolver doesn't know # when to stop parsing resolv.conf. See #NNN for improving this. for x in cl: if isinstance(x, ResolverChain): recurser = x.resolvers[-1] if isinstance(recurser, Resolver): recurser._parseCall.cancel() # On Windows, we need to use a threaded resolver, which leaves trash # lying about that we can't easily clean up without reaching into the # reactor and cancelling them. We only cancel the cleanup functions, as # there should be no others (and it leaving a callLater lying about # should rightly cause the test to fail). if platform.getType() != "posix": # We want the delayed calls on the reactor, which should be all of # ours from the threaded resolver cleanup from twisted.internet import reactor for x in reactor._newTimedCalls: self.assertEqual(x.func.__func__, ThreadedResolver._cleanup) x.cancel() self.assertIsInstance(cl[-1], ResolverChain) PK y�ZT=y� test/test_common.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names.common}. """ from zope.interface.verify import verifyClass from twisted.internet.interfaces import IResolver from twisted.names.common import ResolverBase from twisted.names.dns import EFORMAT, ENAME, ENOTIMP, EREFUSED, ESERVER, Query from twisted.names.error import ( DNSFormatError, DNSNameError, DNSNotImplementedError, DNSQueryRefusedError, DNSServerError, DNSUnknownError, ) from twisted.python.failure import Failure from twisted.trial.unittest import SynchronousTestCase class ExceptionForCodeTests(SynchronousTestCase): """ Tests for L{ResolverBase.exceptionForCode}. """ def setUp(self): self.exceptionForCode = ResolverBase().exceptionForCode def test_eformat(self): """ L{ResolverBase.exceptionForCode} converts L{EFORMAT} to L{DNSFormatError}. """ self.assertIs(self.exceptionForCode(EFORMAT), DNSFormatError) def test_eserver(self): """ L{ResolverBase.exceptionForCode} converts L{ESERVER} to L{DNSServerError}. """ self.assertIs(self.exceptionForCode(ESERVER), DNSServerError) def test_ename(self): """ L{ResolverBase.exceptionForCode} converts L{ENAME} to L{DNSNameError}. """ self.assertIs(self.exceptionForCode(ENAME), DNSNameError) def test_enotimp(self): """ L{ResolverBase.exceptionForCode} converts L{ENOTIMP} to L{DNSNotImplementedError}. """ self.assertIs(self.exceptionForCode(ENOTIMP), DNSNotImplementedError) def test_erefused(self): """ L{ResolverBase.exceptionForCode} converts L{EREFUSED} to L{DNSQueryRefusedError}. """ self.assertIs(self.exceptionForCode(EREFUSED), DNSQueryRefusedError) def test_other(self): """ L{ResolverBase.exceptionForCode} converts any other response code to L{DNSUnknownError}. """ self.assertIs(self.exceptionForCode(object()), DNSUnknownError) class QueryTests(SynchronousTestCase): """ Tests for L{ResolverBase.query}. """ def test_resolverBaseProvidesIResolver(self): """ L{ResolverBase} provides the L{IResolver} interface. """ verifyClass(IResolver, ResolverBase) def test_typeToMethodDispatch(self): """ L{ResolverBase.query} looks up a method to invoke using the type of the query passed to it and the C{typeToMethod} mapping on itself. """ results = [] resolver = ResolverBase() resolver.typeToMethod = { 12345: lambda query, timeout: results.append((query, timeout)) } query = Query(name=b"example.com", type=12345) resolver.query(query, 123) self.assertEqual([(b"example.com", 123)], results) def test_typeToMethodResult(self): """ L{ResolverBase.query} returns a L{Deferred} which fires with the result of the method found in the C{typeToMethod} mapping for the type of the query passed to it. """ expected = object() resolver = ResolverBase() resolver.typeToMethod = {54321: lambda query, timeout: expected} query = Query(name=b"example.com", type=54321) queryDeferred = resolver.query(query, 123) result = [] queryDeferred.addBoth(result.append) self.assertEqual(expected, result[0]) def test_unknownQueryType(self): """ L{ResolverBase.query} returns a L{Deferred} which fails with L{NotImplementedError} when called with a query of a type not present in its C{typeToMethod} dictionary. """ resolver = ResolverBase() resolver.typeToMethod = {} query = Query(name=b"example.com", type=12345) queryDeferred = resolver.query(query, 123) result = [] queryDeferred.addBoth(result.append) self.assertIsInstance(result[0], Failure) result[0].trap(NotImplementedError) PK y�ZD!F�� � test/test_examples.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names} example scripts. """ import os import sys from io import StringIO from twisted.python.filepath import FilePath from twisted.trial.unittest import SkipTest, TestCase class ExampleTestBase: """ This is a mixin which adds an example to the path, tests it, and then removes it from the path and unimports the modules which the test loaded. Test cases which test example code and documentation listings should use this. This is done this way so that examples can live in isolated path entries, next to the documentation, replete with their own plugin packages and whatever other metadata they need. Also, example code is a rare instance of it being valid to have multiple versions of the same code in the repository at once, rather than relying on version control, because documentation will often show the progression of a single piece of code as features are added to it, and we want to test each one. """ def setUp(self): """ Add our example directory to the path and record which modules are currently loaded. """ self.originalPath = sys.path[:] self.originalModules = sys.modules.copy() # Python usually expects native strs to be written to sys.stdout/stderr self.fakeErr = StringIO() self.patch(sys, "stderr", self.fakeErr) self.fakeOut = StringIO() self.patch(sys, "stdout", self.fakeOut) # Get documentation root try: here = FilePath(os.environ["TOX_INI_DIR"]).child("docs") except KeyError: raise SkipTest( "Examples not found ($TOX_INI_DIR unset) - cannot test", ) # Find the example script within this branch for childName in self.exampleRelativePath.split("/"): here = here.child(childName) if not here.exists(): raise SkipTest(f"Examples ({here.path}) not found - cannot test") self.examplePath = here # Add the example parent folder to the Python path sys.path.append(self.examplePath.parent().path) # Import the example as a module moduleName = self.examplePath.basename().split(".")[0] self.example = __import__(moduleName) def tearDown(self): """ Remove the example directory from the path and remove all modules loaded by the test from sys.modules. """ sys.modules.clear() sys.modules.update(self.originalModules) sys.path[:] = self.originalPath def test_shebang(self): """ The example scripts start with the standard shebang line. """ with self.examplePath.open() as f: self.assertEqual(f.readline().rstrip(), b"#!/usr/bin/env python") def test_usageConsistency(self): """ The example script prints a usage message to stdout if it is passed a --help option and then exits. The first line should contain a USAGE summary, explaining the accepted command arguments. """ # Pass None as first parameter - the reactor - it shouldn't # get as far as calling it. self.assertRaises(SystemExit, self.example.main, None, "--help") out = self.fakeOut.getvalue().splitlines() self.assertTrue( out[0].startswith("Usage:"), 'Usage message first line should start with "Usage:". ' "Actual: %r" % (out[0],), ) def test_usageConsistencyOnError(self): """ The example script prints a usage message to stderr if it is passed unrecognized command line arguments. The first line should contain a USAGE summary, explaining the accepted command arguments. The last line should contain an ERROR summary, explaining that incorrect arguments were supplied. """ # Pass None as first parameter - the reactor - it shouldn't # get as far as calling it. self.assertRaises(SystemExit, self.example.main, None, "--unexpected_argument") err = self.fakeErr.getvalue().splitlines() self.assertTrue( err[0].startswith("Usage:"), 'Usage message first line should start with "Usage:". ' "Actual: %r" % (err[0],), ) self.assertTrue( err[-1].startswith("ERROR:"), 'Usage message last line should start with "ERROR:" ' "Actual: %r" % (err[-1],), ) class TestDnsTests(ExampleTestBase, TestCase): """ Test the testdns.py example script. """ exampleRelativePath = "names/examples/testdns.py" class GetHostByNameTests(ExampleTestBase, TestCase): """ Test the gethostbyname.py example script. """ exampleRelativePath = "names/examples/gethostbyname.py" class DnsServiceTests(ExampleTestBase, TestCase): """ Test the dns-service.py example script. """ exampleRelativePath = "names/examples/dns-service.py" class MultiReverseLookupTests(ExampleTestBase, TestCase): """ Test the multi_reverse_lookup.py example script. """ exampleRelativePath = "names/examples/multi_reverse_lookup.py" PK y�Z�U#u�$ �$ test/test_srvconnect.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.names.srvconnect}. """ import random from zope.interface.verify import verifyObject from twisted.internet import defer, protocol from twisted.internet.error import DNSLookupError, ServiceNameUnknownError from twisted.internet.interfaces import IConnector from twisted.names import client, dns, srvconnect from twisted.names.common import ResolverBase from twisted.names.error import DNSNameError from twisted.test.proto_helpers import MemoryReactor from twisted.trial import unittest class FakeResolver(ResolverBase): """ Resolver that only gives out one given result. Either L{results} or L{failure} must be set and will be used for the return value of L{_lookup} @ivar results: List of L{dns.RRHeader} for the desired result. @type results: C{list} @ivar failure: Failure with an exception from L{twisted.names.error}. @type failure: L{Failure<twisted.python.failure.Failure>} """ def __init__(self, results=None, failure=None): self.results = results self.failure = failure self.lookups = [] def _lookup(self, name, cls, qtype, timeout): """ Return the result or failure on lookup. """ self.lookups.append((name, cls, qtype, timeout)) if self.results is not None: return defer.succeed((self.results, [], [])) else: return defer.fail(self.failure) class DummyFactory(protocol.ClientFactory): """ Dummy client factory that stores the reason of connection failure. """ def __init__(self): self.reason = None def clientConnectionFailed(self, connector, reason): self.reason = reason class SRVConnectorTests(unittest.TestCase): """ Tests for L{srvconnect.SRVConnector}. """ def setUp(self): self.patch(client, "theResolver", FakeResolver()) self.reactor = MemoryReactor() self.factory = DummyFactory() self.connector = srvconnect.SRVConnector( self.reactor, "xmpp-server", "example.org", self.factory ) self.randIntArgs = [] self.randIntResults = [] def _randint(self, min, max): """ Fake randint. Returns the first element of L{randIntResults} and records the arguments passed to it in L{randIntArgs}. @param min: Lower bound of the random number. @type min: L{int} @param max: Higher bound of the random number. @type max: L{int} @return: Fake random number from L{randIntResults}. @rtype: L{int} """ self.randIntArgs.append((min, max)) return self.randIntResults.pop(0) def test_interface(self): """ L{srvconnect.SRVConnector} implements L{IConnector}. """ verifyObject(IConnector, self.connector) def test_SRVPresent(self): """ Test connectTCP gets called with the address from the SRV record. """ payload = dns.Record_SRV(port=6269, target="host.example.org", ttl=60) client.theResolver.results = [ dns.RRHeader( name="example.org", type=dns.SRV, cls=dns.IN, ttl=60, payload=payload ) ] self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual(self.reactor.tcpClients.pop()[:2], ("host.example.org", 6269)) def test_SRVNotPresent(self): """ Test connectTCP gets called with fallback parameters on NXDOMAIN. """ client.theResolver.failure = DNSNameError(b"example.org") self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual( self.reactor.tcpClients.pop()[:2], ("example.org", "xmpp-server") ) def test_SRVNoResult(self): """ Test connectTCP gets called with fallback parameters on empty result. """ client.theResolver.results = [] self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual( self.reactor.tcpClients.pop()[:2], ("example.org", "xmpp-server") ) def test_SRVNoResultUnknownServiceDefaultPort(self): """ connectTCP gets called with default port if the service is not defined. """ self.connector = srvconnect.SRVConnector( self.reactor, "thisbetternotexist", "example.org", self.factory, defaultPort=5222, ) client.theResolver.failure = ServiceNameUnknownError() self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual(self.reactor.tcpClients.pop()[:2], ("example.org", 5222)) def test_SRVNoResultUnknownServiceNoDefaultPort(self): """ Connect fails on no result, unknown service and no default port. """ self.connector = srvconnect.SRVConnector( self.reactor, "thisbetternotexist", "example.org", self.factory ) client.theResolver.failure = ServiceNameUnknownError() self.connector.connect() self.assertTrue(self.factory.reason.check(ServiceNameUnknownError)) def test_SRVBadResult(self): """ Test connectTCP gets called with fallback parameters on bad result. """ client.theResolver.results = [ dns.RRHeader( name="example.org", type=dns.CNAME, cls=dns.IN, ttl=60, payload=None ) ] self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual( self.reactor.tcpClients.pop()[:2], ("example.org", "xmpp-server") ) def test_SRVNoService(self): """ Test that connecting fails when no service is present. """ payload = dns.Record_SRV(port=5269, target=b".", ttl=60) client.theResolver.results = [ dns.RRHeader( name="example.org", type=dns.SRV, cls=dns.IN, ttl=60, payload=payload ) ] self.connector.connect() self.assertIsNotNone(self.factory.reason) self.factory.reason.trap(DNSLookupError) self.assertEqual(self.reactor.tcpClients, []) def test_SRVLookupName(self): """ The lookup name is a native string from service, protocol and domain. """ client.theResolver.results = [] self.connector.connect() name = client.theResolver.lookups[-1][0] self.assertEqual(b"_xmpp-server._tcp.example.org", name) def test_unicodeDomain(self): """ L{srvconnect.SRVConnector} automatically encodes unicode domain using C{idna} encoding. """ self.connector = srvconnect.SRVConnector( self.reactor, "xmpp-client", "\u00e9chec.example.org", self.factory ) self.assertEqual(b"xn--chec-9oa.example.org", self.connector.domain) def test_pickServerWeights(self): """ pickServer calculates running sum of weights and calls randint. This exercises the server selection algorithm specified in RFC 2782 by preparing fake L{random.randint} results and checking the values it was called with. """ record1 = dns.Record_SRV(10, 10, 5222, "host1.example.org") record2 = dns.Record_SRV(10, 20, 5222, "host2.example.org") self.connector.orderedServers = [record1, record2] self.connector.servers = [] self.patch(random, "randint", self._randint) # 1st round self.randIntResults = [11, 0] self.connector.pickServer() self.assertEqual(self.randIntArgs[0], (0, 30)) self.connector.pickServer() self.assertEqual(self.randIntArgs[1], (0, 10)) # 2nd round self.randIntResults = [10, 0] self.connector.pickServer() self.assertEqual(self.randIntArgs[2], (0, 30)) self.connector.pickServer() self.assertEqual(self.randIntArgs[3], (0, 20)) def test_pickServerSamePriorities(self): """ Two records with equal priorities compare on weight (ascending). """ record1 = dns.Record_SRV(10, 10, 5222, "host1.example.org") record2 = dns.Record_SRV(10, 20, 5222, "host2.example.org") self.connector.orderedServers = [record2, record1] self.connector.servers = [] self.patch(random, "randint", self._randint) self.randIntResults = [0, 0] self.assertEqual(("host1.example.org", 5222), self.connector.pickServer()) self.assertEqual(("host2.example.org", 5222), self.connector.pickServer()) def test_srvDifferentPriorities(self): """ Two records with differing priorities compare on priority (ascending). """ record1 = dns.Record_SRV(10, 0, 5222, "host1.example.org") record2 = dns.Record_SRV(20, 0, 5222, "host2.example.org") self.connector.orderedServers = [record2, record1] self.connector.servers = [] self.patch(random, "randint", self._randint) self.randIntResults = [0, 0] self.assertEqual(("host1.example.org", 5222), self.connector.pickServer()) self.assertEqual(("host2.example.org", 5222), self.connector.pickServer()) PK y�Z��C� test/__init__.pynu �[��� "Tests for twisted.names" PK y�Z��Ք � � test/test_client.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.names.client}. """ import errno from zope.interface.verify import verifyClass, verifyObject from twisted.internet import defer from twisted.internet.error import CannotListenError, ConnectionRefusedError from twisted.internet.interfaces import IResolver from twisted.internet.task import Clock from twisted.internet.test.modulehelpers import AlternateReactor from twisted.names import cache, client, dns, error, hosts from twisted.names.common import ResolverBase from twisted.names.error import DNSQueryTimeoutError from twisted.names.test import test_util from twisted.names.test.test_hosts import GoodTempPathMixin from twisted.python import failure from twisted.python.filepath import FilePath from twisted.python.runtime import platform from twisted.test import proto_helpers from twisted.trial import unittest if not platform.isWindows(): windowsSkip = None else: windowsSkip = "These tests need more work before they'll work on Windows." class FakeResolver(ResolverBase): def _lookup(self, name, cls, qtype, timeout): """ The getHostByNameTest does a different type of query that requires it return an A record from an ALL_RECORDS lookup, so we accommodate that here. """ if name == b"getHostByNameTest": rr = dns.RRHeader( name=name, type=dns.A, cls=cls, ttl=60, payload=dns.Record_A(address="127.0.0.1", ttl=60), ) else: rr = dns.RRHeader(name=name, type=qtype, cls=cls, ttl=60) results = [rr] authority = [] additional = [] return defer.succeed((results, authority, additional)) class StubPort: """ A partial implementation of L{IListeningPort} which only keeps track of whether it has been stopped. @ivar disconnected: A C{bool} which is C{False} until C{stopListening} is called, C{True} afterwards. """ disconnected = False def stopListening(self): self.disconnected = True class StubDNSDatagramProtocol: """ L{dns.DNSDatagramProtocol}-alike. @ivar queries: A C{list} of tuples giving the arguments passed to C{query} along with the L{defer.Deferred} which was returned from the call. """ def __init__(self): self.queries = [] self.transport = StubPort() def query(self, address, queries, timeout=10, id=None): """ Record the given arguments and return a Deferred which will not be called back by this code. """ result = defer.Deferred() self.queries.append((address, queries, timeout, id, result)) return result class GetResolverTests(unittest.TestCase): """ Tests for L{client.getResolver}. """ skip = windowsSkip def test_interface(self): """ L{client.getResolver} returns an object providing L{IResolver}. """ with AlternateReactor(Clock()): resolver = client.getResolver() self.assertTrue(verifyObject(IResolver, resolver)) def test_idempotent(self): """ Multiple calls to L{client.getResolver} return the same L{IResolver} implementation. """ with AlternateReactor(Clock()): a = client.getResolver() b = client.getResolver() self.assertIs(a, b) class CreateResolverTests(unittest.TestCase, GoodTempPathMixin): """ Tests for L{client.createResolver}. """ skip = windowsSkip def _hostsTest(self, resolver, filename): res = [r for r in resolver.resolvers if isinstance(r, hosts.Resolver)] self.assertEqual(1, len(res)) self.assertEqual(res[0].file, filename) def test_defaultHosts(self): """ L{client.createResolver} returns a L{resolve.ResolverChain} including a L{hosts.Resolver} using I{/etc/hosts} if no alternate hosts file is specified. """ with AlternateReactor(Clock()): resolver = client.createResolver() self._hostsTest(resolver, b"/etc/hosts") def test_overrideHosts(self): """ The I{hosts} parameter to L{client.createResolver} overrides the hosts file used by the L{hosts.Resolver} in the L{resolve.ResolverChain} it returns. """ with AlternateReactor(Clock()): resolver = client.createResolver(hosts=b"/foo/bar") self._hostsTest(resolver, b"/foo/bar") def _resolvConfTest(self, resolver, filename): """ Verify that C{resolver} has a L{client.Resolver} with a configuration filename set to C{filename}. """ res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertEqual(res[0].resolv, filename) def test_reactor(self): """ The L{client.Resolver} included in the L{resolve.ResolverChain} returned by L{client.createResolver} uses the global reactor. """ reactor = Clock() with AlternateReactor(reactor): resolver = client.createResolver() res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertIs(reactor, res[0]._reactor) def test_defaultResolvConf(self): """ L{client.createResolver} returns a L{resolve.ResolverChain} including a L{client.Resolver} using I{/etc/resolv.conf} if no alternate resolver configuration file is specified. """ with AlternateReactor(Clock()): resolver = client.createResolver() self._resolvConfTest(resolver, b"/etc/resolv.conf") def test_overrideResolvConf(self): """ The I{resolvconf} parameter to L{client.createResolver} overrides the resolver configuration file used by the L{client.Resolver} in the L{resolve.ResolverChain} it returns. """ with AlternateReactor(Clock()): resolver = client.createResolver(resolvconf=b"/foo/bar") self._resolvConfTest(resolver, b"/foo/bar") def test_defaultServers(self): """ If no servers are given, addresses are taken from the file given by the I{resolvconf} parameter to L{client.createResolver}. """ resolvconf = self.path() resolvconf.setContent(b"nameserver 127.1.2.3\n") with AlternateReactor(Clock()): resolver = client.createResolver(resolvconf=resolvconf.path) res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertEqual([], res[0].servers) self.assertEqual([("127.1.2.3", 53)], res[0].dynServers) def test_overrideServers(self): """ Servers passed to L{client.createResolver} are used in addition to any found in the file given by the I{resolvconf} parameter. """ resolvconf = self.path() resolvconf.setContent(b"nameserver 127.1.2.3\n") with AlternateReactor(Clock()): resolver = client.createResolver( servers=[("127.3.2.1", 53)], resolvconf=resolvconf.path ) res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertEqual([("127.3.2.1", 53)], res[0].servers) self.assertEqual([("127.1.2.3", 53)], res[0].dynServers) def test_cache(self): """ L{client.createResolver} returns a L{resolve.ResolverChain} including a L{cache.CacheResolver}. """ with AlternateReactor(Clock()): resolver = client.createResolver() res = [r for r in resolver.resolvers if isinstance(r, cache.CacheResolver)] self.assertEqual(1, len(res)) class ResolverTests(unittest.TestCase): """ Tests for L{client.Resolver}. """ def test_clientProvidesIResolver(self): """ L{client} provides L{IResolver} through a series of free functions. """ verifyObject(IResolver, client) def test_clientResolverProvidesIResolver(self): """ L{client.Resolver} provides L{IResolver}. """ verifyClass(IResolver, client.Resolver) def test_noServers(self): """ L{client.Resolver} raises L{ValueError} if constructed with neither servers nor a nameserver configuration file. """ self.assertRaises(ValueError, client.Resolver) def test_missingConfiguration(self): """ A missing nameserver configuration file results in no server information being loaded from it (ie, not an exception) and a default server being provided. """ resolver = client.Resolver(resolv=self.mktemp(), reactor=Clock()) self.assertEqual([("127.0.0.1", 53)], resolver.dynServers) def test_closesResolvConf(self): """ As part of its constructor, C{StubResolver} opens C{/etc/resolv.conf}; then, explicitly closes it and does not count on the GC to do so for it. """ handle = FilePath(self.mktemp()) resolvConf = handle.open(mode="w+") class StubResolver(client.Resolver): def _openFile(self, name): return resolvConf StubResolver( servers=["example.com", 53], resolv="/etc/resolv.conf", reactor=Clock() ) self.assertTrue(resolvConf.closed) def test_domainEmptyArgument(self): """ L{client.Resolver.parseConfig} treats a I{domain} line without an argument as indicating a domain of C{b""}. """ resolver = client.Resolver(servers=[("127.0.0.1", 53)]) resolver.parseConfig([b"domain\n"]) self.assertEqual(b"", resolver.domain) def test_searchEmptyArgument(self): """ L{client.Resolver.parseConfig} treats a I{search} line without an argument as indicating an empty search suffix. """ resolver = client.Resolver(servers=[("127.0.0.1", 53)]) resolver.parseConfig([b"search\n"]) self.assertEqual([], resolver.search) def test_datagramQueryServerOrder(self): """ L{client.Resolver.queryUDP} should issue queries to its L{dns.DNSDatagramProtocol} with server addresses taken from its own C{servers} and C{dynServers} lists, proceeding through them in order as L{DNSQueryTimeoutError}s occur. """ protocol = StubDNSDatagramProtocol() servers = [("::1", 53), ("::2", 53)] dynServers = [("::3", 53), ("::4", 53)] resolver = client.Resolver(servers=servers) resolver.dynServers = dynServers resolver._connectedProtocol = lambda interface: protocol expectedResult = object() queryResult = resolver.queryUDP(None) queryResult.addCallback(self.assertEqual, expectedResult) self.assertEqual(len(protocol.queries), 1) self.assertIs(protocol.queries[0][0], servers[0]) protocol.queries[0][-1].errback(DNSQueryTimeoutError(0)) self.assertEqual(len(protocol.queries), 2) self.assertIs(protocol.queries[1][0], servers[1]) protocol.queries[1][-1].errback(DNSQueryTimeoutError(1)) self.assertEqual(len(protocol.queries), 3) self.assertIs(protocol.queries[2][0], dynServers[0]) protocol.queries[2][-1].errback(DNSQueryTimeoutError(2)) self.assertEqual(len(protocol.queries), 4) self.assertIs(protocol.queries[3][0], dynServers[1]) protocol.queries[3][-1].callback(expectedResult) return queryResult def test_singleConcurrentRequest(self): """ L{client.Resolver.query} only issues one request at a time per query. Subsequent requests made before responses to prior ones are received are queued and given the same response as is given to the first one. """ protocol = StubDNSDatagramProtocol() resolver = client.Resolver(servers=[("example.com", 53)]) resolver._connectedProtocol = lambda: protocol queries = protocol.queries query = dns.Query(b"foo.example.com", dns.A, dns.IN) # The first query should be passed to the underlying protocol. firstResult = resolver.query(query) self.assertEqual(len(queries), 1) # The same query again should not be passed to the underlying protocol. secondResult = resolver.query(query) self.assertEqual(len(queries), 1) # The response to the first query should be sent in response to both # queries. answer = object() response = dns.Message() response.answers.append(answer) queries.pop()[-1].callback(response) d = defer.gatherResults([firstResult, secondResult]) def cbFinished(responses): firstResponse, secondResponse = responses self.assertEqual(firstResponse, ([answer], [], [])) self.assertEqual(secondResponse, ([answer], [], [])) d.addCallback(cbFinished) return d def test_multipleConcurrentRequests(self): """ L{client.Resolver.query} issues a request for each different concurrent query. """ protocol = StubDNSDatagramProtocol() resolver = client.Resolver(servers=[("example.com", 53)]) resolver._connectedProtocol = lambda: protocol queries = protocol.queries # The first query should be passed to the underlying protocol. firstQuery = dns.Query(b"foo.example.com", dns.A) resolver.query(firstQuery) self.assertEqual(len(queries), 1) # A query for a different name is also passed to the underlying # protocol. secondQuery = dns.Query(b"bar.example.com", dns.A) resolver.query(secondQuery) self.assertEqual(len(queries), 2) # A query for a different type is also passed to the underlying # protocol. thirdQuery = dns.Query(b"foo.example.com", dns.A6) resolver.query(thirdQuery) self.assertEqual(len(queries), 3) def test_multipleSequentialRequests(self): """ After a response is received to a query issued with L{client.Resolver.query}, another query with the same parameters results in a new network request. """ protocol = StubDNSDatagramProtocol() resolver = client.Resolver(servers=[("example.com", 53)]) resolver._connectedProtocol = lambda: protocol queries = protocol.queries query = dns.Query(b"foo.example.com", dns.A) # The first query should be passed to the underlying protocol. resolver.query(query) self.assertEqual(len(queries), 1) # Deliver the response. queries.pop()[-1].callback(dns.Message()) # Repeating the first query should touch the protocol again. resolver.query(query) self.assertEqual(len(queries), 1) def test_multipleConcurrentFailure(self): """ If the result of a request is an error response, the Deferreds for all concurrently issued requests associated with that result fire with the L{Failure}. """ protocol = StubDNSDatagramProtocol() resolver = client.Resolver(servers=[("example.com", 53)]) resolver._connectedProtocol = lambda: protocol queries = protocol.queries query = dns.Query(b"foo.example.com", dns.A) firstResult = resolver.query(query) secondResult = resolver.query(query) class ExpectedException(Exception): pass queries.pop()[-1].errback(failure.Failure(ExpectedException())) return defer.gatherResults( [ self.assertFailure(firstResult, ExpectedException), self.assertFailure(secondResult, ExpectedException), ] ) def test_connectedProtocol(self): """ L{client.Resolver._connectedProtocol} returns a new L{DNSDatagramProtocol} connected to a new address with a cryptographically secure random port number. """ resolver = client.Resolver(servers=[("example.com", 53)]) firstProto = resolver._connectedProtocol() secondProto = resolver._connectedProtocol() self.assertIsNotNone(firstProto.transport) self.assertIsNotNone(secondProto.transport) self.assertNotEqual( firstProto.transport.getHost().port, secondProto.transport.getHost().port ) return defer.gatherResults( [ defer.maybeDeferred(firstProto.transport.stopListening), defer.maybeDeferred(secondProto.transport.stopListening), ] ) def test_resolverUsesOnlyParameterizedReactor(self): """ If a reactor instance is supplied to L{client.Resolver} L{client.Resolver._connectedProtocol} should pass that reactor to L{twisted.names.dns.DNSDatagramProtocol}. """ reactor = test_util.MemoryReactor() resolver = client.Resolver(resolv=self.mktemp(), reactor=reactor) proto = resolver._connectedProtocol() self.assertIs(proto._reactor, reactor) def test_differentProtocol(self): """ L{client.Resolver._connectedProtocol} is called once each time a UDP request needs to be issued and the resulting protocol instance is used for that request. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return defer.succeed(dns.Message()) resolver._connectedProtocol = FakeProtocol resolver.query(dns.Query(b"foo.example.com")) resolver.query(dns.Query(b"bar.example.com")) self.assertEqual(len(set(protocols)), 2) def test_ipv6Resolver(self): """ If the resolver is ipv6, open a ipv6 port. """ fake = test_util.MemoryReactor() resolver = client.Resolver(servers=[("::1", 53)], reactor=fake) resolver.query(dns.Query(b"foo.example.com")) [(proto, transport)] = fake.udpPorts.items() interface = transport.getHost().host self.assertEqual("::", interface) def test_disallowedPort(self): """ If a port number is initially selected which cannot be bound, the L{CannotListenError} is handled and another port number is attempted. """ ports = [] class FakeReactor: def listenUDP(self, port, *args, **kwargs): ports.append(port) if len(ports) == 1: raise CannotListenError(None, port, None) resolver = client.Resolver(servers=[("example.com", 53)]) resolver._reactor = FakeReactor() resolver._connectedProtocol() self.assertEqual(len(set(ports)), 2) def test_disallowedPortRepeatedly(self): """ If port numbers that cannot be bound are repeatedly selected, L{resolver._connectedProtocol} will give up eventually. """ ports = [] class FakeReactor: def listenUDP(self, port, *args, **kwargs): ports.append(port) raise CannotListenError(None, port, None) resolver = client.Resolver(servers=[("example.com", 53)]) resolver._reactor = FakeReactor() self.assertRaises(CannotListenError, resolver._connectedProtocol) # 1000 is a good round number. I like it. self.assertEqual(len(ports), 1000) def test_runOutOfFiles(self): """ If the process is out of files, L{Resolver._connectedProtocol} will give up. """ ports = [] class FakeReactor: def listenUDP(self, port, *args, **kwargs): ports.append(port) err = OSError(errno.EMFILE, "Out of files :(") raise CannotListenError(None, port, err) resolver = client.Resolver(servers=[("example.com", 53)]) resolver._reactor = FakeReactor() exc = self.assertRaises(CannotListenError, resolver._connectedProtocol) # The EMFILE-containing exception was raised, and it did not try # multiple times. self.assertEqual(exc.socketError.errno, errno.EMFILE) self.assertEqual(len(ports), 1) def test_differentProtocolAfterTimeout(self): """ When a query issued by L{client.Resolver.query} times out, the retry uses a new protocol instance. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] results = [ defer.fail(failure.Failure(DNSQueryTimeoutError(None))), defer.succeed(dns.Message()), ] class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return results.pop(0) resolver._connectedProtocol = FakeProtocol resolver.query(dns.Query(b"foo.example.com")) self.assertEqual(len(set(protocols)), 2) def test_protocolShutDown(self): """ After the L{Deferred} returned by L{DNSDatagramProtocol.query} is called back, the L{DNSDatagramProtocol} is disconnected from its transport. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] result = defer.Deferred() class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return result resolver._connectedProtocol = FakeProtocol resolver.query(dns.Query(b"foo.example.com")) self.assertFalse(protocols[0].transport.disconnected) result.callback(dns.Message()) self.assertTrue(protocols[0].transport.disconnected) def test_protocolShutDownAfterTimeout(self): """ The L{DNSDatagramProtocol} created when an interim timeout occurs is also disconnected from its transport after the Deferred returned by its query method completes. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] result = defer.Deferred() results = [defer.fail(failure.Failure(DNSQueryTimeoutError(None))), result] class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return results.pop(0) resolver._connectedProtocol = FakeProtocol resolver.query(dns.Query(b"foo.example.com")) self.assertFalse(protocols[1].transport.disconnected) result.callback(dns.Message()) self.assertTrue(protocols[1].transport.disconnected) def test_protocolShutDownAfterFailure(self): """ If the L{Deferred} returned by L{DNSDatagramProtocol.query} fires with a failure, the L{DNSDatagramProtocol} is still disconnected from its transport. """ class ExpectedException(Exception): pass resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] result = defer.Deferred() class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return result resolver._connectedProtocol = FakeProtocol queryResult = resolver.query(dns.Query(b"foo.example.com")) self.assertFalse(protocols[0].transport.disconnected) result.errback(failure.Failure(ExpectedException())) self.assertTrue(protocols[0].transport.disconnected) return self.assertFailure(queryResult, ExpectedException) def test_tcpDisconnectRemovesFromConnections(self): """ When a TCP DNS protocol associated with a Resolver disconnects, it is removed from the Resolver's connection list. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocol = resolver.factory.buildProtocol(None) protocol.makeConnection(None) self.assertIn(protocol, resolver.connections) # Disconnecting should remove the protocol from the connection list: protocol.connectionLost(None) self.assertNotIn(protocol, resolver.connections) def test_singleTCPQueryErrbackOnConnectionFailure(self): """ The deferred returned by L{client.Resolver.queryTCP} will errback when the TCP connection attempt fails. The reason for the connection failure is passed as the argument to errback. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor) d = resolver.queryTCP(dns.Query("example.com")) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] class SentinelException(Exception): pass factory.clientConnectionFailed( reactor.connectors[0], failure.Failure(SentinelException()) ) self.failureResultOf(d, SentinelException) def test_multipleTCPQueryErrbackOnConnectionFailure(self): """ All pending L{resolver.queryTCP} C{deferred}s will C{errback} with the same C{Failure} if the connection attempt fails. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor) d1 = resolver.queryTCP(dns.Query("example.com")) d2 = resolver.queryTCP(dns.Query("example.net")) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] class SentinelException(Exception): pass factory.clientConnectionFailed( reactor.connectors[0], failure.Failure(SentinelException()) ) f1 = self.failureResultOf(d1, SentinelException) f2 = self.failureResultOf(d2, SentinelException) self.assertIs(f1, f2) def test_reentrantTCPQueryErrbackOnConnectionFailure(self): """ An errback on the deferred returned by L{client.Resolver.queryTCP} may trigger another TCP query. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("127.0.0.1", 10053)], reactor=reactor) q = dns.Query("example.com") # First query sent d = resolver.queryTCP(q) # Repeat the query when the first query fails def reissue(e): e.trap(ConnectionRefusedError) return resolver.queryTCP(q) d.addErrback(reissue) self.assertEqual(len(reactor.tcpClients), 1) self.assertEqual(len(reactor.connectors), 1) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] # First query fails f1 = failure.Failure(ConnectionRefusedError()) factory.clientConnectionFailed(reactor.connectors[0], f1) # A second TCP connection is immediately attempted self.assertEqual(len(reactor.tcpClients), 2) self.assertEqual(len(reactor.connectors), 2) # No result expected until the second chained query returns self.assertNoResult(d) # Second query fails f2 = failure.Failure(ConnectionRefusedError()) factory.clientConnectionFailed(reactor.connectors[1], f2) # Original deferred now fires with the second failure f = self.failureResultOf(d, ConnectionRefusedError) self.assertIs(f, f2) def test_pendingEmptiedInPlaceOnError(self): """ When the TCP connection attempt fails, the L{client.Resolver.pending} list is emptied in place. It is not replaced with a new empty list. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor) d = resolver.queryTCP(dns.Query("example.com")) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] prePending = resolver.pending self.assertEqual(len(prePending), 1) class SentinelException(Exception): pass factory.clientConnectionFailed( reactor.connectors[0], failure.Failure(SentinelException()) ) self.failureResultOf(d, SentinelException) self.assertIs(resolver.pending, prePending) self.assertEqual(len(prePending), 0) class ClientTests(unittest.TestCase): def setUp(self): """ Replace the resolver with a FakeResolver """ client.theResolver = FakeResolver() self.hostname = b"example.com" self.hostnameForGetHostByName = b"getHostByNameTest" def tearDown(self): """ By setting the resolver to None, it will be recreated next time a name lookup is done. """ client.theResolver = None def checkResult(self, results, qtype): """ Verify that the result is the same query type as what is expected. """ answers, authority, additional = results result = answers[0] self.assertEqual(result.name.name, self.hostname) self.assertEqual(result.type, qtype) def checkGetHostByName(self, result): """ Test that the getHostByName query returns the 127.0.0.1 address. """ self.assertEqual(result, "127.0.0.1") def test_getHostByName(self): """ do a getHostByName of a value that should return 127.0.0.1. """ d = client.getHostByName(self.hostnameForGetHostByName) d.addCallback(self.checkGetHostByName) return d def test_lookupAddress(self): """ Do a lookup and test that the resolver will issue the correct type of query type. We do this by checking that FakeResolver returns a result record with the same query type as what we issued. """ d = client.lookupAddress(self.hostname) d.addCallback(self.checkResult, dns.A) return d def test_lookupIPV6Address(self): """ See L{test_lookupAddress} """ d = client.lookupIPV6Address(self.hostname) d.addCallback(self.checkResult, dns.AAAA) return d def test_lookupAddress6(self): """ See L{test_lookupAddress} """ d = client.lookupAddress6(self.hostname) d.addCallback(self.checkResult, dns.A6) return d def test_lookupNameservers(self): """ See L{test_lookupAddress} """ d = client.lookupNameservers(self.hostname) d.addCallback(self.checkResult, dns.NS) return d def test_lookupCanonicalName(self): """ See L{test_lookupAddress} """ d = client.lookupCanonicalName(self.hostname) d.addCallback(self.checkResult, dns.CNAME) return d def test_lookupAuthority(self): """ See L{test_lookupAddress} """ d = client.lookupAuthority(self.hostname) d.addCallback(self.checkResult, dns.SOA) return d def test_lookupMailBox(self): """ See L{test_lookupAddress} """ d = client.lookupMailBox(self.hostname) d.addCallback(self.checkResult, dns.MB) return d def test_lookupMailGroup(self): """ See L{test_lookupAddress} """ d = client.lookupMailGroup(self.hostname) d.addCallback(self.checkResult, dns.MG) return d def test_lookupMailRename(self): """ See L{test_lookupAddress} """ d = client.lookupMailRename(self.hostname) d.addCallback(self.checkResult, dns.MR) return d def test_lookupNull(self): """ See L{test_lookupAddress} """ d = client.lookupNull(self.hostname) d.addCallback(self.checkResult, dns.NULL) return d def test_lookupWellKnownServices(self): """ See L{test_lookupAddress} """ d = client.lookupWellKnownServices(self.hostname) d.addCallback(self.checkResult, dns.WKS) return d def test_lookupPointer(self): """ See L{test_lookupAddress} """ d = client.lookupPointer(self.hostname) d.addCallback(self.checkResult, dns.PTR) return d def test_lookupHostInfo(self): """ See L{test_lookupAddress} """ d = client.lookupHostInfo(self.hostname) d.addCallback(self.checkResult, dns.HINFO) return d def test_lookupMailboxInfo(self): """ See L{test_lookupAddress} """ d = client.lookupMailboxInfo(self.hostname) d.addCallback(self.checkResult, dns.MINFO) return d def test_lookupMailExchange(self): """ See L{test_lookupAddress} """ d = client.lookupMailExchange(self.hostname) d.addCallback(self.checkResult, dns.MX) return d def test_lookupText(self): """ See L{test_lookupAddress} """ d = client.lookupText(self.hostname) d.addCallback(self.checkResult, dns.TXT) return d def test_lookupSenderPolicy(self): """ See L{test_lookupAddress} """ d = client.lookupSenderPolicy(self.hostname) d.addCallback(self.checkResult, dns.SPF) return d def test_lookupResponsibility(self): """ See L{test_lookupAddress} """ d = client.lookupResponsibility(self.hostname) d.addCallback(self.checkResult, dns.RP) return d def test_lookupAFSDatabase(self): """ See L{test_lookupAddress} """ d = client.lookupAFSDatabase(self.hostname) d.addCallback(self.checkResult, dns.AFSDB) return d def test_lookupService(self): """ See L{test_lookupAddress} """ d = client.lookupService(self.hostname) d.addCallback(self.checkResult, dns.SRV) return d def test_lookupZone(self): """ See L{test_lookupAddress} """ d = client.lookupZone(self.hostname) d.addCallback(self.checkResult, dns.AXFR) return d def test_lookupAllRecords(self): """ See L{test_lookupAddress} """ d = client.lookupAllRecords(self.hostname) d.addCallback(self.checkResult, dns.ALL_RECORDS) return d def test_lookupNamingAuthorityPointer(self): """ See L{test_lookupAddress} """ d = client.lookupNamingAuthorityPointer(self.hostname) d.addCallback(self.checkResult, dns.NAPTR) return d def test_query(self): """ L{client.query} accepts a L{dns.Query} instance and dispatches it to L{client.theResolver}.C{query}, which in turn dispatches to an appropriate C{lookup*} method of L{client.theResolver}, based on the L{dns.Query} type. """ q = dns.Query(self.hostname, dns.A) d = client.query(q) d.addCallback(self.checkResult, dns.A) return d class FilterAnswersTests(unittest.TestCase): """ Test L{twisted.names.client.Resolver.filterAnswers}'s handling of various error conditions it might encounter. """ def setUp(self): # Create a resolver pointed at an invalid server - we won't be hitting # the network in any of these tests. self.resolver = client.Resolver(servers=[("0.0.0.0", 0)]) def test_truncatedMessage(self): """ Test that a truncated message results in an equivalent request made via TCP. """ m = dns.Message(trunc=True) m.addQuery(b"example.com") def queryTCP(queries): self.assertEqual(queries, m.queries) response = dns.Message() response.answers = ["answer"] response.authority = ["authority"] response.additional = ["additional"] return defer.succeed(response) self.resolver.queryTCP = queryTCP d = self.resolver.filterAnswers(m) d.addCallback(self.assertEqual, (["answer"], ["authority"], ["additional"])) return d def _rcodeTest(self, rcode, exc): m = dns.Message(rCode=rcode) err = self.resolver.filterAnswers(m) err.trap(exc) def test_formatError(self): """ Test that a message with a result code of C{EFORMAT} results in a failure wrapped around L{DNSFormatError}. """ return self._rcodeTest(dns.EFORMAT, error.DNSFormatError) def test_serverError(self): """ Like L{test_formatError} but for C{ESERVER}/L{DNSServerError}. """ return self._rcodeTest(dns.ESERVER, error.DNSServerError) def test_nameError(self): """ Like L{test_formatError} but for C{ENAME}/L{DNSNameError}. """ return self._rcodeTest(dns.ENAME, error.DNSNameError) def test_notImplementedError(self): """ Like L{test_formatError} but for C{ENOTIMP}/L{DNSNotImplementedError}. """ return self._rcodeTest(dns.ENOTIMP, error.DNSNotImplementedError) def test_refusedError(self): """ Like L{test_formatError} but for C{EREFUSED}/L{DNSQueryRefusedError}. """ return self._rcodeTest(dns.EREFUSED, error.DNSQueryRefusedError) def test_refusedErrorUnknown(self): """ Like L{test_formatError} but for an unrecognized error code and L{DNSUnknownError}. """ return self._rcodeTest(dns.EREFUSED + 1, error.DNSUnknownError) class FakeDNSDatagramProtocol: def __init__(self): self.queries = [] self.transport = StubPort() def query(self, address, queries, timeout=10, id=None): self.queries.append((address, queries, timeout, id)) return defer.fail(error.DNSQueryTimeoutError(queries)) def removeResend(self, id): # Ignore this for the time being. pass class RetryLogicTests(unittest.TestCase): """ Tests for query retrying implemented by L{client.Resolver}. """ testServers = ["1.2.3.4", "4.3.2.1", "a.b.c.d", "z.y.x.w"] def test_roundRobinBackoff(self): """ When timeouts occur waiting for responses to queries, the next configured server is issued the query. When the query has been issued to all configured servers, the timeout is increased and the process begins again at the beginning. """ addrs = [(x, 53) for x in self.testServers] r = client.Resolver(resolv=None, servers=addrs) proto = FakeDNSDatagramProtocol() r._connectedProtocol = lambda: proto return ( r.lookupAddress(b"foo.example.com") .addCallback(self._cbRoundRobinBackoff) .addErrback(self._ebRoundRobinBackoff, proto) ) def _cbRoundRobinBackoff(self, result): self.fail("Lookup address succeeded, should have timed out") def _ebRoundRobinBackoff(self, failure, fakeProto): failure.trap(defer.TimeoutError) # Assert that each server is tried with a particular timeout # before the timeout is increased and the attempts are repeated. for t in (1, 3, 11, 45): tries = fakeProto.queries[: len(self.testServers)] del fakeProto.queries[: len(self.testServers)] tries.sort() expected = list(self.testServers) expected.sort() for ((addr, query, timeout, id), expectedAddr) in zip(tries, expected): self.assertEqual(addr, (expectedAddr, 53)) self.assertEqual(timeout, t) self.assertFalse(fakeProto.queries) class ThreadedResolverTests(unittest.TestCase): """ Tests for L{client.ThreadedResolver}. """ def test_deprecated(self): """ L{client.ThreadedResolver} is deprecated. Instantiating it emits a deprecation warning pointing at the code that does the instantiation. """ client.ThreadedResolver() warnings = self.flushWarnings(offendingFunctions=[self.test_deprecated]) self.assertEqual( warnings[0]["message"], "twisted.names.client.ThreadedResolver is deprecated since " "Twisted 9.0, use twisted.internet.base.ThreadedResolver " "instead.", ) self.assertEqual(warnings[0]["category"], DeprecationWarning) self.assertEqual(len(warnings), 1) PK y�Z�l��� � secondary.pynu �[��� # -*- test-case-name: twisted.names.test.test_names -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. __all__ = ["SecondaryAuthority", "SecondaryAuthorityService"] from twisted.application import service from twisted.internet import defer, task from twisted.names import client, common, dns, resolve from twisted.names.authority import FileAuthority from twisted.python import failure, log from twisted.python.compat import nativeString class SecondaryAuthorityService(service.Service): """ A service that keeps one or more authorities up to date by doing hourly zone transfers from a master. @ivar primary: IP address of the master. @type primary: L{str} @ivar domains: An authority for each domain mirrored from the master. @type domains: L{list} of L{SecondaryAuthority} """ calls = None _port = 53 def __init__(self, primary, domains): """ @param primary: The IP address of the server from which to perform zone transfers. @type primary: L{str} @param domains: A sequence of domain names for which to perform zone transfers. @type domains: L{list} of L{bytes} """ self.primary = nativeString(primary) self.domains = [SecondaryAuthority(primary, d) for d in domains] @classmethod def fromServerAddressAndDomains(cls, serverAddress, domains): """ Construct a new L{SecondaryAuthorityService} from a tuple giving a server address and a C{str} giving the name of a domain for which this is an authority. @param serverAddress: A two-tuple, the first element of which is a C{str} giving an IP address and the second element of which is a C{int} giving a port number. Together, these define where zone transfers will be attempted from. @param domains: Domain names for which to perform zone transfers. @type domains: sequence of L{bytes} @return: A new instance of L{SecondaryAuthorityService}. """ primary, port = serverAddress service = cls(primary, []) service._port = port service.domains = [ SecondaryAuthority.fromServerAddressAndDomain(serverAddress, d) for d in domains ] return service def getAuthority(self): """ Get a resolver for the transferred domains. @rtype: L{ResolverChain} """ return resolve.ResolverChain(self.domains) def startService(self): service.Service.startService(self) self.calls = [task.LoopingCall(d.transfer) for d in self.domains] i = 0 from twisted.internet import reactor for c in self.calls: # XXX Add errbacks, respect proper timeouts reactor.callLater(i, c.start, 60 * 60) i += 1 def stopService(self): service.Service.stopService(self) for c in self.calls: c.stop() class SecondaryAuthority(FileAuthority): """ An Authority that keeps itself updated by performing zone transfers. @ivar primary: The IP address of the server from which zone transfers will be attempted. @type primary: L{str} @ivar _port: The port number of the server from which zone transfers will be attempted. @type _port: L{int} @ivar domain: The domain for which this is the secondary authority. @type domain: L{bytes} @ivar _reactor: The reactor to use to perform the zone transfers, or L{None} to use the global reactor. """ transferring = False soa = records = None _port = 53 _reactor = None def __init__(self, primaryIP, domain): """ @param domain: The domain for which this will be the secondary authority. @type domain: L{bytes} or L{str} """ # Yep. Skip over FileAuthority.__init__. This is a hack until we have # a good composition-based API for the complicated DNS record lookup # logic we want to share. common.ResolverBase.__init__(self) self.primary = nativeString(primaryIP) self.domain = dns.domainString(domain) @classmethod def fromServerAddressAndDomain(cls, serverAddress, domain): """ Construct a new L{SecondaryAuthority} from a tuple giving a server address and a C{bytes} giving the name of a domain for which this is an authority. @param serverAddress: A two-tuple, the first element of which is a C{str} giving an IP address and the second element of which is a C{int} giving a port number. Together, these define where zone transfers will be attempted from. @param domain: A C{bytes} giving the domain to transfer. @type domain: L{bytes} @return: A new instance of L{SecondaryAuthority}. """ primary, port = serverAddress secondary = cls(primary, domain) secondary._port = port return secondary def transfer(self): """ Attempt a zone transfer. @returns: A L{Deferred} that fires with L{None} when attempted zone transfer has completed. """ # FIXME: This logic doesn't avoid duplicate transfers # https://twistedmatrix.com/trac/ticket/9754 if self.transferring: # <-- never true return self.transfering = True # <-- speling reactor = self._reactor if reactor is None: from twisted.internet import reactor resolver = client.Resolver( servers=[(self.primary, self._port)], reactor=reactor ) return ( resolver.lookupZone(self.domain) .addCallback(self._cbZone) .addErrback(self._ebZone) ) def _lookup(self, name, cls, type, timeout=None): if not self.soa or not self.records: # No transfer has occurred yet. Fail non-authoritatively so that # the caller can try elsewhere. return defer.fail(failure.Failure(dns.DomainError(name))) return FileAuthority._lookup(self, name, cls, type, timeout) def _cbZone(self, zone): ans, _, _ = zone self.records = r = {} for rec in ans: if not self.soa and rec.type == dns.SOA: self.soa = (rec.name.name.lower(), rec.payload) else: r.setdefault(rec.name.name.lower(), []).append(rec.payload) def _ebZone(self, failure): log.msg( "Updating %s from %s failed during zone transfer" % (self.domain, self.primary) ) log.err(failure) def update(self): self.transfer().addCallbacks(self._cbTransferred, self._ebTransferred) def _cbTransferred(self, result): self.transferring = False def _ebTransferred(self, failure): self.transferred = False log.msg( "Transferring %s from %s failed after zone transfer" % (self.domain, self.primary) ) log.err(failure) PK y�Z���]� � resolve.pynu �[��� # -*- test-case-name: twisted.names.test.test_resolve -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Lookup a name using multiple resolvers. Future Plans: This needs someway to specify which resolver answered the query, or someway to specify (authority|ttl|cache behavior|more?) """ from zope.interface import implementer from twisted.internet import defer, interfaces from twisted.names import common, dns, error class FailureHandler: def __init__(self, resolver, query, timeout): self.resolver = resolver self.query = query self.timeout = timeout def __call__(self, failure): # AuthoritativeDomainErrors should halt resolution attempts failure.trap(dns.DomainError, defer.TimeoutError, NotImplementedError) return self.resolver(self.query, self.timeout) @implementer(interfaces.IResolver) class ResolverChain(common.ResolverBase): """ Lookup an address using multiple L{IResolver}s """ def __init__(self, resolvers): """ @type resolvers: L{list} @param resolvers: A L{list} of L{IResolver} providers. """ common.ResolverBase.__init__(self) self.resolvers = resolvers def _lookup(self, name, cls, type, timeout): """ Build a L{dns.Query} for the given parameters and dispatch it to each L{IResolver} in C{self.resolvers} until an answer or L{error.AuthoritativeDomainError} is returned. @type name: C{str} @param name: DNS name to resolve. @type type: C{int} @param type: DNS record type. @type cls: C{int} @param cls: DNS record class. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @rtype: L{Deferred} @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. """ if not self.resolvers: return defer.fail(error.DomainError()) q = dns.Query(name, type, cls) d = self.resolvers[0].query(q, timeout) for r in self.resolvers[1:]: d = d.addErrback(FailureHandler(r.query, q, timeout)) return d def lookupAllRecords(self, name, timeout=None): # XXX: Why is this necessary? dns.ALL_RECORDS queries should # be handled just the same as any other type by _lookup # above. If I remove this method all names tests still # pass. See #6604 -rwall if not self.resolvers: return defer.fail(error.DomainError()) d = self.resolvers[0].lookupAllRecords(name, timeout) for r in self.resolvers[1:]: d = d.addErrback(FailureHandler(r.lookupAllRecords, name, timeout)) return d PK y�Z�O��� � error.pynu �[��� # -*- test-case-name: twisted.names.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Exception class definitions for Twisted Names. """ from twisted.internet.defer import TimeoutError class DomainError(ValueError): """ Indicates a lookup failed because there were no records matching the given C{name, class, type} triple. """ class AuthoritativeDomainError(ValueError): """ Indicates a lookup failed for a name for which this server is authoritative because there were no records matching the given C{name, class, type} triple. """ class DNSQueryTimeoutError(TimeoutError): """ Indicates a lookup failed due to a timeout. @ivar id: The id of the message which timed out. """ def __init__(self, id): TimeoutError.__init__(self) self.id = id class DNSFormatError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.EFORMAT}. """ class DNSServerError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.ESERVER}. """ class DNSNameError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.ENAME}. """ class DNSNotImplementedError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.ENOTIMP}. """ class DNSQueryRefusedError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.EREFUSED}. """ class DNSUnknownError(DomainError): """ Indicates a query failed with an unknown result. """ class ResolverError(Exception): """ Indicates a query failed because of a decision made by the local resolver object. """ __all__ = [ "DomainError", "AuthoritativeDomainError", "DNSQueryTimeoutError", "DNSFormatError", "DNSServerError", "DNSNameError", "DNSNotImplementedError", "DNSQueryRefusedError", "DNSUnknownError", "ResolverError", ] PK y�ZX��� � hosts.pynu �[��� # -*- test-case-name: twisted.names.test.test_hosts -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ hosts(5) support. """ from twisted.internet import defer from twisted.internet.abstract import isIPAddress, isIPv6Address from twisted.names import common, dns from twisted.python import failure from twisted.python.compat import nativeString from twisted.python.filepath import FilePath def searchFileForAll(hostsFile, name): """ Search the given file, which is in hosts(5) standard format, for addresses associated with a given name. @param hostsFile: The name of the hosts(5)-format file to search. @type hostsFile: L{FilePath} @param name: The name to search for. @type name: C{bytes} @return: L{None} if the name is not found in the file, otherwise a C{str} giving the address in the file associated with the name. """ results = [] try: lines = hostsFile.getContent().splitlines() except BaseException: return results name = name.lower() for line in lines: idx = line.find(b"#") if idx != -1: line = line[:idx] if not line: continue parts = line.split() if name.lower() in [s.lower() for s in parts[1:]]: try: maybeIP = nativeString(parts[0]) except ValueError: # Not ASCII. continue if isIPAddress(maybeIP) or isIPv6Address(maybeIP): results.append(maybeIP) return results def searchFileFor(file, name): """ Grep given file, which is in hosts(5) standard format, for an address entry with a given name. @param file: The name of the hosts(5)-format file to search. @type file: C{str} or C{bytes} @param name: The name to search for. @type name: C{bytes} @return: L{None} if the name is not found in the file, otherwise a C{str} giving the first address in the file associated with the name. """ addresses = searchFileForAll(FilePath(file), name) if addresses: return addresses[0] return None class Resolver(common.ResolverBase): """ A resolver that services hosts(5) format files. """ def __init__(self, file=b"/etc/hosts", ttl=60 * 60): common.ResolverBase.__init__(self) self.file = file self.ttl = ttl def _aRecords(self, name): """ Return a tuple of L{dns.RRHeader} instances for all of the IPv4 addresses in the hosts file. """ return tuple( dns.RRHeader(name, dns.A, dns.IN, self.ttl, dns.Record_A(addr, self.ttl)) for addr in searchFileForAll(FilePath(self.file), name) if isIPAddress(addr) ) def _aaaaRecords(self, name): """ Return a tuple of L{dns.RRHeader} instances for all of the IPv6 addresses in the hosts file. """ return tuple( dns.RRHeader( name, dns.AAAA, dns.IN, self.ttl, dns.Record_AAAA(addr, self.ttl) ) for addr in searchFileForAll(FilePath(self.file), name) if isIPv6Address(addr) ) def _respond(self, name, records): """ Generate a response for the given name containing the given result records, or a failure if there are no result records. @param name: The DNS name the response is for. @type name: C{str} @param records: A tuple of L{dns.RRHeader} instances giving the results that will go into the response. @return: A L{Deferred} which will fire with a three-tuple of result records, authority records, and additional records, or which will fail with L{dns.DomainError} if there are no result records. """ if records: return defer.succeed((records, (), ())) return defer.fail(failure.Failure(dns.DomainError(name))) def lookupAddress(self, name, timeout=None): """ Read any IPv4 addresses from C{self.file} and return them as L{Record_A} instances. """ name = dns.domainString(name) return self._respond(name, self._aRecords(name)) def lookupIPV6Address(self, name, timeout=None): """ Read any IPv6 addresses from C{self.file} and return them as L{Record_AAAA} instances. """ name = dns.domainString(name) return self._respond(name, self._aaaaRecords(name)) # Someday this should include IPv6 addresses too, but that will cause # problems if users of the API (mainly via getHostByName) aren't updated to # know about IPv6 first. # FIXME - getHostByName knows about IPv6 now. lookupAllRecords = lookupAddress PK y�Z.#,��� �� dns.pynu �[��� # -*- test-case-name: twisted.names.test.test_dns -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ DNS protocol implementation. Future Plans: - Get rid of some toplevels, maybe. """ # System imports import inspect import random import socket import struct from io import BytesIO from itertools import chain from typing import Optional, SupportsInt, Union from zope.interface import Attribute, Interface, implementer # Twisted imports from twisted.internet import defer, protocol from twisted.internet.error import CannotListenError from twisted.python import failure, log, randbytes, util as tputil from twisted.python.compat import cmp, comparable, nativeString __all__ = [ "IEncodable", "IRecord", "IEncodableRecord", "A", "A6", "AAAA", "AFSDB", "CNAME", "DNAME", "HINFO", "MAILA", "MAILB", "MB", "MD", "MF", "MG", "MINFO", "MR", "MX", "NAPTR", "NS", "NULL", "OPT", "PTR", "RP", "SOA", "SPF", "SRV", "TXT", "SSHFP", "TSIG", "WKS", "ANY", "CH", "CS", "HS", "IN", "ALL_RECORDS", "AXFR", "IXFR", "EFORMAT", "ENAME", "ENOTIMP", "EREFUSED", "ESERVER", "EBADVERSION", "EBADSIG", "EBADKEY", "EBADTIME", "Record_A", "Record_A6", "Record_AAAA", "Record_AFSDB", "Record_CNAME", "Record_DNAME", "Record_HINFO", "Record_MB", "Record_MD", "Record_MF", "Record_MG", "Record_MINFO", "Record_MR", "Record_MX", "Record_NAPTR", "Record_NS", "Record_NULL", "Record_PTR", "Record_RP", "Record_SOA", "Record_SPF", "Record_SRV", "Record_SSHFP", "Record_TSIG", "Record_TXT", "Record_WKS", "UnknownRecord", "QUERY_CLASSES", "QUERY_TYPES", "REV_CLASSES", "REV_TYPES", "EXT_QUERIES", "Charstr", "Message", "Name", "Query", "RRHeader", "SimpleRecord", "DNSDatagramProtocol", "DNSMixin", "DNSProtocol", "OK", "OP_INVERSE", "OP_NOTIFY", "OP_QUERY", "OP_STATUS", "OP_UPDATE", "PORT", "AuthoritativeDomainError", "DNSQueryTimeoutError", "DomainError", ] AF_INET6 = socket.AF_INET6 def _ord2bytes(ordinal): """ Construct a bytes object representing a single byte with the given ordinal value. @type ordinal: L{int} @rtype: L{bytes} """ return bytes([ordinal]) def _nicebytes(bytes): """ Represent a mostly textful bytes object in a way suitable for presentation to an end user. @param bytes: The bytes to represent. @rtype: L{str} """ return repr(bytes)[1:] def _nicebyteslist(list): """ Represent a list of mostly textful bytes objects in a way suitable for presentation to an end user. @param list: The list of bytes to represent. @rtype: L{str} """ return "[{}]".format(", ".join([_nicebytes(b) for b in list])) def randomSource(): """ Wrapper around L{twisted.python.randbytes.RandomFactory.secureRandom} to return 2 random bytes. @rtype: L{bytes} """ return struct.unpack("H", randbytes.secureRandom(2, fallback=True))[0] PORT = 53 ( A, NS, MD, MF, CNAME, SOA, MB, MG, MR, NULL, WKS, PTR, HINFO, MINFO, MX, TXT, RP, AFSDB, ) = range(1, 19) AAAA = 28 SRV = 33 NAPTR = 35 A6 = 38 DNAME = 39 OPT = 41 SSHFP = 44 SPF = 99 # These record types do not exist in zones, but are transferred in # messages the same way normal RRs are. TKEY = 249 TSIG = 250 QUERY_TYPES = { A: "A", NS: "NS", MD: "MD", MF: "MF", CNAME: "CNAME", SOA: "SOA", MB: "MB", MG: "MG", MR: "MR", NULL: "NULL", WKS: "WKS", PTR: "PTR", HINFO: "HINFO", MINFO: "MINFO", MX: "MX", TXT: "TXT", RP: "RP", AFSDB: "AFSDB", # 19 through 27? Eh, I'll get to 'em. AAAA: "AAAA", SRV: "SRV", NAPTR: "NAPTR", A6: "A6", DNAME: "DNAME", OPT: "OPT", SSHFP: "SSHFP", SPF: "SPF", TKEY: "TKEY", TSIG: "TSIG", } IXFR, AXFR, MAILB, MAILA, ALL_RECORDS = range(251, 256) # "Extended" queries (Hey, half of these are deprecated, good job) EXT_QUERIES = { IXFR: "IXFR", AXFR: "AXFR", MAILB: "MAILB", MAILA: "MAILA", ALL_RECORDS: "ALL_RECORDS", } REV_TYPES = {v: k for (k, v) in chain(QUERY_TYPES.items(), EXT_QUERIES.items())} IN, CS, CH, HS = range(1, 5) ANY = 255 QUERY_CLASSES = {IN: "IN", CS: "CS", CH: "CH", HS: "HS", ANY: "ANY"} REV_CLASSES = {v: k for (k, v) in QUERY_CLASSES.items()} # Opcodes OP_QUERY, OP_INVERSE, OP_STATUS = range(3) OP_NOTIFY = 4 # RFC 1996 OP_UPDATE = 5 # RFC 2136 # Response Codes OK, EFORMAT, ESERVER, ENAME, ENOTIMP, EREFUSED = range(6) # https://tools.ietf.org/html/rfc6891#section-9 EBADVERSION = 16 # RFC 2845 EBADSIG, EBADKEY, EBADTIME = range(16, 19) class IRecord(Interface): """ A single entry in a zone of authority. """ TYPE = Attribute("An indicator of what kind of record this is.") # Backwards compatibility aliases - these should be deprecated or something I # suppose. -exarkun from twisted.names.error import ( AuthoritativeDomainError, DNSQueryTimeoutError, DomainError, ) def _nameToLabels(name): """ Split a domain name into its constituent labels. @type name: L{bytes} @param name: A fully qualified domain name (with or without a trailing dot). @return: A L{list} of labels ending with an empty label representing the DNS root zone. @rtype: L{list} of L{bytes} """ if name in (b"", b"."): return [b""] labels = name.split(b".") if labels[-1] != b"": labels.append(b"") return labels def domainString(domain): """ Coerce a domain name string to bytes. L{twisted.names} represents domain names as L{bytes}, but many interfaces accept L{bytes} or a text string (L{unicode} on Python 2, L{str} on Python 3). This function coerces text strings using IDNA encoding --- see L{encodings.idna}. Note that DNS is I{case insensitive} but I{case preserving}. This function doesn't normalize case, so you'll still need to do that whenever comparing the strings it returns. @param domain: A domain name. If passed as a text string it will be C{idna} encoded. @type domain: L{bytes} or L{str} @returns: L{bytes} suitable for network transmission. @rtype: L{bytes} @since: Twisted 20.3.0 """ if isinstance(domain, str): domain = domain.encode("idna") if not isinstance(domain, bytes): raise TypeError( "Expected {} or {} but found {!r} of type {}".format( bytes.__name__, str.__name__, domain, type(domain) ) ) return domain def _isSubdomainOf(descendantName, ancestorName): """ Test whether C{descendantName} is equal to or is a I{subdomain} of C{ancestorName}. The names are compared case-insensitively. The names are treated as byte strings containing one or more DNS labels separated by B{.}. C{descendantName} is considered equal if its sequence of labels exactly matches the labels of C{ancestorName}. C{descendantName} is considered a I{subdomain} if its sequence of labels ends with the labels of C{ancestorName}. @type descendantName: L{bytes} @param descendantName: The DNS subdomain name. @type ancestorName: L{bytes} @param ancestorName: The DNS parent or ancestor domain name. @return: C{True} if C{descendantName} is equal to or if it is a subdomain of C{ancestorName}. Otherwise returns C{False}. """ descendantLabels = _nameToLabels(descendantName.lower()) ancestorLabels = _nameToLabels(ancestorName.lower()) return descendantLabels[-len(ancestorLabels) :] == ancestorLabels def str2time(s): """ Parse a string description of an interval into an integer number of seconds. @param s: An interval definition constructed as an interval duration followed by an interval unit. An interval duration is a base ten representation of an integer. An interval unit is one of the following letters: S (seconds), M (minutes), H (hours), D (days), W (weeks), or Y (years). For example: C{"3S"} indicates an interval of three seconds; C{"5D"} indicates an interval of five days. Alternatively, C{s} may be any non-string and it will be returned unmodified. @type s: text string (L{bytes} or L{str}) for parsing; anything else for passthrough. @return: an L{int} giving the interval represented by the string C{s}, or whatever C{s} is if it is not a string. """ suffixes = ( ("S", 1), ("M", 60), ("H", 60 * 60), ("D", 60 * 60 * 24), ("W", 60 * 60 * 24 * 7), ("Y", 60 * 60 * 24 * 365), ) if isinstance(s, bytes): s = s.decode("ascii") if isinstance(s, str): s = s.upper().strip() for (suff, mult) in suffixes: if s.endswith(suff): return int(float(s[:-1]) * mult) try: s = int(s) except ValueError: raise ValueError("Invalid time interval specifier: " + s) return s def readPrecisely(file, l): buff = file.read(l) if len(buff) < l: raise EOFError return buff class IEncodable(Interface): """ Interface for something which can be encoded to and decoded to the DNS wire format. A binary-mode file object (such as L{io.BytesIO}) is used as a buffer when encoding or decoding. """ def encode(strio, compDict=None): """ Write a representation of this object to the given file object. @type strio: File-like object @param strio: The buffer to write to. It must have a C{tell()} method. @type compDict: L{dict} of L{bytes} to L{int} r L{None} @param compDict: A mapping of names to byte offsets that have already been written to the buffer, which may be used for compression (see RFC 1035 section 4.1.4). When L{None}, encode without compression. """ def decode(strio, length=None): """ Reconstruct an object from data read from the given file object. @type strio: File-like object @param strio: A seekable buffer from which bytes may be read. @type length: L{int} or L{None} @param length: The number of bytes in this RDATA field. Most implementations can ignore this value. Only in the case of records similar to TXT where the total length is in no way encoded in the data is it necessary. """ class IEncodableRecord(IEncodable, IRecord): """ Interface for DNS records that can be encoded and decoded. @since: Twisted 21.2.0 """ @implementer(IEncodable) class Charstr: def __init__(self, string=b""): if not isinstance(string, bytes): raise ValueError(f"{string!r} is not a byte string") self.string = string def encode(self, strio, compDict=None): """ Encode this Character string into the appropriate byte format. @type strio: file @param strio: The byte representation of this Charstr will be written to this file. """ string = self.string ind = len(string) strio.write(_ord2bytes(ind)) strio.write(string) def decode(self, strio, length=None): """ Decode a byte string into this Charstr. @type strio: file @param strio: Bytes will be read from this file until the full string is decoded. @raise EOFError: Raised when there are not enough bytes available from C{strio}. """ self.string = b"" l = ord(readPrecisely(strio, 1)) self.string = readPrecisely(strio, l) def __eq__(self, other: object) -> bool: if isinstance(other, Charstr): return self.string == other.string return NotImplemented def __hash__(self): return hash(self.string) def __str__(self) -> str: """ Represent this L{Charstr} instance by its string value. """ return nativeString(self.string) @implementer(IEncodable) class Name: """ A name in the domain name system, made up of multiple labels. For example, I{twistedmatrix.com}. @ivar name: A byte string giving the name. @type name: L{bytes} """ def __init__(self, name=b""): """ @param name: A name. @type name: L{bytes} or L{str} """ self.name = domainString(name) def encode(self, strio, compDict=None): """ Encode this Name into the appropriate byte format. @type strio: file @param strio: The byte representation of this Name will be written to this file. @type compDict: dict @param compDict: dictionary of Names that have already been encoded and whose addresses may be backreferenced by this Name (for the purpose of reducing the message size). """ name = self.name while name: if compDict is not None: if name in compDict: strio.write(struct.pack("!H", 0xC000 | compDict[name])) return else: compDict[name] = strio.tell() + Message.headerSize ind = name.find(b".") if ind > 0: label, name = name[:ind], name[ind + 1 :] else: # This is the last label, end the loop after handling it. label = name name = None ind = len(label) strio.write(_ord2bytes(ind)) strio.write(label) strio.write(b"\x00") def decode(self, strio, length=None): """ Decode a byte string into this Name. @type strio: file @param strio: Bytes will be read from this file until the full Name is decoded. @raise EOFError: Raised when there are not enough bytes available from C{strio}. @raise ValueError: Raised when the name cannot be decoded (for example, because it contains a loop). """ visited = set() self.name = b"" off = 0 while 1: l = ord(readPrecisely(strio, 1)) if l == 0: if off > 0: strio.seek(off) return if (l >> 6) == 3: new_off = (l & 63) << 8 | ord(readPrecisely(strio, 1)) if new_off in visited: raise ValueError("Compression loop in encoded name") visited.add(new_off) if off == 0: off = strio.tell() strio.seek(new_off) continue label = readPrecisely(strio, l) if self.name == b"": self.name = label else: self.name = self.name + b"." + label def __eq__(self, other: object) -> bool: if isinstance(other, Name): return self.name.lower() == other.name.lower() return NotImplemented def __hash__(self): return hash(self.name) def __str__(self) -> str: """ Represent this L{Name} instance by its string name. """ return nativeString(self.name) @comparable @implementer(IEncodable) class Query: """ Represent a single DNS query. @ivar name: The name about which this query is requesting information. @type name: L{Name} @ivar type: The query type. @type type: L{int} @ivar cls: The query class. @type cls: L{int} """ def __init__(self, name: Union[bytes, str] = b"", type: int = A, cls: int = IN): """ @type name: L{bytes} or L{str} @param name: See L{Query.name} @type type: L{int} @param type: The query type. @type cls: L{int} @param cls: The query class. """ self.name = Name(name) self.type = type self.cls = cls def encode(self, strio, compDict=None): self.name.encode(strio, compDict) strio.write(struct.pack("!HH", self.type, self.cls)) def decode(self, strio, length=None): self.name.decode(strio) buff = readPrecisely(strio, 4) self.type, self.cls = struct.unpack("!HH", buff) def __hash__(self): return hash((self.name.name.lower(), self.type, self.cls)) def __cmp__(self, other): if isinstance(other, Query): return cmp( (self.name.name.lower(), self.type, self.cls), (other.name.name.lower(), other.type, other.cls), ) return NotImplemented def __str__(self) -> str: t = QUERY_TYPES.get( self.type, EXT_QUERIES.get(self.type, "UNKNOWN (%d)" % self.type) ) c = QUERY_CLASSES.get(self.cls, "UNKNOWN (%d)" % self.cls) return f"<Query {self.name} {t} {c}>" def __repr__(self) -> str: return f"Query({self.name.name!r}, {self.type!r}, {self.cls!r})" @implementer(IEncodable) class _OPTHeader(tputil.FancyStrMixin, tputil.FancyEqMixin): """ An OPT record header. @ivar name: The DNS name associated with this record. Since this is a pseudo record, the name is always an L{Name} instance with value b'', which represents the DNS root zone. This attribute is a readonly property. @ivar type: The DNS record type. This is a fixed value of 41 C{dns.OPT} for OPT Record. This attribute is a readonly property. @see: L{_OPTHeader.__init__} for documentation of other public instance attributes. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2} @since: 13.2 """ showAttributes = ( ("name", lambda n: nativeString(n.name)), "type", "udpPayloadSize", "extendedRCODE", "version", "dnssecOK", "options", ) compareAttributes = ( "name", "type", "udpPayloadSize", "extendedRCODE", "version", "dnssecOK", "options", ) def __init__( self, udpPayloadSize=4096, extendedRCODE=0, version=0, dnssecOK=False, options=None, ): """ @type udpPayloadSize: L{int} @param udpPayloadSize: The number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type extendedRCODE: L{int} @param extendedRCODE: Forms the upper 8 bits of extended 12-bit RCODE (together with the 4 bits defined in [RFC1035]. Note that EXTENDED-RCODE value 0 indicates that an unextended RCODE is in use (values 0 through 15). @type version: L{int} @param version: Indicates the implementation level of the setter. Full conformance with this specification is indicated by version C{0}. @type dnssecOK: L{bool} @param dnssecOK: DNSSEC OK bit as defined by [RFC3225]. @type options: L{list} @param options: A L{list} of 0 or more L{_OPTVariableOption} instances. """ self.udpPayloadSize = udpPayloadSize self.extendedRCODE = extendedRCODE self.version = version self.dnssecOK = dnssecOK if options is None: options = [] self.options = options @property def name(self): """ A readonly property for accessing the C{name} attribute of this record. @return: The DNS name associated with this record. Since this is a pseudo record, the name is always an L{Name} instance with value b'', which represents the DNS root zone. """ return Name(b"") @property def type(self): """ A readonly property for accessing the C{type} attribute of this record. @return: The DNS record type. This is a fixed value of 41 (C{dns.OPT} for OPT Record. """ return OPT def encode(self, strio, compDict=None): """ Encode this L{_OPTHeader} instance to bytes. @type strio: file @param strio: the byte representation of this L{_OPTHeader} will be written to this file. @type compDict: L{dict} or L{None} @param compDict: A dictionary of backreference addresses that have already been written to this stream and that may be used for DNS name compression. """ b = BytesIO() for o in self.options: o.encode(b) optionBytes = b.getvalue() RRHeader( name=self.name.name, type=self.type, cls=self.udpPayloadSize, ttl=(self.extendedRCODE << 24 | self.version << 16 | self.dnssecOK << 15), payload=UnknownRecord(optionBytes), ).encode(strio, compDict) def decode(self, strio, length=None): """ Decode bytes into an L{_OPTHeader} instance. @type strio: file @param strio: Bytes will be read from this file until the full L{_OPTHeader} is decoded. @type length: L{int} or L{None} @param length: Not used. """ h = RRHeader() h.decode(strio, length) h.payload = UnknownRecord(readPrecisely(strio, h.rdlength)) newOptHeader = self.fromRRHeader(h) for attrName in self.compareAttributes: if attrName not in ("name", "type"): setattr(self, attrName, getattr(newOptHeader, attrName)) @classmethod def fromRRHeader(cls, rrHeader): """ A classmethod for constructing a new L{_OPTHeader} from the attributes and payload of an existing L{RRHeader} instance. @type rrHeader: L{RRHeader} @param rrHeader: An L{RRHeader} instance containing an L{UnknownRecord} payload. @return: An instance of L{_OPTHeader}. @rtype: L{_OPTHeader} """ options = None if rrHeader.payload is not None: options = [] optionsBytes = BytesIO(rrHeader.payload.data) optionsBytesLength = len(rrHeader.payload.data) while optionsBytes.tell() < optionsBytesLength: o = _OPTVariableOption() o.decode(optionsBytes) options.append(o) # Decode variable options if present return cls( udpPayloadSize=rrHeader.cls, extendedRCODE=rrHeader.ttl >> 24, version=rrHeader.ttl >> 16 & 0xFF, dnssecOK=(rrHeader.ttl & 0xFFFF) >> 15, options=options, ) @implementer(IEncodable) class _OPTVariableOption(tputil.FancyStrMixin, tputil.FancyEqMixin): """ A class to represent OPT record variable options. @see: L{_OPTVariableOption.__init__} for documentation of public instance attributes. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2} @since: 13.2 """ showAttributes = ("code", ("data", nativeString)) compareAttributes = ("code", "data") _fmt = "!HH" def __init__(self, code=0, data=b""): """ @type code: L{int} @param code: The option code @type data: L{bytes} @param data: The option data """ self.code = code self.data = data def encode(self, strio, compDict=None): """ Encode this L{_OPTVariableOption} to bytes. @type strio: file @param strio: the byte representation of this L{_OPTVariableOption} will be written to this file. @type compDict: L{dict} or L{None} @param compDict: A dictionary of backreference addresses that have already been written to this stream and that may be used for DNS name compression. """ strio.write(struct.pack(self._fmt, self.code, len(self.data)) + self.data) def decode(self, strio, length=None): """ Decode bytes into an L{_OPTVariableOption} instance. @type strio: file @param strio: Bytes will be read from this file until the full L{_OPTVariableOption} is decoded. @type length: L{int} or L{None} @param length: Not used. """ l = struct.calcsize(self._fmt) buff = readPrecisely(strio, l) self.code, length = struct.unpack(self._fmt, buff) self.data = readPrecisely(strio, length) @implementer(IEncodable) class RRHeader(tputil.FancyEqMixin): """ A resource record header. @cvar fmt: L{str} specifying the byte format of an RR. @ivar name: The name about which this reply contains information. @type name: L{Name} @ivar type: The query type of the original request. @type type: L{int} @ivar cls: The query class of the original request. @ivar ttl: The time-to-live for this record. @type ttl: L{int} @ivar payload: The record described by this header. @type payload: L{IEncodableRecord} or L{None} @ivar auth: A L{bool} indicating whether this C{RRHeader} was parsed from an authoritative message. """ compareAttributes = ("name", "type", "cls", "ttl", "payload", "auth") fmt = "!HHIH" rdlength = None cachedResponse = None def __init__( self, name: Union[bytes, str] = b"", type: int = A, cls: int = IN, ttl: SupportsInt = 0, payload: Optional[IEncodableRecord] = None, auth: bool = False, ): """ @type name: L{bytes} or L{str} @param name: See L{RRHeader.name} @type type: L{int} @param type: The query type. @type cls: L{int} @param cls: The query class. @type ttl: L{int} @param ttl: Time to live for this record. This will be converted to an L{int}. @type payload: L{IEncodableRecord} or L{None} @param payload: An optional Query Type specific data object. @raises TypeError: if the ttl cannot be converted to an L{int}. @raises ValueError: if the ttl is negative. @raises ValueError: if the payload type is not equal to the C{type} argument. """ payloadType = None if payload is None else payload.TYPE if payloadType is not None and payloadType != type: raise ValueError( "Payload type (%s) does not match given type (%s)" % ( QUERY_TYPES.get(payloadType, payloadType), QUERY_TYPES.get(type, type), ) ) integralTTL = int(ttl) if integralTTL < 0: raise ValueError("TTL cannot be negative") self.name = Name(name) self.type = type self.cls = cls self.ttl = integralTTL self.payload = payload self.auth = auth def encode(self, strio, compDict=None): self.name.encode(strio, compDict) strio.write(struct.pack(self.fmt, self.type, self.cls, self.ttl, 0)) if self.payload: prefix = strio.tell() self.payload.encode(strio, compDict) aft = strio.tell() strio.seek(prefix - 2, 0) strio.write(struct.pack("!H", aft - prefix)) strio.seek(aft, 0) def decode(self, strio, length=None): self.name.decode(strio) l = struct.calcsize(self.fmt) buff = readPrecisely(strio, l) r = struct.unpack(self.fmt, buff) self.type, self.cls, self.ttl, self.rdlength = r def isAuthoritative(self): return self.auth def __str__(self) -> str: t = QUERY_TYPES.get( self.type, EXT_QUERIES.get(self.type, "UNKNOWN (%d)" % self.type) ) c = QUERY_CLASSES.get(self.cls, "UNKNOWN (%d)" % self.cls) return "<RR name=%s type=%s class=%s ttl=%ds auth=%s>" % ( self.name, t, c, self.ttl, self.auth and "True" or "False", ) __repr__ = __str__ @implementer(IEncodableRecord) class SimpleRecord(tputil.FancyStrMixin, tputil.FancyEqMixin): """ A Resource Record which consists of a single RFC 1035 domain-name. @type name: L{Name} @ivar name: The name associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ showAttributes = (("name", "name", "%s"), "ttl") compareAttributes = ("name", "ttl") TYPE: Optional[int] = None name = None def __init__(self, name=b"", ttl=None): """ @param name: See L{SimpleRecord.name} @type name: L{bytes} or L{str} """ self.name = Name(name) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): self.name.encode(strio, compDict) def decode(self, strio, length=None): self.name = Name() self.name.decode(strio) def __hash__(self): return hash(self.name) # Kinds of RRs - oh my! class Record_NS(SimpleRecord): """ An authoritative nameserver. """ TYPE = NS fancybasename = "NS" class Record_MD(SimpleRecord): """ A mail destination. This record type is obsolete. @see: L{Record_MX} """ TYPE = MD fancybasename = "MD" class Record_MF(SimpleRecord): """ A mail forwarder. This record type is obsolete. @see: L{Record_MX} """ TYPE = MF fancybasename = "MF" class Record_CNAME(SimpleRecord): """ The canonical name for an alias. """ TYPE = CNAME fancybasename = "CNAME" class Record_MB(SimpleRecord): """ A mailbox domain name. This is an experimental record type. """ TYPE = MB fancybasename = "MB" class Record_MG(SimpleRecord): """ A mail group member. This is an experimental record type. """ TYPE = MG fancybasename = "MG" class Record_MR(SimpleRecord): """ A mail rename domain name. This is an experimental record type. """ TYPE = MR fancybasename = "MR" class Record_PTR(SimpleRecord): """ A domain name pointer. """ TYPE = PTR fancybasename = "PTR" class Record_DNAME(SimpleRecord): """ A non-terminal DNS name redirection. This record type provides the capability to map an entire subtree of the DNS name space to another domain. It differs from the CNAME record which maps a single node of the name space. @see: U{http://www.faqs.org/rfcs/rfc2672.html} @see: U{http://www.faqs.org/rfcs/rfc3363.html} """ TYPE = DNAME fancybasename = "DNAME" @implementer(IEncodableRecord) class Record_A(tputil.FancyEqMixin): """ An IPv4 host address. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv4 address associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ compareAttributes = ("address", "ttl") TYPE = A address = None def __init__(self, address="0.0.0.0", ttl=None): """ @type address: L{bytes} or L{str} @param address: The IPv4 address associated with this record, in quad-dotted notation. """ if isinstance(address, bytes): address = address.decode("ascii") address = socket.inet_aton(address) self.address = address self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(self.address) def decode(self, strio, length=None): self.address = readPrecisely(strio, 4) def __hash__(self): return hash(self.address) def __str__(self) -> str: return f"<A address={self.dottedQuad()} ttl={self.ttl}>" __repr__ = __str__ def dottedQuad(self): return socket.inet_ntoa(self.address) @implementer(IEncodableRecord) class Record_SOA(tputil.FancyEqMixin, tputil.FancyStrMixin): """ Marks the start of a zone of authority. This record describes parameters which are shared by all records within a particular zone. @type mname: L{Name} @ivar mname: The domain-name of the name server that was the original or primary source of data for this zone. @type rname: L{Name} @ivar rname: A domain-name which specifies the mailbox of the person responsible for this zone. @type serial: L{int} @ivar serial: The unsigned 32 bit version number of the original copy of the zone. Zone transfers preserve this value. This value wraps and should be compared using sequence space arithmetic. @type refresh: L{int} @ivar refresh: A 32 bit time interval before the zone should be refreshed. @type minimum: L{int} @ivar minimum: The unsigned 32 bit minimum TTL field that should be exported with any RR from this zone. @type expire: L{int} @ivar expire: A 32 bit time value that specifies the upper limit on the time interval that can elapse before the zone is no longer authoritative. @type retry: L{int} @ivar retry: A 32 bit time interval that should elapse before a failed refresh should be retried. @type ttl: L{int} @ivar ttl: The default TTL to use for records served from this zone. """ fancybasename = "SOA" compareAttributes = ( "serial", "mname", "rname", "refresh", "expire", "retry", "minimum", "ttl", ) showAttributes = ( ("mname", "mname", "%s"), ("rname", "rname", "%s"), "serial", "refresh", "retry", "expire", "minimum", "ttl", ) TYPE = SOA def __init__( self, mname=b"", rname=b"", serial=0, refresh=0, retry=0, expire=0, minimum=0, ttl=None, ): """ @param mname: See L{Record_SOA.mname} @type mname: L{bytes} or L{str} @param rname: See L{Record_SOA.rname} @type rname: L{bytes} or L{str} """ self.mname, self.rname = Name(mname), Name(rname) self.serial, self.refresh = str2time(serial), str2time(refresh) self.minimum, self.expire = str2time(minimum), str2time(expire) self.retry = str2time(retry) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): self.mname.encode(strio, compDict) self.rname.encode(strio, compDict) strio.write( struct.pack( "!LlllL", self.serial, self.refresh, self.retry, self.expire, self.minimum, ) ) def decode(self, strio, length=None): self.mname, self.rname = Name(), Name() self.mname.decode(strio) self.rname.decode(strio) r = struct.unpack("!LlllL", readPrecisely(strio, 20)) self.serial, self.refresh, self.retry, self.expire, self.minimum = r def __hash__(self): return hash( (self.serial, self.mname, self.rname, self.refresh, self.expire, self.retry) ) @implementer(IEncodableRecord) class Record_NULL(tputil.FancyStrMixin, tputil.FancyEqMixin): """ A null record. This is an experimental record type. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ fancybasename = "NULL" showAttributes = (("payload", _nicebytes), "ttl") compareAttributes = ("payload", "ttl") TYPE = NULL def __init__(self, payload=None, ttl=None): self.payload = payload self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(self.payload) def decode(self, strio, length=None): self.payload = readPrecisely(strio, length) def __hash__(self): return hash(self.payload) @implementer(IEncodableRecord) class Record_WKS(tputil.FancyEqMixin, tputil.FancyStrMixin): """ A well known service description. This record type is obsolete. See L{Record_SRV}. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv4 address associated with this record. @type protocol: L{int} @ivar protocol: The 8 bit IP protocol number for which this service map is relevant. @type map: L{bytes} @ivar map: A bitvector indicating the services available at the specified address. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ fancybasename = "WKS" compareAttributes = ("address", "protocol", "map", "ttl") showAttributes = [("_address", "address", "%s"), "protocol", "ttl"] TYPE = WKS @property def _address(self): return socket.inet_ntoa(self.address) def __init__(self, address="0.0.0.0", protocol=0, map=b"", ttl=None): """ @type address: L{bytes} or L{str} @param address: The IPv4 address associated with this record, in quad-dotted notation. """ if isinstance(address, bytes): address = address.decode("idna") self.address = socket.inet_aton(address) self.protocol, self.map = protocol, map self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(self.address) strio.write(struct.pack("!B", self.protocol)) strio.write(self.map) def decode(self, strio, length=None): self.address = readPrecisely(strio, 4) self.protocol = struct.unpack("!B", readPrecisely(strio, 1))[0] self.map = readPrecisely(strio, length - 5) def __hash__(self): return hash((self.address, self.protocol, self.map)) @implementer(IEncodableRecord) class Record_AAAA(tputil.FancyEqMixin, tputil.FancyStrMixin): """ An IPv6 host address. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv6 address associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1886.html} """ TYPE = AAAA fancybasename = "AAAA" showAttributes = (("_address", "address", "%s"), "ttl") compareAttributes = ("address", "ttl") @property def _address(self): return socket.inet_ntop(AF_INET6, self.address) def __init__(self, address="::", ttl=None): """ @type address: L{bytes} or L{str} @param address: The IPv6 address for this host, in RFC 2373 format. """ if isinstance(address, bytes): address = address.decode("idna") self.address = socket.inet_pton(AF_INET6, address) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(self.address) def decode(self, strio, length=None): self.address = readPrecisely(strio, 16) def __hash__(self): return hash(self.address) @implementer(IEncodableRecord) class Record_A6(tputil.FancyStrMixin, tputil.FancyEqMixin): """ An IPv6 address. This is an experimental record type. @type prefixLen: L{int} @ivar prefixLen: The length of the suffix. @type suffix: L{bytes} @ivar suffix: An IPv6 address suffix in network order. @type prefix: L{Name} @ivar prefix: If specified, a name which will be used as a prefix for other A6 records. @type bytes: L{int} @ivar bytes: The length of the prefix. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2874.html} @see: U{http://www.faqs.org/rfcs/rfc3363.html} @see: U{http://www.faqs.org/rfcs/rfc3364.html} """ TYPE = A6 fancybasename = "A6" showAttributes = (("_suffix", "suffix", "%s"), ("prefix", "prefix", "%s"), "ttl") compareAttributes = ("prefixLen", "prefix", "suffix", "ttl") @property def _suffix(self): return socket.inet_ntop(AF_INET6, self.suffix) def __init__(self, prefixLen=0, suffix="::", prefix=b"", ttl=None): """ @param suffix: An IPv6 address suffix in in RFC 2373 format. @type suffix: L{bytes} or L{str} @param prefix: An IPv6 address prefix for other A6 records. @type prefix: L{bytes} or L{str} """ if isinstance(suffix, bytes): suffix = suffix.decode("idna") self.prefixLen = prefixLen self.suffix = socket.inet_pton(AF_INET6, suffix) self.prefix = Name(prefix) self.bytes = int((128 - self.prefixLen) / 8.0) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!B", self.prefixLen)) if self.bytes: strio.write(self.suffix[-self.bytes :]) if self.prefixLen: # This may not be compressed self.prefix.encode(strio, None) def decode(self, strio, length=None): self.prefixLen = struct.unpack("!B", readPrecisely(strio, 1))[0] self.bytes = int((128 - self.prefixLen) / 8.0) if self.bytes: self.suffix = b"\x00" * (16 - self.bytes) + readPrecisely(strio, self.bytes) if self.prefixLen: self.prefix.decode(strio) def __eq__(self, other: object) -> bool: if isinstance(other, Record_A6): return ( self.prefixLen == other.prefixLen and self.suffix[-self.bytes :] == other.suffix[-self.bytes :] and self.prefix == other.prefix and self.ttl == other.ttl ) return NotImplemented def __hash__(self): return hash((self.prefixLen, self.suffix[-self.bytes :], self.prefix)) def __str__(self) -> str: return "<A6 %s %s (%d) ttl=%s>" % ( self.prefix, socket.inet_ntop(AF_INET6, self.suffix), self.prefixLen, self.ttl, ) @implementer(IEncodableRecord) class Record_SRV(tputil.FancyEqMixin, tputil.FancyStrMixin): """ The location of the server(s) for a specific protocol and domain. This is an experimental record type. @type priority: L{int} @ivar priority: The priority of this target host. A client MUST attempt to contact the target host with the lowest-numbered priority it can reach; target hosts with the same priority SHOULD be tried in an order defined by the weight field. @type weight: L{int} @ivar weight: Specifies a relative weight for entries with the same priority. Larger weights SHOULD be given a proportionately higher probability of being selected. @type port: L{int} @ivar port: The port on this target host of this service. @type target: L{Name} @ivar target: The domain name of the target host. There MUST be one or more address records for this name, the name MUST NOT be an alias (in the sense of RFC 1034 or RFC 2181). Implementors are urged, but not required, to return the address record(s) in the Additional Data section. Unless and until permitted by future standards action, name compression is not to be used for this field. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2782.html} """ TYPE = SRV fancybasename = "SRV" compareAttributes = ("priority", "weight", "target", "port", "ttl") showAttributes = ("priority", "weight", ("target", "target", "%s"), "port", "ttl") def __init__(self, priority=0, weight=0, port=0, target=b"", ttl=None): """ @param target: See L{Record_SRV.target} @type target: L{bytes} or L{str} """ self.priority = int(priority) self.weight = int(weight) self.port = int(port) self.target = Name(target) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!HHH", self.priority, self.weight, self.port)) # This can't be compressed self.target.encode(strio, None) def decode(self, strio, length=None): r = struct.unpack("!HHH", readPrecisely(strio, struct.calcsize("!HHH"))) self.priority, self.weight, self.port = r self.target = Name() self.target.decode(strio) def __hash__(self): return hash((self.priority, self.weight, self.port, self.target)) @implementer(IEncodableRecord) class Record_NAPTR(tputil.FancyEqMixin, tputil.FancyStrMixin): """ The location of the server(s) for a specific protocol and domain. @type order: L{int} @ivar order: An integer specifying the order in which the NAPTR records MUST be processed to ensure the correct ordering of rules. Low numbers are processed before high numbers. @type preference: L{int} @ivar preference: An integer that specifies the order in which NAPTR records with equal "order" values SHOULD be processed, low numbers being processed before high numbers. @type flag: L{Charstr} @ivar flag: A <character-string> containing flags to control aspects of the rewriting and interpretation of the fields in the record. Flags are single characters from the set [A-Z0-9]. The case of the alphabetic characters is not significant. At this time only four flags, "S", "A", "U", and "P", are defined. @type service: L{Charstr} @ivar service: Specifies the service(s) available down this rewrite path. It may also specify the particular protocol that is used to talk with a service. A protocol MUST be specified if the flags field states that the NAPTR is terminal. @type regexp: L{Charstr} @ivar regexp: A STRING containing a substitution expression that is applied to the original string held by the client in order to construct the next domain name to lookup. @type replacement: L{Name} @ivar replacement: The next NAME to query for NAPTR, SRV, or address records depending on the value of the flags field. This MUST be a fully qualified domain-name. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2915.html} """ TYPE = NAPTR compareAttributes = ( "order", "preference", "flags", "service", "regexp", "replacement", ) fancybasename = "NAPTR" showAttributes = ( "order", "preference", ("flags", "flags", "%s"), ("service", "service", "%s"), ("regexp", "regexp", "%s"), ("replacement", "replacement", "%s"), "ttl", ) def __init__( self, order=0, preference=0, flags=b"", service=b"", regexp=b"", replacement=b"", ttl=None, ): """ @param replacement: See L{Record_NAPTR.replacement} @type replacement: L{bytes} or L{str} """ self.order = int(order) self.preference = int(preference) self.flags = Charstr(flags) self.service = Charstr(service) self.regexp = Charstr(regexp) self.replacement = Name(replacement) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!HH", self.order, self.preference)) # This can't be compressed self.flags.encode(strio, None) self.service.encode(strio, None) self.regexp.encode(strio, None) self.replacement.encode(strio, None) def decode(self, strio, length=None): r = struct.unpack("!HH", readPrecisely(strio, struct.calcsize("!HH"))) self.order, self.preference = r self.flags = Charstr() self.service = Charstr() self.regexp = Charstr() self.replacement = Name() self.flags.decode(strio) self.service.decode(strio) self.regexp.decode(strio) self.replacement.decode(strio) def __hash__(self): return hash( ( self.order, self.preference, self.flags, self.service, self.regexp, self.replacement, ) ) @implementer(IEncodableRecord) class Record_AFSDB(tputil.FancyStrMixin, tputil.FancyEqMixin): """ Map from a domain name to the name of an AFS cell database server. @type subtype: L{int} @ivar subtype: In the case of subtype 1, the host has an AFS version 3.0 Volume Location Server for the named AFS cell. In the case of subtype 2, the host has an authenticated name server holding the cell-root directory node for the named DCE/NCA cell. @type hostname: L{Name} @ivar hostname: The domain name of a host that has a server for the cell named by this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1183.html} """ TYPE = AFSDB fancybasename = "AFSDB" compareAttributes = ("subtype", "hostname", "ttl") showAttributes = ("subtype", ("hostname", "hostname", "%s"), "ttl") def __init__(self, subtype=0, hostname=b"", ttl=None): """ @param hostname: See L{Record_AFSDB.hostname} @type hostname: L{bytes} or L{str} """ self.subtype = int(subtype) self.hostname = Name(hostname) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!H", self.subtype)) self.hostname.encode(strio, compDict) def decode(self, strio, length=None): r = struct.unpack("!H", readPrecisely(strio, struct.calcsize("!H"))) (self.subtype,) = r self.hostname.decode(strio) def __hash__(self): return hash((self.subtype, self.hostname)) @implementer(IEncodableRecord) class Record_RP(tputil.FancyEqMixin, tputil.FancyStrMixin): """ The responsible person for a domain. @type mbox: L{Name} @ivar mbox: A domain name that specifies the mailbox for the responsible person. @type txt: L{Name} @ivar txt: A domain name for which TXT RR's exist (indirection through which allows information sharing about the contents of this RP record). @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1183.html} """ TYPE = RP fancybasename = "RP" compareAttributes = ("mbox", "txt", "ttl") showAttributes = (("mbox", "mbox", "%s"), ("txt", "txt", "%s"), "ttl") def __init__(self, mbox=b"", txt=b"", ttl=None): """ @param mbox: See L{Record_RP.mbox}. @type mbox: L{bytes} or L{str} @param txt: See L{Record_RP.txt} @type txt: L{bytes} or L{str} """ self.mbox = Name(mbox) self.txt = Name(txt) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): self.mbox.encode(strio, compDict) self.txt.encode(strio, compDict) def decode(self, strio, length=None): self.mbox = Name() self.txt = Name() self.mbox.decode(strio) self.txt.decode(strio) def __hash__(self): return hash((self.mbox, self.txt)) @implementer(IEncodableRecord) class Record_HINFO(tputil.FancyStrMixin, tputil.FancyEqMixin): """ Host information. @type cpu: L{bytes} @ivar cpu: Specifies the CPU type. @type os: L{bytes} @ivar os: Specifies the OS. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = HINFO fancybasename = "HINFO" showAttributes = (("cpu", _nicebytes), ("os", _nicebytes), "ttl") compareAttributes = ("cpu", "os", "ttl") def __init__(self, cpu=b"", os=b"", ttl=None): self.cpu, self.os = cpu, os self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!B", len(self.cpu)) + self.cpu) strio.write(struct.pack("!B", len(self.os)) + self.os) def decode(self, strio, length=None): cpu = struct.unpack("!B", readPrecisely(strio, 1))[0] self.cpu = readPrecisely(strio, cpu) os = struct.unpack("!B", readPrecisely(strio, 1))[0] self.os = readPrecisely(strio, os) def __eq__(self, other: object) -> bool: if isinstance(other, Record_HINFO): return ( self.os.lower() == other.os.lower() and self.cpu.lower() == other.cpu.lower() and self.ttl == other.ttl ) return NotImplemented def __hash__(self): return hash((self.os.lower(), self.cpu.lower())) @implementer(IEncodableRecord) class Record_MINFO(tputil.FancyEqMixin, tputil.FancyStrMixin): """ Mailbox or mail list information. This is an experimental record type. @type rmailbx: L{Name} @ivar rmailbx: A domain-name which specifies a mailbox which is responsible for the mailing list or mailbox. If this domain name names the root, the owner of the MINFO RR is responsible for itself. @type emailbx: L{Name} @ivar emailbx: A domain-name which specifies a mailbox which is to receive error messages related to the mailing list or mailbox specified by the owner of the MINFO record. If this domain name names the root, errors should be returned to the sender of the message. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = MINFO rmailbx = None emailbx = None fancybasename = "MINFO" compareAttributes = ("rmailbx", "emailbx", "ttl") showAttributes = ( ("rmailbx", "responsibility", "%s"), ("emailbx", "errors", "%s"), "ttl", ) def __init__(self, rmailbx=b"", emailbx=b"", ttl=None): """ @param rmailbx: See L{Record_MINFO.rmailbx}. @type rmailbx: L{bytes} or L{str} @param emailbx: See L{Record_MINFO.rmailbx}. @type emailbx: L{bytes} or L{str} """ self.rmailbx, self.emailbx = Name(rmailbx), Name(emailbx) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): self.rmailbx.encode(strio, compDict) self.emailbx.encode(strio, compDict) def decode(self, strio, length=None): self.rmailbx, self.emailbx = Name(), Name() self.rmailbx.decode(strio) self.emailbx.decode(strio) def __hash__(self): return hash((self.rmailbx, self.emailbx)) @implementer(IEncodableRecord) class Record_MX(tputil.FancyStrMixin, tputil.FancyEqMixin): """ Mail exchange. @type preference: L{int} @ivar preference: Specifies the preference given to this RR among others at the same owner. Lower values are preferred. @type name: L{Name} @ivar name: A domain-name which specifies a host willing to act as a mail exchange. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = MX fancybasename = "MX" compareAttributes = ("preference", "name", "ttl") showAttributes = ("preference", ("name", "name", "%s"), "ttl") def __init__(self, preference=0, name=b"", ttl=None, **kwargs): """ @param name: See L{Record_MX.name}. @type name: L{bytes} or L{str} """ self.preference = int(preference) self.name = Name(kwargs.get("exchange", name)) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!H", self.preference)) self.name.encode(strio, compDict) def decode(self, strio, length=None): self.preference = struct.unpack("!H", readPrecisely(strio, 2))[0] self.name = Name() self.name.decode(strio) def __hash__(self): return hash((self.preference, self.name)) @implementer(IEncodableRecord) class Record_SSHFP(tputil.FancyEqMixin, tputil.FancyStrMixin): """ A record containing the fingerprint of an SSH key. @type algorithm: L{int} @ivar algorithm: The SSH key's algorithm, such as L{ALGORITHM_RSA}. Note that the numbering used for SSH key algorithms is specific to the SSHFP record, and is not the same as the numbering used for KEY or SIG records. @type fingerprintType: L{int} @ivar fingerprintType: The fingerprint type, such as L{FINGERPRINT_TYPE_SHA256}. @type fingerprint: L{bytes} @ivar fingerprint: The key's fingerprint, e.g. a 32-byte SHA-256 digest. @cvar ALGORITHM_RSA: The algorithm value for C{ssh-rsa} keys. @cvar ALGORITHM_DSS: The algorithm value for C{ssh-dss} keys. @cvar ALGORITHM_ECDSA: The algorithm value for C{ecdsa-sha2-*} keys. @cvar ALGORITHM_Ed25519: The algorithm value for C{ed25519} keys. @cvar FINGERPRINT_TYPE_SHA1: The type for SHA-1 fingerprints. @cvar FINGERPRINT_TYPE_SHA256: The type for SHA-256 fingerprints. @see: U{RFC 4255 <https://tools.ietf.org/html/rfc4255>} and U{RFC 6594 <https://tools.ietf.org/html/rfc6594>} """ fancybasename = "SSHFP" compareAttributes = ("algorithm", "fingerprintType", "fingerprint", "ttl") showAttributes = ("algorithm", "fingerprintType", "fingerprint") TYPE = SSHFP ALGORITHM_RSA = 1 ALGORITHM_DSS = 2 ALGORITHM_ECDSA = 3 ALGORITHM_Ed25519 = 4 FINGERPRINT_TYPE_SHA1 = 1 FINGERPRINT_TYPE_SHA256 = 2 def __init__(self, algorithm=0, fingerprintType=0, fingerprint=b"", ttl=0): self.algorithm = algorithm self.fingerprintType = fingerprintType self.fingerprint = fingerprint self.ttl = ttl def encode(self, strio, compDict=None): strio.write(struct.pack("!BB", self.algorithm, self.fingerprintType)) strio.write(self.fingerprint) def decode(self, strio, length=None): r = struct.unpack("!BB", readPrecisely(strio, 2)) (self.algorithm, self.fingerprintType) = r self.fingerprint = readPrecisely(strio, length - 2) def __hash__(self): return hash((self.algorithm, self.fingerprintType, self.fingerprint)) @implementer(IEncodableRecord) class Record_TXT(tputil.FancyEqMixin, tputil.FancyStrMixin): """ Freeform text. @type data: L{list} of L{bytes} @ivar data: Freeform text which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = TXT fancybasename = "TXT" showAttributes = (("data", _nicebyteslist), "ttl") compareAttributes = ("data", "ttl") def __init__(self, *data, **kw): self.data = list(data) # arg man python sucks so bad self.ttl = str2time(kw.get("ttl", None)) def encode(self, strio, compDict=None): for d in self.data: strio.write(struct.pack("!B", len(d)) + d) def decode(self, strio, length=None): soFar = 0 self.data = [] while soFar < length: L = struct.unpack("!B", readPrecisely(strio, 1))[0] self.data.append(readPrecisely(strio, L)) soFar += L + 1 if soFar != length: log.msg( "Decoded %d bytes in %s record, but rdlength is %d" % (soFar, self.fancybasename, length) ) def __hash__(self): return hash(tuple(self.data)) @implementer(IEncodableRecord) class UnknownRecord(tputil.FancyEqMixin, tputil.FancyStrMixin): """ Encapsulate the wire data for unknown record types so that they can pass through the system unchanged. @type data: L{bytes} @ivar data: Wire data which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @since: 11.1 """ TYPE = None fancybasename = "UNKNOWN" compareAttributes = ("data", "ttl") showAttributes = (("data", _nicebytes), "ttl") def __init__(self, data=b"", ttl=None): self.data = data self.ttl = str2time(ttl) def encode(self, strio, compDict=None): """ Write the raw bytes corresponding to this record's payload to the stream. """ strio.write(self.data) def decode(self, strio, length=None): """ Load the bytes which are part of this record from the stream and store them unparsed and unmodified. """ if length is None: raise Exception("must know length for unknown record types") self.data = readPrecisely(strio, length) def __hash__(self): return hash((self.data, self.ttl)) class Record_SPF(Record_TXT): """ Structurally, freeform text. Semantically, a policy definition, formatted as defined in U{rfc 4408<http://www.faqs.org/rfcs/rfc4408.html>}. @type data: L{list} of L{bytes} @ivar data: Freeform text which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = SPF fancybasename = "SPF" @implementer(IEncodableRecord) class Record_TSIG(tputil.FancyEqMixin, tputil.FancyStrMixin): """ A transaction signature, encapsulated in a RR, as described in U{RFC 2845 <https://tools.ietf.org/html/rfc2845>}. @type algorithm: L{Name} @ivar algorithm: The name of the signature or MAC algorithm. @type timeSigned: L{int} @ivar timeSigned: Signing time, as seconds from the POSIX epoch. @type fudge: L{int} @ivar fudge: Allowable time skew, in seconds. @type MAC: L{bytes} @ivar MAC: The message digest or signature. @type originalID: L{int} @ivar originalID: A message ID. @type error: L{int} @ivar error: An error code (extended C{RCODE}) carried in exceptional cases. @type otherData: L{bytes} @ivar otherData: Other data carried in exceptional cases. """ fancybasename = "TSIG" compareAttributes = ( "algorithm", "timeSigned", "fudge", "MAC", "originalID", "error", "otherData", "ttl", ) showAttributes = ["algorithm", "timeSigned", "MAC", "error", "otherData"] TYPE = TSIG def __init__( self, algorithm=None, timeSigned=None, fudge=5, MAC=None, originalID=0, error=OK, otherData=b"", ttl=0, ): # All of our init arguments have to have defaults, because of # the way IEncodable and Message.parseRecords() work, but for # some of our arguments there is no reasonable default; we use # invalid values here to prevent a user of this class from # relying on what's really an internal implementation detail. self.algorithm = None if algorithm is None else Name(algorithm) self.timeSigned = timeSigned self.fudge = str2time(fudge) self.MAC = MAC self.originalID = originalID self.error = error self.otherData = otherData self.ttl = ttl def encode(self, strio, compDict=None): self.algorithm.encode(strio, compDict) strio.write(struct.pack("!Q", self.timeSigned)[2:]) # 48-bit number strio.write(struct.pack("!HH", self.fudge, len(self.MAC))) strio.write(self.MAC) strio.write( struct.pack("!HHH", self.originalID, self.error, len(self.otherData)) ) strio.write(self.otherData) def decode(self, strio, length=None): algorithm = Name() algorithm.decode(strio) self.algorithm = algorithm fields = struct.unpack("!QHH", b"\x00\x00" + readPrecisely(strio, 10)) self.timeSigned, self.fudge, macLength = fields self.MAC = readPrecisely(strio, macLength) fields = struct.unpack("!HHH", readPrecisely(strio, 6)) self.originalID, self.error, otherLength = fields self.otherData = readPrecisely(strio, otherLength) def __hash__(self): return hash((self.algorithm, self.timeSigned, self.MAC, self.originalID)) def _responseFromMessage(responseConstructor, message, **kwargs): """ Generate a L{Message} like instance suitable for use as the response to C{message}. The C{queries}, C{id} attributes will be copied from C{message} and the C{answer} flag will be set to L{True}. @param responseConstructor: A response message constructor with an initializer signature matching L{dns.Message.__init__}. @type responseConstructor: C{callable} @param message: A request message. @type message: L{Message} @param kwargs: Keyword arguments which will be passed to the initialiser of the response message. @type kwargs: L{dict} @return: A L{Message} like response instance. @rtype: C{responseConstructor} """ response = responseConstructor(id=message.id, answer=True, **kwargs) response.queries = message.queries[:] return response def _getDisplayableArguments(obj, alwaysShow, fieldNames): """ Inspect the function signature of C{obj}'s constructor, and get a list of which arguments should be displayed. This is a helper function for C{_compactRepr}. @param obj: The instance whose repr is being generated. @param alwaysShow: A L{list} of field names which should always be shown. @param fieldNames: A L{list} of field attribute names which should be shown if they have non-default values. @return: A L{list} of displayable arguments. """ displayableArgs = [] # Get the argument names and values from the constructor. signature = inspect.signature(obj.__class__.__init__) for name in fieldNames: defaultValue = signature.parameters[name].default fieldValue = getattr(obj, name, defaultValue) if (name in alwaysShow) or (fieldValue != defaultValue): displayableArgs.append(f" {name}={fieldValue!r}") return displayableArgs def _compactRepr( obj, alwaysShow=None, flagNames=None, fieldNames=None, sectionNames=None ): """ Return a L{str} representation of C{obj} which only shows fields with non-default values, flags which are True and sections which have been explicitly set. @param obj: The instance whose repr is being generated. @param alwaysShow: A L{list} of field names which should always be shown. @param flagNames: A L{list} of flag attribute names which should be shown if they are L{True}. @param fieldNames: A L{list} of field attribute names which should be shown if they have non-default values. @param sectionNames: A L{list} of section attribute names which should be shown if they have been assigned a value. @return: A L{str} representation of C{obj}. """ if alwaysShow is None: alwaysShow = [] if flagNames is None: flagNames = [] if fieldNames is None: fieldNames = [] if sectionNames is None: sectionNames = [] setFlags = [] for name in flagNames: if name in alwaysShow or getattr(obj, name, False) == True: setFlags.append(name) displayableArgs = _getDisplayableArguments(obj, alwaysShow, fieldNames) out = ["<", obj.__class__.__name__] + displayableArgs if setFlags: out.append(" flags={}".format(",".join(setFlags))) for name in sectionNames: section = getattr(obj, name, []) if section: out.append(f" {name}={section!r}") out.append(">") return "".join(out) class Message(tputil.FancyEqMixin): """ L{Message} contains all the information represented by a single DNS request or response. @ivar id: See L{__init__} @ivar answer: See L{__init__} @ivar opCode: See L{__init__} @ivar recDes: See L{__init__} @ivar recAv: See L{__init__} @ivar auth: See L{__init__} @ivar rCode: See L{__init__} @ivar trunc: See L{__init__} @ivar maxSize: See L{__init__} @ivar authenticData: See L{__init__} @ivar checkingDisabled: See L{__init__} @ivar queries: The queries which are being asked of or answered by DNS server. @type queries: L{list} of L{Query} @ivar answers: Records containing the answers to C{queries} if this is a response message. @type answers: L{list} of L{RRHeader} @ivar authority: Records containing information about the authoritative DNS servers for the names in C{queries}. @type authority: L{list} of L{RRHeader} @ivar additional: Records containing IP addresses of host names in C{answers} and C{authority}. @type additional: L{list} of L{RRHeader} @ivar _flagNames: The names of attributes representing the flag header fields. @ivar _fieldNames: The names of attributes representing non-flag fixed header fields. @ivar _sectionNames: The names of attributes representing the record sections of this message. """ compareAttributes = ( "id", "answer", "opCode", "recDes", "recAv", "auth", "rCode", "trunc", "maxSize", "authenticData", "checkingDisabled", "queries", "answers", "authority", "additional", ) headerFmt = "!H2B4H" headerSize = struct.calcsize(headerFmt) # Question, answer, additional, and nameserver lists queries = answers = add = ns = None def __init__( self, id=0, answer=0, opCode=0, recDes=0, recAv=0, auth=0, rCode=OK, trunc=0, maxSize=512, authenticData=0, checkingDisabled=0, ): """ @param id: A 16 bit identifier assigned by the program that generates any kind of query. This identifier is copied to the corresponding reply and can be used by the requester to match up replies to outstanding queries. @type id: L{int} @param answer: A one bit field that specifies whether this message is a query (0), or a response (1). @type answer: L{int} @param opCode: A four bit field that specifies kind of query in this message. This value is set by the originator of a query and copied into the response. @type opCode: L{int} @param recDes: Recursion Desired - this bit may be set in a query and is copied into the response. If RD is set, it directs the name server to pursue the query recursively. Recursive query support is optional. @type recDes: L{int} @param recAv: Recursion Available - this bit is set or cleared in a response and denotes whether recursive query support is available in the name server. @type recAv: L{int} @param auth: Authoritative Answer - this bit is valid in responses and specifies that the responding name server is an authority for the domain name in question section. @type auth: L{int} @ivar rCode: A response code, used to indicate success or failure in a message which is a response from a server to a client request. @type rCode: C{0 <= int < 16} @param trunc: A flag indicating that this message was truncated due to length greater than that permitted on the transmission channel. @type trunc: L{int} @param maxSize: The requestor's UDP payload size is the number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type maxSize: L{int} @param authenticData: A flag indicating in a response that all the data included in the answer and authority portion of the response has been authenticated by the server according to the policies of that server. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{int} @param checkingDisabled: A flag indicating in a query that pending (non-authenticated) data is acceptable to the resolver sending the query. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{int} """ self.maxSize = maxSize self.id = id self.answer = answer self.opCode = opCode self.auth = auth self.trunc = trunc self.recDes = recDes self.recAv = recAv self.rCode = rCode self.authenticData = authenticData self.checkingDisabled = checkingDisabled self.queries = [] self.answers = [] self.authority = [] self.additional = [] def __repr__(self) -> str: """ Generate a repr of this L{Message}. Only includes the non-default fields and sections and only includes flags which are set. The C{id} is always shown. @return: The native string repr. """ return _compactRepr( self, flagNames=( "answer", "auth", "trunc", "recDes", "recAv", "authenticData", "checkingDisabled", ), fieldNames=("id", "opCode", "rCode", "maxSize"), sectionNames=("queries", "answers", "authority", "additional"), alwaysShow=("id",), ) def addQuery(self, name, type=ALL_RECORDS, cls=IN): """ Add another query to this Message. @type name: L{bytes} @param name: The name to query. @type type: L{int} @param type: Query type @type cls: L{int} @param cls: Query class """ self.queries.append(Query(name, type, cls)) def encode(self, strio): compDict = {} body_tmp = BytesIO() for q in self.queries: q.encode(body_tmp, compDict) for q in self.answers: q.encode(body_tmp, compDict) for q in self.authority: q.encode(body_tmp, compDict) for q in self.additional: q.encode(body_tmp, compDict) body = body_tmp.getvalue() size = len(body) + self.headerSize if self.maxSize and size > self.maxSize: self.trunc = 1 body = body[: self.maxSize - self.headerSize] byte3 = ( ((self.answer & 1) << 7) | ((self.opCode & 0xF) << 3) | ((self.auth & 1) << 2) | ((self.trunc & 1) << 1) | (self.recDes & 1) ) byte4 = ( ((self.recAv & 1) << 7) | ((self.authenticData & 1) << 5) | ((self.checkingDisabled & 1) << 4) | (self.rCode & 0xF) ) strio.write( struct.pack( self.headerFmt, self.id, byte3, byte4, len(self.queries), len(self.answers), len(self.authority), len(self.additional), ) ) strio.write(body) def decode(self, strio, length=None): self.maxSize = 0 header = readPrecisely(strio, self.headerSize) r = struct.unpack(self.headerFmt, header) self.id, byte3, byte4, nqueries, nans, nns, nadd = r self.answer = (byte3 >> 7) & 1 self.opCode = (byte3 >> 3) & 0xF self.auth = (byte3 >> 2) & 1 self.trunc = (byte3 >> 1) & 1 self.recDes = byte3 & 1 self.recAv = (byte4 >> 7) & 1 self.authenticData = (byte4 >> 5) & 1 self.checkingDisabled = (byte4 >> 4) & 1 self.rCode = byte4 & 0xF self.queries = [] for i in range(nqueries): q = Query() try: q.decode(strio) except EOFError: return self.queries.append(q) items = ((self.answers, nans), (self.authority, nns), (self.additional, nadd)) for (l, n) in items: self.parseRecords(l, n, strio) def parseRecords(self, list, num, strio): for i in range(num): header = RRHeader(auth=self.auth) try: header.decode(strio) except EOFError: return t = self.lookupRecordType(header.type) if not t: continue header.payload = t(ttl=header.ttl) try: header.payload.decode(strio, header.rdlength) except EOFError: return list.append(header) # Create a mapping from record types to their corresponding Record_* # classes. This relies on the global state which has been created so # far in initializing this module (so don't define Record classes after # this). _recordTypes = {} for name in globals(): if name.startswith("Record_"): _recordTypes[globals()[name].TYPE] = globals()[name] # Clear the iteration variable out of the class namespace so it # doesn't become an attribute. del name def lookupRecordType(self, type): """ Retrieve the L{IRecord} implementation for the given record type. @param type: A record type, such as C{A} or L{NS}. @type type: L{int} @return: An object which implements L{IRecord} or L{None} if none can be found for the given type. @rtype: C{Type[IRecord]} """ return self._recordTypes.get(type, UnknownRecord) def toStr(self): """ Encode this L{Message} into a byte string in the format described by RFC 1035. @rtype: L{bytes} """ strio = BytesIO() self.encode(strio) return strio.getvalue() def fromStr(self, str): """ Decode a byte string in the format described by RFC 1035 into this L{Message}. @param str: L{bytes} """ strio = BytesIO(str) self.decode(strio) class _EDNSMessage(tputil.FancyEqMixin): """ An I{EDNS} message. Designed for compatibility with L{Message} but with a narrower public interface. Most importantly, L{_EDNSMessage.fromStr} will interpret and remove I{OPT} records that are present in the additional records section. The I{OPT} records are used to populate certain I{EDNS} specific attributes. L{_EDNSMessage.toStr} will add suitable I{OPT} records to the additional section to represent the extended EDNS information. @see: U{https://tools.ietf.org/html/rfc6891} @ivar id: See L{__init__} @ivar answer: See L{__init__} @ivar opCode: See L{__init__} @ivar auth: See L{__init__} @ivar trunc: See L{__init__} @ivar recDes: See L{__init__} @ivar recAv: See L{__init__} @ivar rCode: See L{__init__} @ivar ednsVersion: See L{__init__} @ivar dnssecOK: See L{__init__} @ivar authenticData: See L{__init__} @ivar checkingDisabled: See L{__init__} @ivar maxSize: See L{__init__} @ivar queries: See L{__init__} @ivar answers: See L{__init__} @ivar authority: See L{__init__} @ivar additional: See L{__init__} @ivar _messageFactory: A constructor of L{Message} instances. Called by C{_toMessage} and C{_fromMessage}. """ compareAttributes = ( "id", "answer", "opCode", "auth", "trunc", "recDes", "recAv", "rCode", "ednsVersion", "dnssecOK", "authenticData", "checkingDisabled", "maxSize", "queries", "answers", "authority", "additional", ) _messageFactory = Message def __init__( self, id=0, answer=False, opCode=OP_QUERY, auth=False, trunc=False, recDes=False, recAv=False, rCode=0, ednsVersion=0, dnssecOK=False, authenticData=False, checkingDisabled=False, maxSize=512, queries=None, answers=None, authority=None, additional=None, ): """ Construct a new L{_EDNSMessage} @see: U{RFC1035 section-4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>} @see: U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>} @see: U{RFC3225 section-3<https://tools.ietf.org/html/rfc3225#section-3>} @see: U{RFC6891 section-6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>} @param id: A 16 bit identifier assigned by the program that generates any kind of query. This identifier is copied the corresponding reply and can be used by the requester to match up replies to outstanding queries. @type id: L{int} @param answer: A one bit field that specifies whether this message is a query (0), or a response (1). @type answer: L{bool} @param opCode: A four bit field that specifies kind of query in this message. This value is set by the originator of a query and copied into the response. @type opCode: L{int} @param auth: Authoritative Answer - this bit is valid in responses, and specifies that the responding name server is an authority for the domain name in question section. @type auth: L{bool} @param trunc: Truncation - specifies that this message was truncated due to length greater than that permitted on the transmission channel. @type trunc: L{bool} @param recDes: Recursion Desired - this bit may be set in a query and is copied into the response. If set, it directs the name server to pursue the query recursively. Recursive query support is optional. @type recDes: L{bool} @param recAv: Recursion Available - this bit is set or cleared in a response, and denotes whether recursive query support is available in the name server. @type recAv: L{bool} @param rCode: Extended 12-bit RCODE. Derived from the 4 bits defined in U{RFC1035 4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>} and the upper 8bits defined in U{RFC6891 6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>}. @type rCode: L{int} @param ednsVersion: Indicates the EDNS implementation level. Set to L{None} to prevent any EDNS attributes and options being added to the encoded byte string. @type ednsVersion: L{int} or L{None} @param dnssecOK: DNSSEC OK bit as defined by U{RFC3225 3<https://tools.ietf.org/html/rfc3225#section-3>}. @type dnssecOK: L{bool} @param authenticData: A flag indicating in a response that all the data included in the answer and authority portion of the response has been authenticated by the server according to the policies of that server. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{bool} @param checkingDisabled: A flag indicating in a query that pending (non-authenticated) data is acceptable to the resolver sending the query. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{bool} @param maxSize: The requestor's UDP payload size is the number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type maxSize: L{int} @param queries: The L{list} of L{Query} associated with this message. @type queries: L{list} of L{Query} @param answers: The L{list} of answers associated with this message. @type answers: L{list} of L{RRHeader} @param authority: The L{list} of authority records associated with this message. @type authority: L{list} of L{RRHeader} @param additional: The L{list} of additional records associated with this message. @type additional: L{list} of L{RRHeader} """ self.id = id self.answer = answer self.opCode = opCode self.auth = auth self.trunc = trunc self.recDes = recDes self.recAv = recAv self.rCode = rCode self.ednsVersion = ednsVersion self.dnssecOK = dnssecOK self.authenticData = authenticData self.checkingDisabled = checkingDisabled self.maxSize = maxSize if queries is None: queries = [] self.queries = queries if answers is None: answers = [] self.answers = answers if authority is None: authority = [] self.authority = authority if additional is None: additional = [] self.additional = additional def __repr__(self) -> str: return _compactRepr( self, flagNames=( "answer", "auth", "trunc", "recDes", "recAv", "authenticData", "checkingDisabled", "dnssecOK", ), fieldNames=("id", "opCode", "rCode", "maxSize", "ednsVersion"), sectionNames=("queries", "answers", "authority", "additional"), alwaysShow=("id",), ) def _toMessage(self): """ Convert to a standard L{dns.Message}. If C{ednsVersion} is not None, an L{_OPTHeader} instance containing all the I{EDNS} specific attributes and options will be appended to the list of C{additional} records. @return: A L{dns.Message} @rtype: L{dns.Message} """ m = self._messageFactory( id=self.id, answer=self.answer, opCode=self.opCode, auth=self.auth, trunc=self.trunc, recDes=self.recDes, recAv=self.recAv, # Assign the lower 4 bits to the message rCode=self.rCode & 0xF, authenticData=self.authenticData, checkingDisabled=self.checkingDisabled, ) m.queries = self.queries[:] m.answers = self.answers[:] m.authority = self.authority[:] m.additional = self.additional[:] if self.ednsVersion is not None: o = _OPTHeader( version=self.ednsVersion, dnssecOK=self.dnssecOK, udpPayloadSize=self.maxSize, # Assign the upper 8 bits to the OPT record extendedRCODE=self.rCode >> 4, ) m.additional.append(o) return m def toStr(self): """ Encode to wire format by first converting to a standard L{dns.Message}. @return: A L{bytes} string. """ return self._toMessage().toStr() @classmethod def _fromMessage(cls, message): """ Construct and return a new L{_EDNSMessage} whose attributes and records are derived from the attributes and records of C{message} (a L{Message} instance). If present, an C{OPT} record will be extracted from the C{additional} section and its attributes and options will be used to set the EDNS specific attributes C{extendedRCODE}, C{ednsVersion}, C{dnssecOK}, C{ednsOptions}. The C{extendedRCODE} will be combined with C{message.rCode} and assigned to C{self.rCode}. @param message: The source L{Message}. @type message: L{Message} @return: A new L{_EDNSMessage} @rtype: L{_EDNSMessage} """ additional = [] optRecords = [] for r in message.additional: if r.type == OPT: optRecords.append(_OPTHeader.fromRRHeader(r)) else: additional.append(r) newMessage = cls( id=message.id, answer=message.answer, opCode=message.opCode, auth=message.auth, trunc=message.trunc, recDes=message.recDes, recAv=message.recAv, rCode=message.rCode, authenticData=message.authenticData, checkingDisabled=message.checkingDisabled, # Default to None, it will be updated later when the OPT records are # parsed. ednsVersion=None, dnssecOK=False, queries=message.queries[:], answers=message.answers[:], authority=message.authority[:], additional=additional, ) if len(optRecords) == 1: # XXX: If multiple OPT records are received, an EDNS server should # respond with FORMERR. See ticket:5669#comment:1. opt = optRecords[0] newMessage.ednsVersion = opt.version newMessage.dnssecOK = opt.dnssecOK newMessage.maxSize = opt.udpPayloadSize newMessage.rCode = opt.extendedRCODE << 4 | message.rCode return newMessage def fromStr(self, bytes): """ Decode from wire format, saving flags, values and records to this L{_EDNSMessage} instance in place. @param bytes: The full byte string to be decoded. @type bytes: L{bytes} """ m = self._messageFactory() m.fromStr(bytes) ednsMessage = self._fromMessage(m) for attrName in self.compareAttributes: setattr(self, attrName, getattr(ednsMessage, attrName)) class DNSMixin: """ DNS protocol mixin shared by UDP and TCP implementations. @ivar _reactor: A L{IReactorTime} and L{IReactorUDP} provider which will be used to issue DNS queries and manage request timeouts. """ id = None liveMessages = None def __init__(self, controller, reactor=None): self.controller = controller self.id = random.randrange(2 ** 10, 2 ** 15) if reactor is None: from twisted.internet import reactor self._reactor = reactor def pickID(self): """ Return a unique ID for queries. """ while True: id = randomSource() if id not in self.liveMessages: return id def callLater(self, period, func, *args): """ Wrapper around reactor.callLater, mainly for test purpose. """ return self._reactor.callLater(period, func, *args) def _query(self, queries, timeout, id, writeMessage): """ Send out a message with the given queries. @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @type timeout: L{int} or C{float} @param timeout: How long to wait before giving up @type id: L{int} @param id: Unique key for this request @type writeMessage: C{callable} @param writeMessage: One-parameter callback which writes the message @rtype: C{Deferred} @return: a C{Deferred} which will be fired with the result of the query, or errbacked with any errors that could happen (exceptions during writing of the query, timeout errors, ...). """ m = Message(id, recDes=1) m.queries = queries try: writeMessage(m) except BaseException: return defer.fail() resultDeferred = defer.Deferred() cancelCall = self.callLater(timeout, self._clearFailed, resultDeferred, id) self.liveMessages[id] = (resultDeferred, cancelCall) return resultDeferred def _clearFailed(self, deferred, id): """ Clean the Deferred after a timeout. """ try: del self.liveMessages[id] except KeyError: pass deferred.errback(failure.Failure(DNSQueryTimeoutError(id))) class DNSDatagramProtocol(DNSMixin, protocol.DatagramProtocol): """ DNS protocol over UDP. """ resends = None def stopProtocol(self): """ Stop protocol: reset state variables. """ self.liveMessages = {} self.resends = {} self.transport = None def startProtocol(self): """ Upon start, reset internal state. """ self.liveMessages = {} self.resends = {} def writeMessage(self, message, address): """ Send a message holding DNS queries. @type message: L{Message} """ self.transport.write(message.toStr(), address) def startListening(self): self._reactor.listenUDP(0, self, maxPacketSize=512) def datagramReceived(self, data, addr): """ Read a datagram, extract the message in it and trigger the associated Deferred. """ m = Message() try: m.fromStr(data) except EOFError: log.msg("Truncated packet (%d bytes) from %s" % (len(data), addr)) return except BaseException: # Nothing should trigger this, but since we're potentially # invoking a lot of different decoding methods, we might as well # be extra cautious. Anything that triggers this is itself # buggy. log.err(failure.Failure(), "Unexpected decoding error") return if m.id in self.liveMessages: d, canceller = self.liveMessages[m.id] del self.liveMessages[m.id] canceller.cancel() # XXX we shouldn't need this hack of catching exception on callback() try: d.callback(m) except BaseException: log.err() else: if m.id not in self.resends: self.controller.messageReceived(m, self, addr) def removeResend(self, id): """ Mark message ID as no longer having duplication suppression. """ try: del self.resends[id] except KeyError: pass def query(self, address, queries, timeout=10, id=None): """ Send out a message with the given queries. @type address: L{tuple} of L{str} and L{int} @param address: The address to which to send the query @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @rtype: C{Deferred} """ if not self.transport: # XXX transport might not get created automatically, use callLater? try: self.startListening() except CannotListenError: return defer.fail() if id is None: id = self.pickID() else: self.resends[id] = 1 def writeMessage(m): self.writeMessage(m, address) return self._query(queries, timeout, id, writeMessage) class DNSProtocol(DNSMixin, protocol.Protocol): """ DNS protocol over TCP. """ length = None buffer = b"" def writeMessage(self, message): """ Send a message holding DNS queries. @type message: L{Message} """ s = message.toStr() self.transport.write(struct.pack("!H", len(s)) + s) def connectionMade(self): """ Connection is made: reset internal state, and notify the controller. """ self.liveMessages = {} self.controller.connectionMade(self) def connectionLost(self, reason): """ Notify the controller that this protocol is no longer connected. """ self.controller.connectionLost(self) def dataReceived(self, data): self.buffer += data while self.buffer: if self.length is None and len(self.buffer) >= 2: self.length = struct.unpack("!H", self.buffer[:2])[0] self.buffer = self.buffer[2:] if len(self.buffer) >= self.length: myChunk = self.buffer[: self.length] m = Message() m.fromStr(myChunk) try: d, canceller = self.liveMessages[m.id] except KeyError: self.controller.messageReceived(m, self) else: del self.liveMessages[m.id] canceller.cancel() # XXX we shouldn't need this hack try: d.callback(m) except BaseException: log.err() self.buffer = self.buffer[self.length :] self.length = None else: break def query(self, queries, timeout=60): """ Send out a message with the given queries. @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @rtype: C{Deferred} """ id = self.pickID() return self._query(queries, timeout, id, self.writeMessage) PK y�Z�!��+A +A authority.pynu �[��� # -*- test-case-name: twisted.names.test.test_names -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Authoritative resolvers. """ import os import time from twisted.internet import defer from twisted.names import common, dns, error from twisted.python import failure from twisted.python.compat import execfile, nativeString from twisted.python.filepath import FilePath def getSerial(filename="/tmp/twisted-names.serial"): """ Return a monotonically increasing (across program runs) integer. State is stored in the given file. If it does not exist, it is created with rw-/---/--- permissions. This manipulates process-global state by calling C{os.umask()}, so it isn't thread-safe. @param filename: Path to a file that is used to store the state across program runs. @type filename: L{str} @return: a monotonically increasing number @rtype: L{str} """ serial = time.strftime("%Y%m%d") o = os.umask(0o177) try: if not os.path.exists(filename): with open(filename, "w") as f: f.write(serial + " 0") finally: os.umask(o) with open(filename) as serialFile: lastSerial, zoneID = serialFile.readline().split() zoneID = (lastSerial == serial) and (int(zoneID) + 1) or 0 with open(filename, "w") as serialFile: serialFile.write("%s %d" % (serial, zoneID)) serial = serial + ("%02d" % (zoneID,)) return serial class FileAuthority(common.ResolverBase): """ An Authority that is loaded from a file. This is an abstract class that implements record search logic. To create a functional resolver, subclass it and override the L{loadFile} method. @ivar _ADDITIONAL_PROCESSING_TYPES: Record types for which additional processing will be done. @ivar _ADDRESS_TYPES: Record types which are useful for inclusion in the additional section generated during additional processing. @ivar soa: A 2-tuple containing the SOA domain name as a L{bytes} and a L{dns.Record_SOA}. @ivar records: A mapping of domains (as lowercased L{bytes}) to records. @type records: L{dict} with L{bytes} keys """ # See https://twistedmatrix.com/trac/ticket/6650 _ADDITIONAL_PROCESSING_TYPES = (dns.CNAME, dns.MX, dns.NS) _ADDRESS_TYPES = (dns.A, dns.AAAA) soa = None records = None def __init__(self, filename): common.ResolverBase.__init__(self) self.loadFile(filename) self._cache = {} def __setstate__(self, state): self.__dict__ = state def loadFile(self, filename): """ Load DNS records from a file. This method populates the I{soa} and I{records} attributes. It must be overridden in a subclass. It is called once from the initializer. @param filename: The I{filename} parameter that was passed to the initilizer. @returns: L{None} -- the return value is ignored """ def _additionalRecords(self, answer, authority, ttl): """ Find locally known information that could be useful to the consumer of the response and construct appropriate records to include in the I{additional} section of that response. Essentially, implement RFC 1034 section 4.3.2 step 6. @param answer: A L{list} of the records which will be included in the I{answer} section of the response. @param authority: A L{list} of the records which will be included in the I{authority} section of the response. @param ttl: The default TTL for records for which this is not otherwise specified. @return: A generator of L{dns.RRHeader} instances for inclusion in the I{additional} section. These instances represent extra information about the records in C{answer} and C{authority}. """ for record in answer + authority: if record.type in self._ADDITIONAL_PROCESSING_TYPES: name = record.payload.name.name for rec in self.records.get(name.lower(), ()): if rec.TYPE in self._ADDRESS_TYPES: yield dns.RRHeader( name, rec.TYPE, dns.IN, rec.ttl or ttl, rec, auth=True ) def _lookup(self, name, cls, type, timeout=None): """ Determine a response to a particular DNS query. @param name: The name which is being queried and for which to lookup a response. @type name: L{bytes} @param cls: The class which is being queried. Only I{IN} is implemented here and this value is presently disregarded. @type cls: L{int} @param type: The type of records being queried. See the types defined in L{twisted.names.dns}. @type type: L{int} @param timeout: All processing is done locally and a result is available immediately, so the timeout value is ignored. @return: A L{Deferred} that fires with a L{tuple} of three sets of response records (to comprise the I{answer}, I{authority}, and I{additional} sections of a DNS response) or with a L{Failure} if there is a problem processing the query. """ cnames = [] results = [] authority = [] additional = [] default_ttl = max(self.soa[1].minimum, self.soa[1].expire) domain_records = self.records.get(name.lower()) if domain_records: for record in domain_records: if record.ttl is not None: ttl = record.ttl else: ttl = default_ttl if record.TYPE == dns.NS and name.lower() != self.soa[0].lower(): # NS record belong to a child zone: this is a referral. As # NS records are authoritative in the child zone, ours here # are not. RFC 2181, section 6.1. authority.append( dns.RRHeader(name, record.TYPE, dns.IN, ttl, record, auth=False) ) elif record.TYPE == type or type == dns.ALL_RECORDS: results.append( dns.RRHeader(name, record.TYPE, dns.IN, ttl, record, auth=True) ) if record.TYPE == dns.CNAME: cnames.append( dns.RRHeader(name, record.TYPE, dns.IN, ttl, record, auth=True) ) if not results: results = cnames # Sort of https://tools.ietf.org/html/rfc1034#section-4.3.2 . # See https://twistedmatrix.com/trac/ticket/6732 additionalInformation = self._additionalRecords( results, authority, default_ttl ) if cnames: results.extend(additionalInformation) else: additional.extend(additionalInformation) if not results and not authority: # Empty response. Include SOA record to allow clients to cache # this response. RFC 1034, sections 3.7 and 4.3.4, and RFC 2181 # section 7.1. authority.append( dns.RRHeader( self.soa[0], dns.SOA, dns.IN, ttl, self.soa[1], auth=True ) ) return defer.succeed((results, authority, additional)) else: if dns._isSubdomainOf(name, self.soa[0]): # We may be the authority and we didn't find it. # XXX: The QNAME may also be in a delegated child zone. See # #6581 and #6580 return defer.fail(failure.Failure(dns.AuthoritativeDomainError(name))) else: # The QNAME is not a descendant of this zone. Fail with # DomainError so that the next chained authority or # resolver will be queried. return defer.fail(failure.Failure(error.DomainError(name))) def lookupZone(self, name, timeout=10): name = dns.domainString(name) if self.soa[0].lower() == name.lower(): # Wee hee hee hooo yea default_ttl = max(self.soa[1].minimum, self.soa[1].expire) if self.soa[1].ttl is not None: soa_ttl = self.soa[1].ttl else: soa_ttl = default_ttl results = [ dns.RRHeader( self.soa[0], dns.SOA, dns.IN, soa_ttl, self.soa[1], auth=True ) ] for (k, r) in self.records.items(): for rec in r: if rec.ttl is not None: ttl = rec.ttl else: ttl = default_ttl if rec.TYPE != dns.SOA: results.append( dns.RRHeader(k, rec.TYPE, dns.IN, ttl, rec, auth=True) ) results.append(results[0]) return defer.succeed((results, (), ())) return defer.fail(failure.Failure(dns.DomainError(name))) def _cbAllRecords(self, results): ans, auth, add = [], [], [] for res in results: if res[0]: ans.extend(res[1][0]) auth.extend(res[1][1]) add.extend(res[1][2]) return ans, auth, add class PySourceAuthority(FileAuthority): """ A FileAuthority that is built up from Python source code. """ def loadFile(self, filename): g, l = self.setupConfigNamespace(), {} execfile(filename, g, l) if "zone" not in l: raise ValueError("No zone defined in " + filename) self.records = {} for rr in l["zone"]: if isinstance(rr[1], dns.Record_SOA): self.soa = rr self.records.setdefault(rr[0].lower(), []).append(rr[1]) def wrapRecord(self, type): def wrapRecordFunc(name, *arg, **kw): return (dns.domainString(name), type(*arg, **kw)) return wrapRecordFunc def setupConfigNamespace(self): r = {} items = dns.__dict__.keys() for record in [x for x in items if x.startswith("Record_")]: type = getattr(dns, record) f = self.wrapRecord(type) r[record[len("Record_") :]] = f return r class BindAuthority(FileAuthority): """ An Authority that loads U{BIND zone files <https://en.wikipedia.org/wiki/Zone_file>}. Supports only C{$ORIGIN} and C{$TTL} directives. """ def loadFile(self, filename): """ Load records from C{filename}. @param filename: file to read from @type filename: L{bytes} """ fp = FilePath(filename) # Not the best way to set an origin. It can be set using $ORIGIN # though. self.origin = nativeString(fp.basename() + b".") lines = fp.getContent().splitlines(True) lines = self.stripComments(lines) lines = self.collapseContinuations(lines) self.parseLines(lines) def stripComments(self, lines): """ Strip comments from C{lines}. @param lines: lines to work on @type lines: iterable of L{bytes} @return: C{lines} sans comments. """ return ( a.find(b";") == -1 and a or a[: a.find(b";")] for a in [b.strip() for b in lines] ) def collapseContinuations(self, lines): """ Transform multiline statements into single lines. @param lines: lines to work on @type lines: iterable of L{bytes} @return: iterable of continuous lines """ l = [] state = 0 for line in lines: if state == 0: if line.find(b"(") == -1: l.append(line) else: l.append(line[: line.find(b"(")]) state = 1 else: if line.find(b")") != -1: l[-1] += b" " + line[: line.find(b")")] state = 0 else: l[-1] += b" " + line return filter(None, (line.split() for line in l)) def parseLines(self, lines): """ Parse C{lines}. @param lines: lines to work on @type lines: iterable of L{bytes} """ ttl = 60 * 60 * 3 origin = self.origin self.records = {} for line in lines: if line[0] == b"$TTL": ttl = dns.str2time(line[1]) elif line[0] == b"$ORIGIN": origin = line[1] elif line[0] == b"$INCLUDE": raise NotImplementedError("$INCLUDE directive not implemented") elif line[0] == b"$GENERATE": raise NotImplementedError("$GENERATE directive not implemented") else: self.parseRecordLine(origin, ttl, line) # If the origin changed, reflect that within the instance. self.origin = origin def addRecord(self, owner, ttl, type, domain, cls, rdata): """ Add a record to our authority. Expand domain with origin if necessary. @param owner: origin? @type owner: L{bytes} @param ttl: time to live for the record @type ttl: L{int} @param domain: the domain for which the record is to be added @type domain: L{bytes} @param type: record type @type type: L{str} @param cls: record class @type cls: L{str} @param rdata: record data @type rdata: L{list} of L{bytes} """ if not domain.endswith(b"."): domain = domain + b"." + owner[:-1] else: domain = domain[:-1] f = getattr(self, f"class_{cls}", None) if f: f(ttl, type, domain, rdata) else: raise NotImplementedError(f"Record class {cls!r} not supported") def class_IN(self, ttl, type, domain, rdata): """ Simulate a class IN and recurse into the actual class. @param ttl: time to live for the record @type ttl: L{int} @param type: record type @type type: str @param domain: the domain @type domain: bytes @param rdata: @type rdata: bytes """ record = getattr(dns, f"Record_{nativeString(type)}", None) if record: r = record(*rdata) r.ttl = ttl self.records.setdefault(domain.lower(), []).append(r) if type == "SOA": self.soa = (domain, r) else: raise NotImplementedError( f"Record type {nativeString(type)!r} not supported" ) def parseRecordLine(self, origin, ttl, line): """ Parse a C{line} from a zone file respecting C{origin} and C{ttl}. Add resulting records to authority. @param origin: starting point for the zone @type origin: L{bytes} @param ttl: time to live for the record @type ttl: L{int} @param line: zone file line to parse; split by word @type line: L{list} of L{bytes} """ queryClasses = {qc.encode("ascii") for qc in dns.QUERY_CLASSES.values()} queryTypes = {qt.encode("ascii") for qt in dns.QUERY_TYPES.values()} markers = queryClasses | queryTypes cls = b"IN" owner = origin if line[0] == b"@": line = line[1:] owner = origin elif not line[0].isdigit() and line[0] not in markers: owner = line[0] line = line[1:] if line[0].isdigit() or line[0] in markers: domain = owner owner = origin else: domain = line[0] line = line[1:] if line[0] in queryClasses: cls = line[0] line = line[1:] if line[0].isdigit(): ttl = int(line[0]) line = line[1:] elif line[0].isdigit(): ttl = int(line[0]) line = line[1:] if line[0] in queryClasses: cls = line[0] line = line[1:] type = line[0] rdata = line[1:] self.addRecord(owner, ttl, nativeString(type), domain, nativeString(cls), rdata) PK y�ZR0-�� � cache.pynu �[��� # -*- test-case-name: twisted.names.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ An in-memory caching resolver. """ from twisted.internet import defer from twisted.names import common, dns from twisted.python import failure, log class CacheResolver(common.ResolverBase): """ A resolver that serves records from a local, memory cache. @ivar _reactor: A provider of L{interfaces.IReactorTime}. """ cache = None def __init__(self, cache=None, verbose=0, reactor=None): common.ResolverBase.__init__(self) self.cache = {} self.verbose = verbose self.cancel = {} if reactor is None: from twisted.internet import reactor self._reactor = reactor if cache: for query, (seconds, payload) in cache.items(): self.cacheResult(query, payload, seconds) def __setstate__(self, state): self.__dict__ = state now = self._reactor.seconds() for (k, (when, (ans, add, ns))) in self.cache.items(): diff = now - when for rec in ans + add + ns: if rec.ttl < diff: del self.cache[k] break def __getstate__(self): for c in self.cancel.values(): c.cancel() self.cancel.clear() return self.__dict__ def _lookup(self, name, cls, type, timeout): now = self._reactor.seconds() q = dns.Query(name, type, cls) try: when, (ans, auth, add) = self.cache[q] except KeyError: if self.verbose > 1: log.msg("Cache miss for " + repr(name)) return defer.fail(failure.Failure(dns.DomainError(name))) else: if self.verbose: log.msg("Cache hit for " + repr(name)) diff = now - when try: result = ( [ dns.RRHeader( r.name.name, r.type, r.cls, r.ttl - diff, r.payload ) for r in ans ], [ dns.RRHeader( r.name.name, r.type, r.cls, r.ttl - diff, r.payload ) for r in auth ], [ dns.RRHeader( r.name.name, r.type, r.cls, r.ttl - diff, r.payload ) for r in add ], ) except ValueError: return defer.fail(failure.Failure(dns.DomainError(name))) else: return defer.succeed(result) def lookupAllRecords(self, name, timeout=None): return defer.fail(failure.Failure(dns.DomainError(name))) def cacheResult(self, query, payload, cacheTime=None): """ Cache a DNS entry. @param query: a L{dns.Query} instance. @param payload: a 3-tuple of lists of L{dns.RRHeader} records, the matching result of the query (answers, authority and additional). @param cacheTime: The time (seconds since epoch) at which the entry is considered to have been added to the cache. If L{None} is given, the current time is used. """ if self.verbose > 1: log.msg("Adding %r to cache" % query) self.cache[query] = (cacheTime or self._reactor.seconds(), payload) if query in self.cancel: self.cancel[query].cancel() s = list(payload[0]) + list(payload[1]) + list(payload[2]) if s: m = s[0].ttl for r in s: m = min(m, r.ttl) else: m = 0 self.cancel[query] = self._reactor.callLater(m, self.clearEntry, query) def clearEntry(self, query): del self.cache[query] del self.cancel[query] PK y�ZOK�_ �_ client.pynu �[��� # -*- test-case-name: twisted.names.test.test_names -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Asynchronous client DNS The functions exposed in this module can be used for asynchronous name resolution and dns queries. If you need to create a resolver with specific requirements, such as needing to do queries against a particular host, the L{createResolver} function will return an C{IResolver}. Future plans: Proper nameserver acquisition on Windows/MacOS, better caching, respect timeouts """ import errno import os import warnings from zope.interface import moduleProvides from twisted.internet import defer, error, interfaces, protocol from twisted.internet.abstract import isIPv6Address from twisted.names import cache, common, dns, hosts as hostsModule, resolve, root from twisted.python import failure, log # Twisted imports from twisted.python.compat import nativeString from twisted.python.filepath import FilePath from twisted.python.runtime import platform moduleProvides(interfaces.IResolver) class Resolver(common.ResolverBase): """ @ivar _waiting: A C{dict} mapping tuple keys of query name/type/class to Deferreds which will be called back with the result of those queries. This is used to avoid issuing the same query more than once in parallel. This is more efficient on the network and helps avoid a "birthday paradox" attack by keeping the number of outstanding requests for a particular query fixed at one instead of allowing the attacker to raise it to an arbitrary number. @ivar _reactor: A provider of L{IReactorTCP}, L{IReactorUDP}, and L{IReactorTime} which will be used to set up network resources and track timeouts. """ index = 0 timeout = None factory = None servers = None dynServers = () pending = None connections = None resolv = None _lastResolvTime = None _resolvReadInterval = 60 def __init__(self, resolv=None, servers=None, timeout=(1, 3, 11, 45), reactor=None): """ Construct a resolver which will query domain name servers listed in the C{resolv.conf(5)}-format file given by C{resolv} as well as those in the given C{servers} list. Servers are queried in a round-robin fashion. If given, C{resolv} is periodically checked for modification and re-parsed if it is noticed to have changed. @type servers: C{list} of C{(str, int)} or L{None} @param servers: If not None, interpreted as a list of (host, port) pairs specifying addresses of domain name servers to attempt to use for this lookup. Host addresses should be in IPv4 dotted-quad form. If specified, overrides C{resolv}. @type resolv: C{str} @param resolv: Filename to read and parse as a resolver(5) configuration file. @type timeout: Sequence of C{int} @param timeout: Default number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @param reactor: A provider of L{IReactorTime}, L{IReactorUDP}, and L{IReactorTCP} which will be used to establish connections, listen for DNS datagrams, and enforce timeouts. If not provided, the global reactor will be used. @raise ValueError: Raised if no nameserver addresses can be found. """ common.ResolverBase.__init__(self) if reactor is None: from twisted.internet import reactor self._reactor = reactor self.timeout = timeout if servers is None: self.servers = [] else: self.servers = servers self.resolv = resolv if not len(self.servers) and not resolv: raise ValueError("No nameservers specified") self.factory = DNSClientFactory(self, timeout) self.factory.noisy = 0 # Be quiet by default self.connections = [] self.pending = [] self._waiting = {} self.maybeParseConfig() def __getstate__(self): d = self.__dict__.copy() d["connections"] = [] d["_parseCall"] = None return d def __setstate__(self, state): self.__dict__.update(state) self.maybeParseConfig() def _openFile(self, path): """ Wrapper used for opening files in the class, exists primarily for unit testing purposes. """ return FilePath(path).open() def maybeParseConfig(self): if self.resolv is None: # Don't try to parse it, don't set up a call loop return try: resolvConf = self._openFile(self.resolv) except OSError as e: if e.errno == errno.ENOENT: # Missing resolv.conf is treated the same as an empty resolv.conf self.parseConfig(()) else: raise else: with resolvConf: mtime = os.fstat(resolvConf.fileno()).st_mtime if mtime != self._lastResolvTime: log.msg(f"{self.resolv} changed, reparsing") self._lastResolvTime = mtime self.parseConfig(resolvConf) # Check again in a little while self._parseCall = self._reactor.callLater( self._resolvReadInterval, self.maybeParseConfig ) def parseConfig(self, resolvConf): servers = [] for L in resolvConf: L = L.strip() if L.startswith(b"nameserver"): resolver = (nativeString(L.split()[1]), dns.PORT) servers.append(resolver) log.msg(f"Resolver added {resolver!r} to server list") elif L.startswith(b"domain"): try: self.domain = L.split()[1] except IndexError: self.domain = b"" self.search = None elif L.startswith(b"search"): self.search = L.split()[1:] self.domain = None if not servers: servers.append(("127.0.0.1", dns.PORT)) self.dynServers = servers def pickServer(self): """ Return the address of a nameserver. TODO: Weight servers for response time so faster ones can be preferred. """ if not self.servers and not self.dynServers: return None serverL = len(self.servers) dynL = len(self.dynServers) self.index += 1 self.index %= serverL + dynL if self.index < serverL: return self.servers[self.index] else: return self.dynServers[self.index - serverL] def _connectedProtocol(self, interface=""): """ Return a new L{DNSDatagramProtocol} bound to a randomly selected port number. """ failures = 0 proto = dns.DNSDatagramProtocol(self, reactor=self._reactor) while True: try: self._reactor.listenUDP(dns.randomSource(), proto, interface=interface) except error.CannotListenError as e: failures += 1 if ( hasattr(e.socketError, "errno") and e.socketError.errno == errno.EMFILE ): # We've run out of file descriptors. Stop trying. raise if failures >= 1000: # We've tried a thousand times and haven't found a port. # This is almost impossible, and likely means something # else weird is going on. Raise, as to not infinite loop. raise else: return proto def connectionMade(self, protocol): """ Called by associated L{dns.DNSProtocol} instances when they connect. """ self.connections.append(protocol) for (d, q, t) in self.pending: self.queryTCP(q, t).chainDeferred(d) del self.pending[:] def connectionLost(self, protocol): """ Called by associated L{dns.DNSProtocol} instances when they disconnect. """ if protocol in self.connections: self.connections.remove(protocol) def messageReceived(self, message, protocol, address=None): log.msg("Unexpected message (%d) received from %r" % (message.id, address)) def _query(self, *args): """ Get a new L{DNSDatagramProtocol} instance from L{_connectedProtocol}, issue a query to it using C{*args}, and arrange for it to be disconnected from its transport after the query completes. @param args: Positional arguments to be passed to L{DNSDatagramProtocol.query}. @return: A L{Deferred} which will be called back with the result of the query. """ if isIPv6Address(args[0][0]): protocol = self._connectedProtocol(interface="::") else: protocol = self._connectedProtocol() d = protocol.query(*args) def cbQueried(result): protocol.transport.stopListening() return result d.addBoth(cbQueried) return d def queryUDP(self, queries, timeout=None): """ Make a number of DNS queries via UDP. @type queries: A C{list} of C{dns.Query} instances @param queries: The queries to make. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @rtype: C{Deferred} @raise C{twisted.internet.defer.TimeoutError}: When the query times out. """ if timeout is None: timeout = self.timeout addresses = self.servers + list(self.dynServers) if not addresses: return defer.fail(IOError("No domain name servers available")) # Make sure we go through servers in the list in the order they were # specified. addresses.reverse() used = addresses.pop() d = self._query(used, queries, timeout[0]) d.addErrback(self._reissue, addresses, [used], queries, timeout) return d def _reissue(self, reason, addressesLeft, addressesUsed, query, timeout): reason.trap(dns.DNSQueryTimeoutError) # If there are no servers left to be tried, adjust the timeout # to the next longest timeout period and move all the # "used" addresses back to the list of addresses to try. if not addressesLeft: addressesLeft = addressesUsed addressesLeft.reverse() addressesUsed = [] timeout = timeout[1:] # If all timeout values have been used this query has failed. Tell the # protocol we're giving up on it and return a terminal timeout failure # to our caller. if not timeout: return failure.Failure(defer.TimeoutError(query)) # Get an address to try. Take it out of the list of addresses # to try and put it ino the list of already tried addresses. address = addressesLeft.pop() addressesUsed.append(address) # Issue a query to a server. Use the current timeout. Add this # function as a timeout errback in case another retry is required. d = self._query(address, query, timeout[0], reason.value.id) d.addErrback(self._reissue, addressesLeft, addressesUsed, query, timeout) return d def queryTCP(self, queries, timeout=10): """ Make a number of DNS queries via TCP. @type queries: Any non-zero number of C{dns.Query} instances @param queries: The queries to make. @type timeout: C{int} @param timeout: The number of seconds after which to fail. @rtype: C{Deferred} """ if not len(self.connections): address = self.pickServer() if address is None: return defer.fail(IOError("No domain name servers available")) host, port = address self._reactor.connectTCP(host, port, self.factory) self.pending.append((defer.Deferred(), queries, timeout)) return self.pending[-1][0] else: return self.connections[0].query(queries, timeout) def filterAnswers(self, message): """ Extract results from the given message. If the message was truncated, re-attempt the query over TCP and return a Deferred which will fire with the results of that query. If the message's result code is not C{twisted.names.dns.OK}, return a Failure indicating the type of error which occurred. Otherwise, return a three-tuple of lists containing the results from the answers section, the authority section, and the additional section. """ if message.trunc: return self.queryTCP(message.queries).addCallback(self.filterAnswers) if message.rCode != dns.OK: return failure.Failure(self.exceptionForCode(message.rCode)(message)) return (message.answers, message.authority, message.additional) def _lookup(self, name, cls, type, timeout): """ Build a L{dns.Query} for the given parameters and dispatch it via UDP. If this query is already outstanding, it will not be re-issued. Instead, when the outstanding query receives a response, that response will be re-used for this query as well. @type name: C{str} @type type: C{int} @type cls: C{int} @return: A L{Deferred} which fires with a three-tuple giving the answer, authority, and additional sections of the response or with a L{Failure} if the response code is anything other than C{dns.OK}. """ key = (name, type, cls) waiting = self._waiting.get(key) if waiting is None: self._waiting[key] = [] d = self.queryUDP([dns.Query(name, type, cls)], timeout) def cbResult(result): for d in self._waiting.pop(key): d.callback(result) return result d.addCallback(self.filterAnswers) d.addBoth(cbResult) else: d = defer.Deferred() waiting.append(d) return d # This one doesn't ever belong on UDP def lookupZone(self, name, timeout=10): address = self.pickServer() if address is None: return defer.fail(IOError("No domain name servers available")) host, port = address d = defer.Deferred() controller = AXFRController(name, d) factory = DNSClientFactory(controller, timeout) factory.noisy = False # stfu connector = self._reactor.connectTCP(host, port, factory) controller.timeoutCall = self._reactor.callLater( timeout or 10, self._timeoutZone, d, controller, connector, timeout or 10 ) def eliminateTimeout(failure): controller.timeoutCall.cancel() controller.timeoutCall = None return failure return d.addCallbacks( self._cbLookupZone, eliminateTimeout, callbackArgs=(connector,) ) def _timeoutZone(self, d, controller, connector, seconds): connector.disconnect() controller.timeoutCall = None controller.deferred = None d.errback( error.TimeoutError("Zone lookup timed out after %d seconds" % (seconds,)) ) def _cbLookupZone(self, result, connector): connector.disconnect() return (result, [], []) class AXFRController: timeoutCall = None def __init__(self, name, deferred): self.name = name self.deferred = deferred self.soa = None self.records = [] self.pending = [(deferred,)] def connectionMade(self, protocol): # dig saids recursion-desired to 0, so I will too message = dns.Message(protocol.pickID(), recDes=0) message.queries = [dns.Query(self.name, dns.AXFR, dns.IN)] protocol.writeMessage(message) def connectionLost(self, protocol): # XXX Do something here - see #3428 pass def messageReceived(self, message, protocol): # Caveat: We have to handle two cases: All records are in 1 # message, or all records are in N messages. # According to http://cr.yp.to/djbdns/axfr-notes.html, # 'authority' and 'additional' are always empty, and only # 'answers' is present. self.records.extend(message.answers) if not self.records: return if not self.soa: if self.records[0].type == dns.SOA: # print "first SOA!" self.soa = self.records[0] if len(self.records) > 1 and self.records[-1].type == dns.SOA: # print "It's the second SOA! We're done." if self.timeoutCall is not None: self.timeoutCall.cancel() self.timeoutCall = None if self.deferred is not None: self.deferred.callback(self.records) self.deferred = None from twisted.internet.base import ThreadedResolver as _ThreadedResolverImpl class ThreadedResolver(_ThreadedResolverImpl): def __init__(self, reactor=None): if reactor is None: from twisted.internet import reactor _ThreadedResolverImpl.__init__(self, reactor) warnings.warn( "twisted.names.client.ThreadedResolver is deprecated since " "Twisted 9.0, use twisted.internet.base.ThreadedResolver " "instead.", category=DeprecationWarning, stacklevel=2, ) class DNSClientFactory(protocol.ClientFactory): def __init__(self, controller, timeout=10): self.controller = controller self.timeout = timeout def clientConnectionLost(self, connector, reason): pass def clientConnectionFailed(self, connector, reason): """ Fail all pending TCP DNS queries if the TCP connection attempt fails. @see: L{twisted.internet.protocol.ClientFactory} @param connector: Not used. @type connector: L{twisted.internet.interfaces.IConnector} @param reason: A C{Failure} containing information about the cause of the connection failure. This will be passed as the argument to C{errback} on every pending TCP query C{deferred}. @type reason: L{twisted.python.failure.Failure} """ # Copy the current pending deferreds then reset the master # pending list. This prevents triggering new deferreds which # may be added by callback or errback functions on the current # deferreds. pending = self.controller.pending[:] del self.controller.pending[:] for pendingState in pending: d = pendingState[0] d.errback(reason) def buildProtocol(self, addr): p = dns.DNSProtocol(self.controller) p.factory = self return p def createResolver(servers=None, resolvconf=None, hosts=None): r""" Create and return a Resolver. @type servers: C{list} of C{(str, int)} or L{None} @param servers: If not L{None}, interpreted as a list of domain name servers to attempt to use. Each server is a tuple of address in C{str} dotted-quad form and C{int} port number. @type resolvconf: C{str} or L{None} @param resolvconf: If not L{None}, on posix systems will be interpreted as an alternate resolv.conf to use. Will do nothing on windows systems. If L{None}, /etc/resolv.conf will be used. @type hosts: C{str} or L{None} @param hosts: If not L{None}, an alternate hosts file to use. If L{None} on posix systems, /etc/hosts will be used. On windows, C:\windows\hosts will be used. @rtype: C{IResolver} """ if platform.getType() == "posix": if resolvconf is None: resolvconf = b"/etc/resolv.conf" if hosts is None: hosts = b"/etc/hosts" theResolver = Resolver(resolvconf, servers) hostResolver = hostsModule.Resolver(hosts) else: if hosts is None: hosts = r"c:\windows\hosts" from twisted.internet import reactor bootstrap = _ThreadedResolverImpl(reactor) hostResolver = hostsModule.Resolver(hosts) theResolver = root.bootstrap(bootstrap, resolverFactory=Resolver) L = [hostResolver, cache.CacheResolver(), theResolver] return resolve.ResolverChain(L) theResolver = None def getResolver(): """ Get a Resolver instance. Create twisted.names.client.theResolver if it is L{None}, and then return that value. @rtype: C{IResolver} """ global theResolver if theResolver is None: try: theResolver = createResolver() except ValueError: theResolver = createResolver(servers=[("127.0.0.1", 53)]) return theResolver def getHostByName(name, timeout=None, effort=10): """ Resolve a name to a valid ipv4 or ipv6 address. Will errback with C{DNSQueryTimeoutError} on a timeout, C{DomainError} or C{AuthoritativeDomainError} (or subclasses) on other errors. @type name: C{str} @param name: DNS name to resolve. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @type effort: C{int} @param effort: How many times CNAME and NS records to follow while resolving this name. @rtype: C{Deferred} """ return getResolver().getHostByName(name, timeout, effort) def query(query, timeout=None): return getResolver().query(query, timeout) def lookupAddress(name, timeout=None): return getResolver().lookupAddress(name, timeout) def lookupIPV6Address(name, timeout=None): return getResolver().lookupIPV6Address(name, timeout) def lookupAddress6(name, timeout=None): return getResolver().lookupAddress6(name, timeout) def lookupMailExchange(name, timeout=None): return getResolver().lookupMailExchange(name, timeout) def lookupNameservers(name, timeout=None): return getResolver().lookupNameservers(name, timeout) def lookupCanonicalName(name, timeout=None): return getResolver().lookupCanonicalName(name, timeout) def lookupMailBox(name, timeout=None): return getResolver().lookupMailBox(name, timeout) def lookupMailGroup(name, timeout=None): return getResolver().lookupMailGroup(name, timeout) def lookupMailRename(name, timeout=None): return getResolver().lookupMailRename(name, timeout) def lookupPointer(name, timeout=None): return getResolver().lookupPointer(name, timeout) def lookupAuthority(name, timeout=None): return getResolver().lookupAuthority(name, timeout) def lookupNull(name, timeout=None): return getResolver().lookupNull(name, timeout) def lookupWellKnownServices(name, timeout=None): return getResolver().lookupWellKnownServices(name, timeout) def lookupService(name, timeout=None): return getResolver().lookupService(name, timeout) def lookupHostInfo(name, timeout=None): return getResolver().lookupHostInfo(name, timeout) def lookupMailboxInfo(name, timeout=None): return getResolver().lookupMailboxInfo(name, timeout) def lookupText(name, timeout=None): return getResolver().lookupText(name, timeout) def lookupSenderPolicy(name, timeout=None): return getResolver().lookupSenderPolicy(name, timeout) def lookupResponsibility(name, timeout=None): return getResolver().lookupResponsibility(name, timeout) def lookupAFSDatabase(name, timeout=None): return getResolver().lookupAFSDatabase(name, timeout) def lookupZone(name, timeout=None): return getResolver().lookupZone(name, timeout) def lookupAllRecords(name, timeout=None): return getResolver().lookupAllRecords(name, timeout) def lookupNamingAuthorityPointer(name, timeout=None): return getResolver().lookupNamingAuthorityPointer(name, timeout) PK y�Z�����$ �$ common.pynu �[��� # -*- test-case-name: twisted.names.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Base functionality useful to various parts of Twisted Names. """ import socket from zope.interface import implementer from twisted.internet import defer, error, interfaces from twisted.logger import Logger from twisted.names import dns from twisted.names.error import ( DNSFormatError, DNSNameError, DNSNotImplementedError, DNSQueryRefusedError, DNSServerError, DNSUnknownError, ) # Helpers for indexing the three-tuples that get thrown around by this code a # lot. _ANS, _AUTH, _ADD = range(3) EMPTY_RESULT = (), (), () @implementer(interfaces.IResolver) class ResolverBase: """ L{ResolverBase} is a base class for implementations of L{interfaces.IResolver} which deals with a lot of the boilerplate of implementing all of the lookup methods. @cvar _errormap: A C{dict} mapping DNS protocol failure response codes to exception classes which will be used to represent those failures. """ _log = Logger() _errormap = { dns.EFORMAT: DNSFormatError, dns.ESERVER: DNSServerError, dns.ENAME: DNSNameError, dns.ENOTIMP: DNSNotImplementedError, dns.EREFUSED: DNSQueryRefusedError, } typeToMethod = None def __init__(self): self.typeToMethod = {} for (k, v) in typeToMethod.items(): self.typeToMethod[k] = getattr(self, v) def exceptionForCode(self, responseCode): """ Convert a response code (one of the possible values of L{dns.Message.rCode} to an exception instance representing it. @since: 10.0 """ return self._errormap.get(responseCode, DNSUnknownError) def query(self, query, timeout=None): try: method = self.typeToMethod[query.type] except KeyError: self._log.debug( "Query of unknown type {query.type} for {query.name.name!r}", query=query, ) return defer.maybeDeferred( self._lookup, query.name.name, dns.IN, query.type, timeout ) else: return defer.maybeDeferred(method, query.name.name, timeout) def _lookup(self, name, cls, type, timeout): return defer.fail(NotImplementedError("ResolverBase._lookup")) def lookupAddress(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.A, timeout) def lookupIPV6Address(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.AAAA, timeout) def lookupAddress6(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.A6, timeout) def lookupMailExchange(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MX, timeout) def lookupNameservers(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.NS, timeout) def lookupCanonicalName(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.CNAME, timeout) def lookupMailBox(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MB, timeout) def lookupMailGroup(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MG, timeout) def lookupMailRename(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MR, timeout) def lookupPointer(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.PTR, timeout) def lookupAuthority(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.SOA, timeout) def lookupNull(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.NULL, timeout) def lookupWellKnownServices(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.WKS, timeout) def lookupService(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.SRV, timeout) def lookupHostInfo(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.HINFO, timeout) def lookupMailboxInfo(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MINFO, timeout) def lookupText(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.TXT, timeout) def lookupSenderPolicy(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.SPF, timeout) def lookupResponsibility(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.RP, timeout) def lookupAFSDatabase(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.AFSDB, timeout) def lookupZone(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.AXFR, timeout) def lookupNamingAuthorityPointer(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.NAPTR, timeout) def lookupAllRecords(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.ALL_RECORDS, timeout) # IResolverSimple def getHostByName(self, name, timeout=None, effort=10): name = dns.domainString(name) # XXX - respect timeout # XXX - this should do A and AAAA lookups, not ANY (see RFC 8482). # https://twistedmatrix.com/trac/ticket/9691 d = self.lookupAllRecords(name, timeout) d.addCallback(self._cbRecords, name, effort) return d def _cbRecords(self, records, name, effort): (ans, auth, add) = records result = extractRecord(self, dns.Name(name), ans + auth + add, effort) if not result: raise error.DNSLookupError(name) return result def extractRecord(resolver, name, answers, level=10): """ Resolve a name to an IP address, following I{CNAME} records and I{NS} referrals recursively. This is an implementation detail of L{ResolverBase.getHostByName}. @param resolver: The resolver to use for the next query (unless handling an I{NS} referral). @type resolver: L{IResolver} @param name: The name being looked up. @type name: L{dns.Name} @param answers: All of the records returned by the previous query (answers, authority, and additional concatenated). @type answers: L{list} of L{dns.RRHeader} @param level: Remaining recursion budget. This is decremented at each recursion. The query returns L{None} when it reaches 0. @type level: L{int} @returns: The first IPv4 or IPv6 address (as a dotted quad or colon quibbles), or L{None} when no result is found. @rtype: native L{str} or L{None} """ if not level: return None # FIXME: twisted.python.compat monkeypatches this if missing, so this # condition is always true. https://twistedmatrix.com/trac/ticket/9753 if hasattr(socket, "inet_ntop"): for r in answers: if r.name == name and r.type == dns.A6: return socket.inet_ntop(socket.AF_INET6, r.payload.address) for r in answers: if r.name == name and r.type == dns.AAAA: return socket.inet_ntop(socket.AF_INET6, r.payload.address) for r in answers: if r.name == name and r.type == dns.A: return socket.inet_ntop(socket.AF_INET, r.payload.address) for r in answers: if r.name == name and r.type == dns.CNAME: result = extractRecord(resolver, r.payload.name, answers, level - 1) if not result: return resolver.getHostByName(r.payload.name.name, effort=level - 1) return result # No answers, but maybe there's a hint at who we should be asking about # this for r in answers: if r.type != dns.NS: continue from twisted.names import client nsResolver = client.Resolver( servers=[ (r.payload.name.name.decode("ascii"), dns.PORT), ] ) def queryAgain(records): (ans, auth, add) = records return extractRecord(nsResolver, name, ans + auth + add, level - 1) return nsResolver.lookupAddress(name.name).addCallback(queryAgain) typeToMethod = { dns.A: "lookupAddress", dns.AAAA: "lookupIPV6Address", dns.A6: "lookupAddress6", dns.NS: "lookupNameservers", dns.CNAME: "lookupCanonicalName", dns.SOA: "lookupAuthority", dns.MB: "lookupMailBox", dns.MG: "lookupMailGroup", dns.MR: "lookupMailRename", dns.NULL: "lookupNull", dns.WKS: "lookupWellKnownServices", dns.PTR: "lookupPointer", dns.HINFO: "lookupHostInfo", dns.MINFO: "lookupMailboxInfo", dns.MX: "lookupMailExchange", dns.TXT: "lookupText", dns.SPF: "lookupSenderPolicy", dns.RP: "lookupResponsibility", dns.AFSDB: "lookupAFSDatabase", dns.SRV: "lookupService", dns.NAPTR: "lookupNamingAuthorityPointer", dns.AXFR: "lookupZone", dns.ALL_RECORDS: "lookupAllRecords", } PK y�Z)�5̈0 �0 root.pynu �[��� # -*- test-case-name: twisted.names.test.test_rootresolve -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Resolver implementation for querying successive authoritative servers to lookup a record, starting from the root nameservers. @author: Jp Calderone todo:: robustify it documentation """ from twisted.internet import defer from twisted.names import common, dns, error from twisted.python.failure import Failure class _DummyController: """ A do-nothing DNS controller. This is useful when all messages received will be responses to previously issued queries. Anything else received will be ignored. """ def messageReceived(self, *args): pass class Resolver(common.ResolverBase): """ L{Resolver} implements recursive lookup starting from a specified list of root servers. @ivar hints: See C{hints} parameter of L{__init__} @ivar _maximumQueries: See C{maximumQueries} parameter of L{__init__} @ivar _reactor: See C{reactor} parameter of L{__init__} @ivar _resolverFactory: See C{resolverFactory} parameter of L{__init__} """ def __init__(self, hints, maximumQueries=10, reactor=None, resolverFactory=None): """ @param hints: A L{list} of L{str} giving the dotted quad representation of IP addresses of root servers at which to begin resolving names. @type hints: L{list} of L{str} @param maximumQueries: An optional L{int} giving the maximum number of queries which will be attempted to resolve a single name. @type maximumQueries: L{int} @param reactor: An optional L{IReactorTime} and L{IReactorUDP} provider to use to bind UDP ports and manage timeouts. @type reactor: L{IReactorTime} and L{IReactorUDP} provider @param resolverFactory: An optional callable which accepts C{reactor} and C{servers} arguments and returns an instance that provides a C{queryUDP} method. Defaults to L{twisted.names.client.Resolver}. @type resolverFactory: callable """ common.ResolverBase.__init__(self) self.hints = hints self._maximumQueries = maximumQueries self._reactor = reactor if resolverFactory is None: from twisted.names.client import Resolver as resolverFactory self._resolverFactory = resolverFactory def _roots(self): """ Return a list of two-tuples representing the addresses of the root servers, as defined by C{self.hints}. """ return [(ip, dns.PORT) for ip in self.hints] def _query(self, query, servers, timeout, filter): """ Issue one query and return a L{Deferred} which fires with its response. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A timeout on how long to wait for the response. @type timeout: L{tuple} of L{int} @param filter: A flag indicating whether to filter the results. If C{True}, the returned L{Deferred} will fire with a three-tuple of lists of L{twisted.names.dns.RRHeader} (like the return value of the I{lookup*} methods of L{IResolver}. IF C{False}, the result will be a L{Message} instance. @type filter: L{bool} @return: A L{Deferred} which fires with the response or a timeout error. @rtype: L{Deferred} """ r = self._resolverFactory(servers=servers, reactor=self._reactor) d = r.queryUDP([query], timeout) if filter: d.addCallback(r.filterAnswers) return d def _lookup(self, name, cls, type, timeout): """ Implement name lookup by recursively discovering the authoritative server for the name and then asking it, starting at one of the servers in C{self.hints}. """ if timeout is None: # A series of timeouts for semi-exponential backoff, summing to an # arbitrary total of 60 seconds. timeout = (1, 3, 11, 45) return self._discoverAuthority( dns.Query(name, type, cls), self._roots(), timeout, self._maximumQueries ) def _discoverAuthority(self, query, servers, timeout, queriesLeft): """ Issue a query to a server and follow a delegation if necessary. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A C{tuple} of C{int} giving the timeout to use for this query. @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response, or with a L{Failure} if there is a timeout or response error. """ # Stop now if we've hit the query limit. if queriesLeft <= 0: return Failure(error.ResolverError("Query limit reached without result")) d = self._query(query, servers, timeout, False) d.addCallback(self._discoveredAuthority, query, timeout, queriesLeft - 1) return d def _discoveredAuthority(self, response, query, timeout, queriesLeft): """ Interpret the response to a query, checking for error codes and following delegations if necessary. @param response: The L{Message} received in response to issuing C{query}. @type response: L{Message} @param query: The L{dns.Query} which was issued. @type query: L{dns.Query}. @param timeout: The timeout to use if another query is indicated by this response. @type timeout: L{tuple} of L{int} @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Failure} indicating a response error, a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response to C{query} or a L{Deferred} which will fire with one of those. """ if response.rCode != dns.OK: return Failure(self.exceptionForCode(response.rCode)(response)) # Turn the answers into a structure that's a little easier to work with. records = {} for answer in response.answers: records.setdefault(answer.name, []).append(answer) def findAnswerOrCName(name, type, cls): cname = None for record in records.get(name, []): if record.cls == cls: if record.type == type: return record elif record.type == dns.CNAME: cname = record # If there were any CNAME records, return the last one. There's # only supposed to be zero or one, though. return cname seen = set() name = query.name record = None while True: seen.add(name) previous = record record = findAnswerOrCName(name, query.type, query.cls) if record is None: if name == query.name: # If there's no answer for the original name, then this may # be a delegation. Code below handles it. break else: # Try to resolve the CNAME with another query. d = self._discoverAuthority( dns.Query(str(name), query.type, query.cls), self._roots(), timeout, queriesLeft, ) # We also want to include the CNAME in the ultimate result, # otherwise this will be pretty confusing. def cbResolved(results): answers, authority, additional = results answers.insert(0, previous) return (answers, authority, additional) d.addCallback(cbResolved) return d elif record.type == query.type: return (response.answers, response.authority, response.additional) else: # It's a CNAME record. Try to resolve it from the records # in this response with another iteration around the loop. if record.payload.name in seen: raise error.ResolverError("Cycle in CNAME processing") name = record.payload.name # Build a map to use to convert NS names into IP addresses. addresses = {} for rr in response.additional: if rr.type == dns.A: addresses[rr.name.name] = rr.payload.dottedQuad() hints = [] traps = [] for rr in response.authority: if rr.type == dns.NS: ns = rr.payload.name.name if ns in addresses: hints.append((addresses[ns], dns.PORT)) else: traps.append(ns) if hints: return self._discoverAuthority(query, hints, timeout, queriesLeft) elif traps: d = self.lookupAddress(traps[0], timeout) def getOneAddress(results): answers, authority, additional = results return answers[0].payload.dottedQuad() d.addCallback(getOneAddress) d.addCallback( lambda hint: self._discoverAuthority( query, [(hint, dns.PORT)], timeout, queriesLeft - 1 ) ) return d else: return Failure( error.ResolverError("Stuck at response without answers or delegation") ) def makePlaceholder(deferred, name): def placeholder(*args, **kw): deferred.addCallback(lambda r: getattr(r, name)(*args, **kw)) return deferred return placeholder class DeferredResolver: def __init__(self, resolverDeferred): self.waiting = [] resolverDeferred.addCallback(self.gotRealResolver) def gotRealResolver(self, resolver): w = self.waiting self.__dict__ = resolver.__dict__ self.__class__ = resolver.__class__ for d in w: d.callback(resolver) def __getattr__(self, name): if name.startswith("lookup") or name in ("getHostByName", "query"): self.waiting.append(defer.Deferred()) return makePlaceholder(self.waiting[-1], name) raise AttributeError(name) def bootstrap(resolver, resolverFactory=None): """ Lookup the root nameserver addresses using the given resolver Return a Resolver which will eventually become a C{root.Resolver} instance that has references to all the root servers that we were able to look up. @param resolver: The resolver instance which will be used to lookup the root nameserver addresses. @type resolver: L{twisted.internet.interfaces.IResolverSimple} @param resolverFactory: An optional callable which returns a resolver instance. It will passed as the C{resolverFactory} argument to L{Resolver.__init__}. @type resolverFactory: callable @return: A L{DeferredResolver} which will be dynamically replaced with L{Resolver} when the root nameservers have been looked up. """ domains = [chr(ord("a") + i) for i in range(13)] L = [resolver.getHostByName("%s.root-servers.net" % d) for d in domains] d = defer.DeferredList(L, consumeErrors=True) def buildResolver(res): return Resolver( hints=[e[1] for e in res if e[0]], resolverFactory=resolverFactory ) d.addCallback(buildResolver) return DeferredResolver(d) PK y�ZXV �V server.pynu �[��� # -*- test-case-name: twisted.names.test.test_names,twisted.names.test.test_server -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Async DNS server Future plans: - Better config file format maybe - Make sure to differentiate between different classes - notice truncation bit Important: No additional processing is done on some of the record types. This violates the most basic RFC and is just plain annoying for resolvers to deal with. Fix it. @author: Jp Calderone """ import time from twisted.internet import protocol from twisted.names import dns, resolve from twisted.python import log class DNSServerFactory(protocol.ServerFactory): """ Server factory and tracker for L{DNSProtocol} connections. This class also provides records for responses to DNS queries. @ivar cache: A L{Cache<twisted.names.cache.CacheResolver>} instance whose C{cacheResult} method is called when a response is received from one of C{clients}. Defaults to L{None} if no caches are specified. See C{caches} of L{__init__} for more details. @type cache: L{Cache<twisted.names.cache.CacheResolver>} or L{None} @ivar canRecurse: A flag indicating whether this server is capable of performing recursive DNS resolution. @type canRecurse: L{bool} @ivar resolver: A L{resolve.ResolverChain} containing an ordered list of C{authorities}, C{caches} and C{clients} to which queries will be dispatched. @type resolver: L{resolve.ResolverChain} @ivar verbose: See L{__init__} @ivar connections: A list of all the connected L{DNSProtocol} instances using this object as their controller. @type connections: C{list} of L{DNSProtocol} instances @ivar protocol: A callable used for building a DNS stream protocol. Called by L{DNSServerFactory.buildProtocol} and passed the L{DNSServerFactory} instance as the one and only positional argument. Defaults to L{dns.DNSProtocol}. @type protocol: L{IProtocolFactory} constructor @ivar _messageFactory: A response message constructor with an initializer signature matching L{dns.Message.__init__}. @type _messageFactory: C{callable} """ # Type is wrong. See: https://twistedmatrix.com/trac/ticket/10004#ticket protocol = dns.DNSProtocol # type: ignore[assignment] cache = None _messageFactory = dns.Message def __init__(self, authorities=None, caches=None, clients=None, verbose=0): """ @param authorities: Resolvers which provide authoritative answers. @type authorities: L{list} of L{IResolver} providers @param caches: Resolvers which provide cached non-authoritative answers. The first cache instance is assigned to C{DNSServerFactory.cache} and its C{cacheResult} method will be called when a response is received from one of C{clients}. @type caches: L{list} of L{Cache<twisted.names.cache.CacheResolver>} instances @param clients: Resolvers which are capable of performing recursive DNS lookups. @type clients: L{list} of L{IResolver} providers @param verbose: An integer controlling the verbosity of logging of queries and responses. Default is C{0} which means no logging. Set to C{2} to enable logging of full query and response messages. @type verbose: L{int} """ resolvers = [] if authorities is not None: resolvers.extend(authorities) if caches is not None: resolvers.extend(caches) if clients is not None: resolvers.extend(clients) self.canRecurse = not not clients self.resolver = resolve.ResolverChain(resolvers) self.verbose = verbose if caches: self.cache = caches[-1] self.connections = [] def _verboseLog(self, *args, **kwargs): """ Log a message only if verbose logging is enabled. @param args: Positional arguments which will be passed to C{log.msg} @param kwargs: Keyword arguments which will be passed to C{log.msg} """ if self.verbose > 0: log.msg(*args, **kwargs) def buildProtocol(self, addr): p = self.protocol(self) p.factory = self return p def connectionMade(self, protocol): """ Track a newly connected L{DNSProtocol}. @param protocol: The protocol instance to be tracked. @type protocol: L{dns.DNSProtocol} """ self.connections.append(protocol) def connectionLost(self, protocol): """ Stop tracking a no-longer connected L{DNSProtocol}. @param protocol: The tracked protocol instance to be which has been lost. @type protocol: L{dns.DNSProtocol} """ self.connections.remove(protocol) def sendReply(self, protocol, message, address): """ Send a response C{message} to a given C{address} via the supplied C{protocol}. Message payload will be logged if C{DNSServerFactory.verbose} is C{>1}. @param protocol: The DNS protocol instance to which to send the message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The DNS message to be sent. @type message: L{dns.Message} @param address: The address to which the message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ if self.verbose > 1: s = " ".join([str(a.payload) for a in message.answers]) auth = " ".join([str(a.payload) for a in message.authority]) add = " ".join([str(a.payload) for a in message.additional]) if not s: log.msg("Replying with no answers") else: log.msg("Answers are " + s) log.msg("Authority is " + auth) log.msg("Additional is " + add) if address is None: protocol.writeMessage(message) else: protocol.writeMessage(message, address) self._verboseLog( "Processed query in %0.3f seconds" % (time.time() - message.timeReceived) ) def _responseFromMessage( self, message, rCode=dns.OK, answers=None, authority=None, additional=None ): """ Generate a L{Message} instance suitable for use as the response to C{message}. C{queries} will be copied from the request to the response. C{rCode}, C{answers}, C{authority} and C{additional} will be assigned to the response, if supplied. The C{recAv} flag will be set on the response if the C{canRecurse} flag on this L{DNSServerFactory} is set to L{True}. The C{auth} flag will be set on the response if *any* of the supplied C{answers} have their C{auth} flag set to L{True}. The response will have the same C{maxSize} as the request. Additionally, the response will have a C{timeReceived} attribute whose value is that of the original request and the @see: L{dns._responseFromMessage} @param message: The request message @type message: L{Message} @param rCode: The response code which will be assigned to the response. @type message: L{int} @param answers: An optional list of answer records which will be assigned to the response. @type answers: L{list} of L{dns.RRHeader} @param authority: An optional list of authority records which will be assigned to the response. @type authority: L{list} of L{dns.RRHeader} @param additional: An optional list of additional records which will be assigned to the response. @type additional: L{list} of L{dns.RRHeader} @return: A response L{Message} instance. @rtype: L{Message} """ if answers is None: answers = [] if authority is None: authority = [] if additional is None: additional = [] authoritativeAnswer = False for x in answers: if x.isAuthoritative(): authoritativeAnswer = True break response = dns._responseFromMessage( responseConstructor=self._messageFactory, message=message, recAv=self.canRecurse, rCode=rCode, auth=authoritativeAnswer, ) # XXX: Timereceived is a hack which probably shouldn't be tacked onto # the message. Use getattr here so that we don't have to set the # timereceived on every message in the tests. See #6957. response.timeReceived = getattr(message, "timeReceived", None) # XXX: This is another hack. dns.Message.decode sets maxSize=0 which # means that responses are never truncated. I'll maintain that behaviour # here until #6949 is resolved. response.maxSize = message.maxSize response.answers = answers response.authority = authority response.additional = additional return response def gotResolverResponse(self, response, protocol, message, address): """ A callback used by L{DNSServerFactory.handleQuery} for handling the deferred response from C{self.resolver.query}. Constructs a response message by combining the original query message with the resolved answer, authority and additional records. Marks the response message as authoritative if any of the resolved answers are found to be authoritative. The resolved answers count will be logged if C{DNSServerFactory.verbose} is C{>1}. @param response: Answer records, authority records and additional records @type response: L{tuple} of L{list} of L{dns.RRHeader} instances @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ ans, auth, add = response response = self._responseFromMessage( message=message, rCode=dns.OK, answers=ans, authority=auth, additional=add ) self.sendReply(protocol, response, address) l = len(ans) + len(auth) + len(add) self._verboseLog("Lookup found %d record%s" % (l, l != 1 and "s" or "")) if self.cache and l: self.cache.cacheResult(message.queries[0], (ans, auth, add)) def gotResolverError(self, failure, protocol, message, address): """ A callback used by L{DNSServerFactory.handleQuery} for handling deferred errors from C{self.resolver.query}. Constructs a response message from the original query message by assigning a suitable error code to C{rCode}. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. @param failure: The reason for the failed resolution (as reported by C{self.resolver.query}). @type failure: L{Failure<twisted.python.failure.Failure>} @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ if failure.check(dns.DomainError, dns.AuthoritativeDomainError): rCode = dns.ENAME else: rCode = dns.ESERVER log.err(failure) response = self._responseFromMessage(message=message, rCode=rCode) self.sendReply(protocol, response, address) self._verboseLog("Lookup failed") def handleQuery(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when a query message is received. Takes the first query from the received message and dispatches it to C{self.resolver.query}. Adds callbacks L{DNSServerFactory.gotResolverResponse} and L{DNSServerFactory.gotResolverError} to the resulting deferred. Note: Multiple queries in a single message are not supported because there is no standard way to respond with multiple rCodes, auth, etc. This is consistent with other DNS server implementations. See U{http://tools.ietf.org/html/draft-ietf-dnsext-edns1-03} for a proposed solution. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} @return: A C{deferred} which fires with the resolved result or error of the first query in C{message}. @rtype: L{Deferred<twisted.internet.defer.Deferred>} """ query = message.queries[0] return ( self.resolver.query(query) .addCallback(self.gotResolverResponse, protocol, message, address) .addErrback(self.gotResolverError, protocol, message, address) ) def handleInverseQuery(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when an inverse query message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ message.rCode = dns.ENOTIMP self.sendReply(protocol, message, address) self._verboseLog(f"Inverse query from {address!r}") def handleStatus(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when a status message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ message.rCode = dns.ENOTIMP self.sendReply(protocol, message, address) self._verboseLog(f"Status request from {address!r}") def handleNotify(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when a notify message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ message.rCode = dns.ENOTIMP self.sendReply(protocol, message, address) self._verboseLog(f"Notify message from {address!r}") def handleOther(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when a message with unrecognised I{OPCODE} is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ message.rCode = dns.ENOTIMP self.sendReply(protocol, message, address) self._verboseLog("Unknown op code (%d) from %r" % (message.opCode, address)) def messageReceived(self, message, proto, address=None): """ L{DNSServerFactory.messageReceived} is called by protocols which are under the control of this L{DNSServerFactory} whenever they receive a DNS query message or an unexpected / duplicate / late DNS response message. L{DNSServerFactory.allowQuery} is called with the received message, protocol and origin address. If it returns L{False}, a C{dns.EREFUSED} response is sent back to the client. Otherwise the received message is dispatched to one of L{DNSServerFactory.handleQuery}, L{DNSServerFactory.handleInverseQuery}, L{DNSServerFactory.handleStatus}, L{DNSServerFactory.handleNotify}, or L{DNSServerFactory.handleOther} depending on the I{OPCODE} of the received message. If C{DNSServerFactory.verbose} is C{>0} all received messages will be logged in more or less detail depending on the value of C{verbose}. @param message: The DNS message that was received. @type message: L{dns.Message} @param proto: The DNS protocol instance which received the message @type proto: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param address: The address from which the message was received. Only provided for messages received by datagram protocols. The origin of Messages received from stream protocols can be gleaned from the protocol C{transport} attribute. @type address: L{tuple} or L{None} """ message.timeReceived = time.time() if self.verbose: if self.verbose > 1: s = " ".join([str(q) for q in message.queries]) else: s = " ".join( [dns.QUERY_TYPES.get(q.type, "UNKNOWN") for q in message.queries] ) if not len(s): log.msg(f"Empty query from {address or proto.transport.getPeer()!r}") else: log.msg(f"{s} query from {address or proto.transport.getPeer()!r}") if not self.allowQuery(message, proto, address): message.rCode = dns.EREFUSED self.sendReply(proto, message, address) elif message.opCode == dns.OP_QUERY: self.handleQuery(message, proto, address) elif message.opCode == dns.OP_INVERSE: self.handleInverseQuery(message, proto, address) elif message.opCode == dns.OP_STATUS: self.handleStatus(message, proto, address) elif message.opCode == dns.OP_NOTIFY: self.handleNotify(message, proto, address) else: self.handleOther(message, proto, address) def allowQuery(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} to decide whether to process a received message or to reply with C{dns.EREFUSED}. This default implementation permits anything but empty queries. Override in a subclass to implement alternative policies. @param message: The DNS message that was received. @type message: L{dns.Message} @param protocol: The DNS protocol instance which received the message @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param address: The address from which the message was received. Only provided for messages received by datagram protocols. The origin of Messages received from stream protocols can be gleaned from the protocol C{transport} attribute. @type address: L{tuple} or L{None} @return: L{True} if the received message contained one or more queries, else L{False}. @rtype: L{bool} """ return len(message.queries) PK y�Z�G�G� � __init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted Names: DNS server and client implementations. """ PK y�Z.{sa�# �# srvconnect.pynu �[��� PK y�Z�� }� � )$ tap.pynu �[��� PK y�Z�UG�z! z! $ 7 __pycache__/_rfc1982.cpython-310.pycnu �[��� PK y�Z��8Q� � % �X __pycache__/secondary.cpython-310.pycnu �[��� PK y�ZER\w�R �R " x __pycache__/server.cpython-310.pycnu �[��� PK y�ZKG�&� � $ � __pycache__/__init__.cpython-310.pycnu �[��� PK y�Z3Qb�V �V " E� __pycache__/client.cpython-310.pycnu �[��� PK y�Z�?<3�9 �9 % 2# __pycache__/authority.cpython-310.pycnu �[��� PK y�Z��� � ! ] __pycache__/hosts.cpython-310.pycnu �[��� PK y�ZNB<�� � Cq __pycache__/tap.cpython-310.pycnu �[��� PK y�Z��U�p p o� __pycache__/dns.cpython-310.pycnu �[��� PK y�Z��>�+ + ! �� __pycache__/cache.cpython-310.pycnu �[��� PK y�Z��g�! �! & J __pycache__/srvconnect.cpython-310.pycnu �[��� PK y�Z{T;�. �. �% __pycache__/root.cpython-310.pycnu �[��� PK y�Z��S�� � ! yT __pycache__/error.cpython-310.pycnu �[��� PK y�ZDž7 7 # �_ __pycache__/resolve.cpython-310.pycnu �[��� PK y�Z%�%�# �# " 2m __pycache__/common.cpython-310.pycnu �[��� PK y�Z�z���# �# 4� _rfc1982.pynu �[��� PK y�Z�B��1 1 3� test/test_resolve.pynu �[��� PK y�Z\�)wǢ Ǣ �� test/test_server.pynu �[��� PK y�Z���}� � �\ test/test_cache.pynu �[��� PK y�Z��V� 6 6 �r test/test_rfc1982.pynu �[��� PK y�Z!/ӏ� � + � test/__pycache__/test_names.cpython-310.pycnu �[��� PK y�Z� -m m - ZW test/__pycache__/test_resolve.cpython-310.pycnu �[��� PK y�Z52@�> �> - $] test/__pycache__/test_rfc1982.cpython-310.pycnu �[��� PK y�Z�^^� � . � test/__pycache__/test_examples.cpython-310.pycnu �[��� PK y�Z�� � ) �� test/__pycache__/test_dns.cpython-310.pycnu �[��� PK y�Z�ѽ � ) ؼ test/__pycache__/__init__.cpython-310.pycnu �[��� PK y�Z��q��W �W 1 � test/__pycache__/test_rootresolve.cpython-310.pycnu �[��� PK y�ZS>�� � * � test/__pycache__/test_util.cpython-310.pycnu �[��� PK y�Z ^��r� r� , D' test/__pycache__/test_client.cpython-310.pycnu �[��� PK y�Z�;� u u ) � test/__pycache__/test_tap.cpython-310.pycnu �[��� PK y�Z�Fa£ £ , �� test/__pycache__/test_server.cpython-310.pycnu �[��� PK y�Z��h.5 5 , �� test/__pycache__/test_common.cpython-310.pycnu �[��� PK y�Z����P% P% 0 �� test/__pycache__/test_srvconnect.cpython-310.pycnu �[��� PK y�Z<�d( ( + ?� test/__pycache__/test_hosts.cpython-310.pycnu �[��� PK y�Z ��% + �� test/__pycache__/test_cache.cpython-310.pycnu �[��� PK y�Z�����& �& � test/test_hosts.pynu �[��� PK y�ZI�Q��s �s & test/test_dns.pynu �[��� PK y�Z�H�4d 4d 4� test/test_rootresolve.pynu �[��� PK y�Z��4B^� ^� �� test/test_names.pynu �[��� PK y�ZG�O�� � P� test/test_util.pynu �[��� PK y�Z�l�� � �� test/test_tap.pynu �[��� PK y�ZT=y� b� test/test_common.pynu �[��� PK y�ZD!F�� � �� test/test_examples.pynu �[��� PK y�Z�U#u�$ �$ � test/test_srvconnect.pynu �[��� PK y�Z��C� �* test/__init__.pynu �[��� PK y�Z��Ք � � :+ test/test_client.pynu �[��� PK y�Z�l��� � �� secondary.pynu �[��� PK y�Z���]� � �� resolve.pynu �[��� PK y�Z�O��� � �� error.pynu �[��� PK y�ZX��� � � hosts.pynu �[��� PK y�Z.#,��� �� � dns.pynu �[��� PK y�Z�!��+A +A �� authority.pynu �[��� PK y�ZR0-�� � � cache.pynu �[��� PK y�ZOK�_ �_ � client.pynu �[��� PK y�Z�����$ �$ F common.pynu �[��� PK y�Z)�5̈0 �0 �j root.pynu �[��� PK y�ZXV �V �� server.pynu �[��� PK y�Z�G�G� � k� __init__.pynu �[��� PK < < < -�
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.04 |
proxy
|
phpinfo
|
Settings