LOG(prefix << qname << ": Answer has no ECS, trying again without EDNS Client Subnet Mask" << endl);
updateQueryCounts(prefix, qname, remoteIP, doTCP, doDoT);
match = d_eventTrace.add(RecEventTrace::AuthRequest, qname.toLogString() + '/' + qtype.toString(), true, 0);
- resolveret = asyncresolveWrapper(remoteIP, d_doDNSSEC, qname, auth, qtype.getCode(),
+ resolveret = asyncresolveWrapper(LogObject(prefix), remoteIP, d_doDNSSEC, qname, auth, qtype.getCode(),
doTCP, sendRDQuery, &d_now, ednsmask, &lwr, &chained, nsName); // <- we go out on the wire!
d_eventTrace.add(RecEventTrace::AuthRequest, static_cast<int64_t>(lwr.d_rcode), false, match);
}
# 22: test_EDNSBuffer.py
# 23: test_Lua.py
# 24: test_RoutingTag.py
+ # 25: test_Cookies.py
+ # 26: test_Cookies.py
_auth_cmd = ['authbind',
os.environ['PDNS']]
import socket
import os
import time
-import threading
+
from twisted.internet.protocol import Factory
from twisted.internet.protocol import Protocol
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
+import clientsubnetoption
+import cookiesoption
+
from recursortests import RecursorTest
+cookieReactorRunning = False
+
class CookiesTest(RecursorTest):
_confdir = 'Cookies'
_config_template = """
@classmethod
def startResponders(cls):
+ global cookieReactorRunning
print("Launching responders..")
address1 = cls._PREFIX + '.25'
address2 = cls._PREFIX + '.26'
port = 53
- reactor.listenUDP(port, UDPResponder(), interface=address1)
- reactor.listenTCP(port, TCPFactory(), interface=address1)
- reactor.listenUDP(port, UDPResponder(), interface=address2)
- reactor.listenTCP(port, TCPFactory(), interface=address2)
+ if not cookieReactorRunning:
+ reactor.listenUDP(port, UDPResponder(), interface=address1)
+ reactor.listenTCP(port, TCPFactory(), interface=address1)
+ reactor.listenUDP(port, UDPResponder(), interface=address2)
+ reactor.listenTCP(port, TCPFactory(), interface=address2)
+ cookieReactorRunning = True
- if not reactor.running:
- cls.Responder = threading.Thread(name='Responder', target=reactor.run, args=(False,))
- cls.Responder.daemon = True
- cls.Responder.start()
+ cls.startReactor()
def checkCookies(self, support, server='127.0.0.25'):
confdir = os.path.join('configs', self._confdir)
class UDPResponder(DatagramProtocol):
def getCookie(self, message):
for option in message.options:
- if option.otype == dns.edns.COOKIE: #and isinstance(option, dns.edns.CookieOption):
- return option.data
+ if option.otype == dns.edns.COOKIE and isinstance(option, cookiesoption.CookiesOption):
+ data = option.client
+ if option.server is not None:
+ data += option.server
+ return data
return None
def createCookie(self, clientcookie):
reactor.listenUDP(port, UDPLargeResponder(), interface=address)
ednsBufferReactorRunning = True
- if not reactor.running:
- cls._UDPResponder = threading.Thread(
- name='UDP Responder', target=reactor.run, args=(False,))
- cls._UDPResponder.setDaemon(True)
- cls._UDPResponder.start()
+ cls.startReactor()
def getMessage(self, testnum, payload=0):
do_edns = payload > 0
reactor.listenUDP(port, UDPResponder(), interface=address)
- if not reactor.running:
- cls._UDPResponder = threading.Thread(name='UDP Responder', target=reactor.run, args=(False,))
- cls._UDPResponder.setDaemon(True)
- cls._UDPResponder.start()
+ cls.startReactor()
class InteropProcessTest(RecursorTest):
_confdir = 'InteropProcess'
reactor.listenUDP(port, UDPHooksResponder(), interface=address)
hooksReactorRunning = True
- if not reactor.running:
- cls._UDPResponder = threading.Thread(name='UDP Hooks Responder', target=reactor.run, args=(False,))
- cls._UDPResponder.setDaemon(True)
- cls._UDPResponder.start()
+ cls.startReactor()
def testNoData(self):
expected = dns.rrset.from_text('nodata.luahooks.example.', 3600, dns.rdataclass.IN, 'AAAA', '2001:DB8::1')
reactor.listenUDP(port, UDPRoutingResponder(), interface=address)
routingReactorRunning = True
- if not reactor.running:
- cls._UDPResponder = threading.Thread(name='UDP Routing Responder', target=reactor.run, args=(False,))
- cls._UDPResponder.setDaemon(True)
- cls._UDPResponder.start()
+ cls.startReactor()
@classmethod
def tearDownClass(cls):
class SimpleCookiesTest(RecursorTest):
_confdir = 'SimpleCookies'
+ _auth_zones = RecursorTest._default_auth_zones
_config_template = """
recursor:
outgoing:
cookies: true""" % _confdir
- _expectedCookies = 'no'
+ _expectedCookies = 'Unsupported'
@classmethod
def generateRecursorConfig(cls, confdir):
authzonepath = os.path.join(confdir, 'authzone.zone')
class SimpleCookiesAuthEnabledTest(SimpleCookiesTest):
_confdir = 'SimpleCookiesAuthEnabled'
- _expectedCookies = 'yes'
+ _auth_zones = SimpleCookiesTest._auth_zones
+ _expectedCookies = 'Supported'
@classmethod
def generateAuthConfig(cls, confdir, threads):