regression-tests.dnsdist/test_Advanced.py

   1 #!/usr/bin/env python
   2 import base64
   3 import os
   4 import socket
   5 import time
   6 import unittest
   7 import dns
   8 from dnsdisttests import DNSDistTest
   9
  10 class TestAdvancedFixupCase(DNSDistTest):
  11
  12     _config_template = """
  13     truncateTC(true)
  14     fixupCase(true)
  15     newServer{address="127.0.0.1:%s"}
  16     """
  17
  18     def testAdvancedFixupCase(self):
  19         """
  20         Advanced: Fixup Case
  21
  22         Send a query with lower and upper chars,
  23         make the backend return a lowercase version,
  24         check that dnsdist fixes the response.
  25         """
  26         name = 'fiXuPCasE.advanced.tests.powerdns.com.'
  27         query = dns.message.make_query(name, 'A', 'IN')
  28         lowercasequery = dns.message.make_query(name.lower(), 'A', 'IN')
  29         response = dns.message.make_response(lowercasequery)
  30         expectedResponse = dns.message.make_response(query)
  31         rrset = dns.rrset.from_text(name,
  32                                     3600,
  33                                     dns.rdataclass.IN,
  34                                     dns.rdatatype.A,
  35                                     '127.0.0.1')
  36         response.answer.append(rrset)
  37         expectedResponse.answer.append(rrset)
  38
  39         for method in ("sendUDPQuery", "sendTCPQuery"):
  40             sender = getattr(self, method)
  41             (receivedQuery, receivedResponse) = sender(query, response)
  42             self.assertTrue(receivedQuery)
  43             self.assertTrue(receivedResponse)
  44             receivedQuery.id = query.id
  45             self.assertEqual(query, receivedQuery)
  46             self.assertEqual(expectedResponse, receivedResponse)
  47
  48 class TestAdvancedACL(DNSDistTest):
  49
  50     _config_template = """
  51     newServer{address="127.0.0.1:%s"}
  52     """
  53     _acl = ['192.0.2.1/32']
  54
  55     def testACLBlocked(self):
  56         """
  57         Advanced: ACL blocked
  58
  59         Send an A query to "tests.powerdns.com.",
  60         we expect no response since 127.0.0.1 is not on the
  61         ACL.
  62         """
  63         name = 'tests.powerdns.com.'
  64         query = dns.message.make_query(name, 'A', 'IN')
  65
  66         for method in ("sendUDPQuery", "sendTCPQuery"):
  67             sender = getattr(self, method)
  68             (_, receivedResponse) = sender(query, response=None, useQueue=False)
  69             self.assertEqual(receivedResponse, None)
  70
  71 class TestAdvancedStringOnlyServer(DNSDistTest):
  72
  73     _config_template = """
  74     newServer("127.0.0.1:%s")
  75     """
  76
  77     def testAdvancedStringOnlyServer(self):
  78         """
  79         Advanced: "string-only" server is placed in the default pool
  80         """
  81         name = 'string-only-server.advanced.tests.powerdns.com.'
  82         query = dns.message.make_query(name, 'A', 'IN')
  83         response = dns.message.make_response(query)
  84         rrset = dns.rrset.from_text(name,
  85                                     3600,
  86                                     dns.rdataclass.IN,
  87                                     dns.rdatatype.A,
  88                                     '192.0.2.1')
  89         response.answer.append(rrset)
  90
  91         for method in ("sendUDPQuery", "sendTCPQuery"):
  92             sender = getattr(self, method)
  93             (receivedQuery, receivedResponse) = sender(query, response)
  94             self.assertTrue(receivedQuery)
  95             self.assertTrue(receivedResponse)
  96             receivedQuery.id = query.id
  97             self.assertEqual(query, receivedQuery)
  98             self.assertEqual(response, receivedResponse)
  99
 100 @unittest.skipIf('SKIP_INCLUDEDIR_TESTS' in os.environ, 'IncludeDir tests are disabled')
 101 class TestAdvancedIncludeDir(DNSDistTest):
 102
 103     _config_template = """
 104     -- this directory contains a file allowing includedir.advanced.tests.powerdns.com.
 105     includeDirectory('test-include-dir')
 106     newServer{address="127.0.0.1:%s"}
 107     """
 108
 109     def testAdvancedIncludeDirAllowed(self):
 110         """
 111         Advanced: includeDirectory()
 112         """
 113         name = 'includedir.advanced.tests.powerdns.com.'
 114         query = dns.message.make_query(name, 'A', 'IN')
 115         response = dns.message.make_response(query)
 116         rrset = dns.rrset.from_text(name,
 117                                     3600,
 118                                     dns.rdataclass.IN,
 119                                     dns.rdatatype.A,
 120                                     '192.0.2.1')
 121         response.answer.append(rrset)
 122
 123         for method in ("sendUDPQuery", "sendTCPQuery"):
 124             sender = getattr(self, method)
 125             (receivedQuery, receivedResponse) = sender(query, response)
 126             self.assertTrue(receivedQuery)
 127             self.assertTrue(receivedResponse)
 128             receivedQuery.id = query.id
 129             self.assertEqual(query, receivedQuery)
 130             self.assertEqual(response, receivedResponse)
 131
 132         # this one should be refused
 133         name = 'notincludedir.advanced.tests.powerdns.com.'
 134         query = dns.message.make_query(name, 'A', 'IN')
 135         query.flags &= ~dns.flags.RD
 136         expectedResponse = dns.message.make_response(query)
 137         expectedResponse.set_rcode(dns.rcode.REFUSED)
 138
 139         for method in ("sendUDPQuery", "sendTCPQuery"):
 140             sender = getattr(self, method)
 141             (_, receivedResponse) = sender(query, response=None, useQueue=False)
 142             self.assertEqual(receivedResponse, expectedResponse)
 143
 144 class TestStatNodeRespRingSince(DNSDistTest):
 145
 146     _consoleKey = DNSDistTest.generateConsoleKey()
 147     _consoleKeyB64 = base64.b64encode(_consoleKey).decode('ascii')
 148     _config_params = ['_consoleKeyB64', '_consolePort', '_testServerPort']
 149     _config_template = """
 150     setKey("%s")
 151     controlSocket("127.0.0.1:%s")
 152     s1 = newServer{address="127.0.0.1:%s"}
 153     s1:setUp()
 154     function visitor(node, self, childstat)
 155         table.insert(nodesSeen, node.fullname)
 156     end
 157     """
 158
 159     def testStatNodeRespRingSince(self):
 160         """
 161         Advanced: StatNodeRespRing with optional since parameter
 162
 163         """
 164         name = 'statnodesince.advanced.tests.powerdns.com.'
 165         query = dns.message.make_query(name, 'A', 'IN')
 166         response = dns.message.make_response(query)
 167         rrset = dns.rrset.from_text(name,
 168                                     1,
 169                                     dns.rdataclass.IN,
 170                                     dns.rdatatype.A,
 171                                     '127.0.0.1')
 172         response.answer.append(rrset)
 173
 174         (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
 175         self.assertTrue(receivedQuery)
 176         self.assertTrue(receivedResponse)
 177         receivedQuery.id = query.id
 178         self.assertEqual(query, receivedQuery)
 179         self.assertEqual(response, receivedResponse)
 180
 181         self.sendConsoleCommand("nodesSeen = {}")
 182         self.sendConsoleCommand("statNodeRespRing(visitor)")
 183         nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str")
 184         nodes = nodes.strip("\n")
 185         self.assertEqual(nodes, """statnodesince.advanced.tests.powerdns.com.
 186 advanced.tests.powerdns.com.
 187 tests.powerdns.com.
 188 powerdns.com.
 189 com.""")
 190
 191         self.sendConsoleCommand("nodesSeen = {}")
 192         self.sendConsoleCommand("statNodeRespRing(visitor, 0)")
 193         nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str")
 194         nodes = nodes.strip("\n")
 195         self.assertEqual(nodes, """statnodesince.advanced.tests.powerdns.com.
 196 advanced.tests.powerdns.com.
 197 tests.powerdns.com.
 198 powerdns.com.
 199 com.""")
 200
 201         time.sleep(5)
 202
 203         self.sendConsoleCommand("nodesSeen = {}")
 204         self.sendConsoleCommand("statNodeRespRing(visitor)")
 205         nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str")
 206         nodes = nodes.strip("\n")
 207         self.assertEqual(nodes, """statnodesince.advanced.tests.powerdns.com.
 208 advanced.tests.powerdns.com.
 209 tests.powerdns.com.
 210 powerdns.com.
 211 com.""")
 212
 213         self.sendConsoleCommand("nodesSeen = {}")
 214         self.sendConsoleCommand("statNodeRespRing(visitor, 5)")
 215         nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str")
 216         nodes = nodes.strip("\n")
 217         self.assertEqual(nodes, """""")
 218
 219         self.sendConsoleCommand("nodesSeen = {}")
 220         self.sendConsoleCommand("statNodeRespRing(visitor, 10)")
 221         nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str")
 222         nodes = nodes.strip("\n")
 223         self.assertEqual(nodes, """statnodesince.advanced.tests.powerdns.com.
 224 advanced.tests.powerdns.com.
 225 tests.powerdns.com.
 226 powerdns.com.
 227 com.""")
 228
 229 class TestAdvancedGetLocalPort(DNSDistTest):
 230
 231     _config_template = """
 232     function answerBasedOnLocalPort(dq)
 233       local port = dq.localaddr:getPort()
 234       return DNSAction.Spoof, "port-was-"..port..".local-port.advanced.tests.powerdns.com."
 235     end
 236     addAction("local-port.advanced.tests.powerdns.com.", LuaAction(answerBasedOnLocalPort))
 237     newServer{address="127.0.0.1:%s"}
 238     """
 239
 240     def testAdvancedGetLocalPort(self):
 241         """
 242         Advanced: Return CNAME containing the local port
 243         """
 244         name = 'local-port.advanced.tests.powerdns.com.'
 245         query = dns.message.make_query(name, 'A', 'IN')
 246         # dnsdist set RA = RD for spoofed responses
 247         query.flags &= ~dns.flags.RD
 248
 249         response = dns.message.make_response(query)
 250         rrset = dns.rrset.from_text(name,
 251                                     60,
 252                                     dns.rdataclass.IN,
 253                                     dns.rdatatype.CNAME,
 254                                     'port-was-{}.local-port.advanced.tests.powerdns.com.'.format(self._dnsDistPort))
 255         response.answer.append(rrset)
 256
 257         for method in ("sendUDPQuery", "sendTCPQuery"):
 258             sender = getattr(self, method)
 259             (_, receivedResponse) = sender(query, response=None, useQueue=False)
 260             self.assertEqual(receivedResponse, response)
 261
 262 class TestAdvancedGetLocalPortOnAnyBind(DNSDistTest):
 263
 264     _config_template = """
 265     function answerBasedOnLocalPort(dq)
 266       local port = dq.localaddr:getPort()
 267       return DNSAction.Spoof, "port-was-"..port..".local-port-any.advanced.tests.powerdns.com."
 268     end
 269     addAction("local-port-any.advanced.tests.powerdns.com.", LuaAction(answerBasedOnLocalPort))
 270     newServer{address="127.0.0.1:%d"}
 271     """
 272     _dnsDistListeningAddr = '0.0.0.0'
 273
 274     def testAdvancedGetLocalPortOnAnyBind(self):
 275         """
 276         Advanced: Return CNAME containing the local port for an ANY bind
 277         """
 278         name = 'local-port-any.advanced.tests.powerdns.com.'
 279         query = dns.message.make_query(name, 'A', 'IN')
 280         # dnsdist set RA = RD for spoofed responses
 281         query.flags &= ~dns.flags.RD
 282
 283         response = dns.message.make_response(query)
 284         rrset = dns.rrset.from_text(name,
 285                                     60,
 286                                     dns.rdataclass.IN,
 287                                     dns.rdatatype.CNAME,
 288                                     'port-was-{}.local-port-any.advanced.tests.powerdns.com.'.format(self._dnsDistPort))
 289         response.answer.append(rrset)
 290
 291         for method in ("sendUDPQuery", "sendTCPQuery"):
 292             sender = getattr(self, method)
 293             (_, receivedResponse) = sender(query, response=None, useQueue=False)
 294             self.assertEqual(receivedResponse, response)
 295
 296 class TestAdvancedGetLocalAddressOnAnyBind(DNSDistTest):
 297
 298     _config_template = """
 299     function answerBasedOnLocalAddress(dq)
 300       local dest = tostring(dq.localaddr)
 301       local i, j = string.find(dest, "[0-9.]+")
 302       local addr = string.sub(dest, i, j)
 303       local dashAddr = string.gsub(addr, "[.]", "-")
 304       return DNSAction.Spoof, "address-was-"..dashAddr..".local-address-any.advanced.tests.powerdns.com."
 305     end
 306     addAction("local-address-any.advanced.tests.powerdns.com.", LuaAction(answerBasedOnLocalAddress))
 307     newServer{address="127.0.0.1:%s"}
 308     addLocal('0.0.0.0:%d')
 309     addLocal('[::]:%d')
 310     """
 311     _config_params = ['_testServerPort', '_dnsDistPort', '_dnsDistPort']
 312     _acl = ['127.0.0.1/32', '::1/128']
 313     _skipListeningOnCL = True
 314
 315     def testAdvancedGetLocalAddressOnAnyBind(self):
 316         """
 317         Advanced: Return CNAME containing the local address for an ANY bind
 318         """
 319         name = 'local-address-any.advanced.tests.powerdns.com.'
 320         query = dns.message.make_query(name, 'A', 'IN')
 321         # dnsdist set RA = RD for spoofed responses
 322         query.flags &= ~dns.flags.RD
 323
 324         response = dns.message.make_response(query)
 325         rrset = dns.rrset.from_text(name,
 326                                     60,
 327                                     dns.rdataclass.IN,
 328                                     dns.rdatatype.CNAME,
 329                                     'address-was-127-0-0-1.local-address-any.advanced.tests.powerdns.com.')
 330         response.answer.append(rrset)
 331
 332         for method in ("sendUDPQuery", "sendTCPQuery"):
 333             sender = getattr(self, method)
 334             (_, receivedResponse) = sender(query, response=None, useQueue=False)
 335             self.assertEqual(receivedResponse, response)
 336
 337         # now a bit more tricky, UDP-only IPv4
 338         response = dns.message.make_response(query)
 339         rrset = dns.rrset.from_text(name,
 340                                     60,
 341                                     dns.rdataclass.IN,
 342                                     dns.rdatatype.CNAME,
 343                                     'address-was-127-0-0-2.local-address-any.advanced.tests.powerdns.com.')
 344         response.answer.append(rrset)
 345         sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 346         sock.settimeout(1.0)
 347         sock.connect(('127.0.0.2', self._dnsDistPort))
 348         try:
 349             query = query.to_wire()
 350             sock.send(query)
 351             (data, remote) = sock.recvfrom(4096)
 352             self.assertEquals(remote[0], '127.0.0.2')
 353         except socket.timeout:
 354             data = None
 355
 356         self.assertTrue(data)
 357         receivedResponse = dns.message.from_wire(data)
 358         self.assertEqual(receivedResponse, response)
 359
 360     def testAdvancedCheckSourceAddrOnAnyBind(self):
 361         """
 362         Advanced: Check the source address on responses for an ANY bind
 363         """
 364         name = 'source-addr-any.advanced.tests.powerdns.com.'
 365         query = dns.message.make_query(name, 'A', 'IN')
 366         # dnsdist set RA = RD for spoofed responses
 367         query.flags &= ~dns.flags.RD
 368
 369         response = dns.message.make_response(query)
 370         rrset = dns.rrset.from_text(name,
 371                                     60,
 372                                     dns.rdataclass.IN,
 373                                     dns.rdatatype.A,
 374                                     '192.0.2.42')
 375         response.answer.append(rrset)
 376
 377         # a bit more tricky, UDP-only IPv4
 378         sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 379         sock.settimeout(1.0)
 380         sock.connect(('127.0.0.2', self._dnsDistPort))
 381         self._toResponderQueue.put(response, True, 1.0)
 382         try:
 383             data = query.to_wire()
 384             sock.send(data)
 385             (data, remote) = sock.recvfrom(4096)
 386             self.assertEquals(remote[0], '127.0.0.2')
 387         except socket.timeout:
 388             data = None
 389
 390         self.assertTrue(data)
 391         receivedResponse = dns.message.from_wire(data)
 392         receivedQuery = self._fromResponderQueue.get(True, 1.0)
 393         receivedQuery.id = query.id
 394         self.assertEqual(receivedQuery, query)
 395         self.assertEqual(receivedResponse, response)
 396
 397         # a bit more tricky, UDP-only IPv6
 398         sock = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
 399         sock.settimeout(1.0)
 400         sock.connect(('::1', self._dnsDistPort))
 401         self._toResponderQueue.put(response, True, 1.0)
 402         try:
 403             data = query.to_wire()
 404             sock.send(data)
 405             (data, remote) = sock.recvfrom(4096)
 406             self.assertEquals(remote[0], '::1')
 407         except socket.timeout:
 408             data = None
 409
 410         self.assertTrue(data)
 411         receivedResponse = dns.message.from_wire(data)
 412         receivedQuery = self._fromResponderQueue.get(True, 1.0)
 413         receivedQuery.id = query.id
 414         self.assertEqual(receivedQuery, query)
 415         self.assertEqual(receivedResponse, response)
 416
 417 class TestAdvancedGetLocalAddressOnNonDefaultLoopbackBind(DNSDistTest):
 418     # this one is tricky: on the loopback interface we cannot harvest the destination
 419     # address, so we exercise a different code path when we bind on a different address
 420     # than the default 127.0.0.1 one
 421     _config_template = """
 422     newServer{address="127.0.0.1:%s"}
 423     addLocal('127.0.1.19:%d')
 424     """
 425     _config_params = ['_testServerPort', '_dnsDistPort']
 426     _acl = ['127.0.0.1/32']
 427     _skipListeningOnCL = True
 428     _alternateListeningAddr = '127.0.1.19'
 429     _alternateListeningPort = DNSDistTest._dnsDistPort
 430
 431     def testAdvancedCheckSourceAddrOnNonDefaultLoopbackBind(self):
 432         """
 433         Advanced: Check the source address used to reply on a non-default loopback bind
 434         """
 435         name = 'source-addr-non-default-loopback.advanced.tests.powerdns.com.'
 436         query = dns.message.make_query(name, 'A', 'IN')
 437         response = dns.message.make_response(query)
 438         rrset = dns.rrset.from_text(name,
 439                                     60,
 440                                     dns.rdataclass.IN,
 441                                     dns.rdatatype.A,
 442                                     '192.0.2.42')
 443         response.answer.append(rrset)
 444
 445         # a bit more tricky, UDP-only IPv4
 446         sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 447         sock.settimeout(1.0)
 448         sock.connect(('127.0.1.19', self._dnsDistPort))
 449         self._toResponderQueue.put(response, True, 1.0)
 450         try:
 451             data = query.to_wire()
 452             sock.send(data)
 453             (data, remote) = sock.recvfrom(4096)
 454             self.assertEquals(remote[0], '127.0.1.19')
 455         except socket.timeout:
 456             data = None
 457
 458         self.assertTrue(data)
 459         receivedResponse = dns.message.from_wire(data)
 460         receivedQuery = self._fromResponderQueue.get(True, 1.0)
 461         receivedQuery.id = query.id
 462         self.assertEqual(receivedQuery, query)
 463         self.assertEqual(receivedResponse, response)
 464
 465 class TestAdvancedAllowHeaderOnly(DNSDistTest):
 466
 467     _config_template = """
 468     newServer{address="127.0.0.1:%s"}
 469     setAllowEmptyResponse(true)
 470     """
 471
 472     def testHeaderOnlyRefused(self):
 473         """
 474         Advanced: Header-only refused response
 475         """
 476         name = 'header-only-refused-response.advanced.tests.powerdns.com.'
 477         query = dns.message.make_query(name, 'A', 'IN')
 478         response = dns.message.make_response(query)
 479         response.set_rcode(dns.rcode.REFUSED)
 480         response.question = []
 481
 482         for method in ("sendUDPQuery", "sendTCPQuery"):
 483             sender = getattr(self, method)
 484             (receivedQuery, receivedResponse) = sender(query, response)
 485             self.assertTrue(receivedQuery)
 486             receivedQuery.id = query.id
 487             self.assertEqual(query, receivedQuery)
 488             self.assertEqual(receivedResponse, response)
 489
 490     def testHeaderOnlyNoErrorResponse(self):
 491         """
 492         Advanced: Header-only NoError response should be allowed
 493         """
 494         name = 'header-only-noerror-response.advanced.tests.powerdns.com.'
 495         query = dns.message.make_query(name, 'A', 'IN')
 496         response = dns.message.make_response(query)
 497         response.question = []
 498
 499         for method in ("sendUDPQuery", "sendTCPQuery"):
 500             sender = getattr(self, method)
 501             (receivedQuery, receivedResponse) = sender(query, response)
 502             self.assertTrue(receivedQuery)
 503             receivedQuery.id = query.id
 504             self.assertEqual(query, receivedQuery)
 505             self.assertEqual(receivedResponse, response)
 506
 507     def testHeaderOnlyNXDResponse(self):
 508         """
 509         Advanced: Header-only NXD response should be allowed
 510         """
 511         name = 'header-only-nxd-response.advanced.tests.powerdns.com.'
 512         query = dns.message.make_query(name, 'A', 'IN')
 513         response = dns.message.make_response(query)
 514         response.set_rcode(dns.rcode.NXDOMAIN)
 515         response.question = []
 516
 517         for method in ("sendUDPQuery", "sendTCPQuery"):
 518             sender = getattr(self, method)
 519             (receivedQuery, receivedResponse) = sender(query, response)
 520             self.assertTrue(receivedQuery)
 521             receivedQuery.id = query.id
 522             self.assertEqual(query, receivedQuery)
 523             self.assertEqual(receivedResponse, response)
 524
 525 class TestAdvancedDropEmptyQueries(DNSDistTest):
 526
 527     _config_template = """
 528     setDropEmptyQueries(true)
 529     newServer{address="127.0.0.1:%s"}
 530     """
 531
 532     def testAdvancedDropEmptyQueries(self):
 533         """
 534         Advanced: Drop empty queries
 535         """
 536         name = 'drop-empty-queries.advanced.tests.powerdns.com.'
 537         query = dns.message.Message()
 538
 539         for method in ("sendUDPQuery", "sendTCPQuery"):
 540             sender = getattr(self, method)
 541             (_, receivedResponse) = sender(query, response=None, useQueue=False)
 542             self.assertEqual(receivedResponse, None)
 543
 544 class TestProtocols(DNSDistTest):
 545     _config_template = """
 546     function checkUDP(dq)
 547       if dq:getProtocol() ~= "Do53 UDP" then
 548         return DNSAction.Spoof, '1.2.3.4'
 549       end
 550       return DNSAction.None
 551     end
 552
 553     function checkTCP(dq)
 554       if dq:getProtocol() ~= "Do53 TCP" then
 555         return DNSAction.Spoof, '1.2.3.4'
 556       end
 557       return DNSAction.None
 558     end
 559
 560     addAction("udp.protocols.advanced.tests.powerdns.com.", LuaAction(checkUDP))
 561     addAction("tcp.protocols.advanced.tests.powerdns.com.", LuaAction(checkTCP))
 562     newServer{address="127.0.0.1:%s"}
 563     """
 564
 565     def testProtocolUDP(self):
 566         """
 567         Advanced: Test DNSQuestion.Protocol over UDP
 568         """
 569         name = 'udp.protocols.advanced.tests.powerdns.com.'
 570         query = dns.message.make_query(name, 'A', 'IN')
 571         response = dns.message.make_response(query)
 572
 573         (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
 574         receivedQuery.id = query.id
 575         self.assertEqual(receivedQuery, query)
 576         self.assertEqual(receivedResponse, response)
 577
 578     def testProtocolTCP(self):
 579         """
 580         Advanced: Test DNSQuestion.Protocol over TCP
 581         """
 582         name = 'tcp.protocols.advanced.tests.powerdns.com.'
 583         query = dns.message.make_query(name, 'A', 'IN')
 584         response = dns.message.make_response(query)
 585
 586         (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
 587         receivedQuery.id = query.id
 588         self.assertEqual(receivedQuery, query)
 589         self.assertEqual(receivedResponse, response)
 590
 591 class TestCustomMetrics(DNSDistTest):
 592     _config_template = """
 593     function custommetrics(dq)
 594       initialCounter = getMetric("my-custom-counter")
 595       initialGauge = getMetric("my-custom-counter")
 596       incMetric("my-custom-counter")
 597       setMetric("my-custom-gauge", initialGauge + 1.3)
 598       if getMetric("my-custom-counter") ~= (initialCounter + 1) or getMetric("my-custom-gauge") ~= (initialGauge + 1.3) then
 599         return DNSAction.Spoof, '1.2.3.5'
 600       end
 601       return DNSAction.Spoof, '4.3.2.1'
 602     end
 603
 604     function declareNewMetric(dq)
 605       if declareMetric("new-runtime-metric", "counter", "Metric declaration at runtime should fail") then
 606         return DNSAction.Spoof, '1.2.3.4'
 607       end
 608       return DNSAction.None
 609     end
 610
 611     declareMetric("my-custom-counter", "counter", "Number of tests run")
 612     declareMetric("my-custom-gauge", "gauge", "Temperature of the tests")
 613     addAction("declare.metric.advanced.tests.powerdns.com.", LuaAction(declareNewMetric))
 614     addAction("operations.metric.advanced.tests.powerdns.com.", LuaAction(custommetrics))
 615     newServer{address="127.0.0.1:%s"}
 616     """
 617
 618     def testDeclareAfterConfig(self):
 619         """
 620         Advanced: Test custom metric declaration after config done
 621         """
 622         name = 'declare.metric.advanced.tests.powerdns.com.'
 623         query = dns.message.make_query(name, 'A', 'IN')
 624         response = dns.message.make_response(query)
 625
 626         for method in ("sendUDPQuery", "sendTCPQuery"):
 627             sender = getattr(self, method)
 628             (receivedQuery, receivedResponse) = sender(query, response)
 629             receivedQuery.id = query.id
 630             self.assertEqual(receivedQuery, query)
 631             self.assertEqual(receivedResponse, response)
 632
 633     def testMetricOperations(self):
 634         """
 635         Advanced: Test basic operations on custom metrics
 636         """
 637         name = 'operations.metric.advanced.tests.powerdns.com.'
 638         query = dns.message.make_query(name, 'A', 'IN')
 639         # dnsdist set RA = RD for spoofed responses
 640         query.flags &= ~dns.flags.RD
 641         response = dns.message.make_response(query)
 642         rrset = dns.rrset.from_text(name,
 643                                     60,
 644                                     dns.rdataclass.IN,
 645                                     dns.rdatatype.A,
 646                                     '4.3.2.1')
 647         response.answer.append(rrset)
 648
 649         for method in ("sendUDPQuery", "sendTCPQuery"):
 650             sender = getattr(self, method)
 651             (_, receivedResponse) = sender(query, response=None, useQueue=False)
 652             self.assertEqual(receivedResponse, response)
 653
 654 class TestDNSQuestionTime(DNSDistTest):
 655     _config_template = """
 656     local queryTime = nil
 657
 658     function luaquery(dq)
 659       if queryTime then
 660         errlog('Error, the time variable is already set')
 661         return DNSAction.Drop
 662       end
 663       queryTime = dq:getQueryTime()
 664       local currentTime = getCurrentTime()
 665       if queryTime.tv_sec > currentTime.tv_sec then
 666         errlog('Error, query time is higher than current time')
 667         return DNSAction.Drop
 668       end
 669       if queryTime.tv_sec == currentTime.tv_sec and queryTime.tv_nsec > currentTime.tv_nsec then
 670         errlog('Error, query time NS is higher than current time')
 671         return DNSAction.Drop
 672       end
 673       return DNSAction.None
 674     end
 675
 676     function luaresponse(dr)
 677       if queryTime == nil then
 678         errlog('Error, the time variable is NOT set')
 679         return DNSAction.Drop
 680       end
 681       local currentTime = getCurrentTime()
 682       local queryTimeFromResponse = dr:getQueryTime()
 683       if queryTime.tv_sec ~= queryTimeFromResponse.tv_sec or queryTime.tv_nsec ~= queryTimeFromResponse.tv_nsec then
 684         errlog('Error, the query time in the response does NOT match the one from the query')
 685         return DNSAction.Drop
 686       end
 687       if queryTime.tv_sec > currentTime.tv_sec then
 688         errlog('Error, query time is higher than current time')
 689         return DNSAction.Drop
 690       end
 691       if queryTime.tv_sec == currentTime.tv_sec and queryTime.tv_nsec > currentTime.tv_nsec then
 692         errlog('Error, query time (NS) is higher than current time')
 693         return DNSAction.Drop
 694       end
 695
 696       queryTime = nil
 697       return DNSAction.None
 698     end
 699
 700     addAction(AllRule(), LuaAction(luaquery))
 701     addResponseAction(AllRule(), LuaResponseAction(luaresponse))
 702     newServer{address="127.0.0.1:%s"}
 703     """
 704
 705     def testQueryTime(self):
 706         """
 707         Advanced: Test query time
 708         """
 709         name = 'query.time.advanced.tests.powerdns.com.'
 710         query = dns.message.make_query(name, 'A', 'IN')
 711         response = dns.message.make_response(query)
 712         rrset = dns.rrset.from_text(name,
 713                                     60,
 714                                     dns.rdataclass.IN,
 715                                     dns.rdatatype.A,
 716                                     '4.3.2.1')
 717         response.answer.append(rrset)
 718
 719         for method in ("sendUDPQuery", "sendTCPQuery"):
 720             sender = getattr(self, method)
 721             (receivedQuery, receivedResponse) = sender(query, response)
 722             receivedQuery.id = query.id
 723             self.assertEqual(receivedQuery, query)
 724             self.assertEqual(receivedResponse, response)
 725
 726 class TestChangeName(DNSDistTest):
 727     _config_template = """
 728     local tagName = 'initial-name'
 729     function luaChangeNamequery(dq)
 730       dq:setTag(tagName, dq.qname:toString())
 731       if not dq:changeName(newDNSName('changeName.advanced.tests.dnsdist.org')) then
 732         errlog('Error rebasing the query')
 733         return DNSAction.Drop
 734       end
 735       return DNSAction.None
 736     end
 737
 738     function luaChangeNameresponse(dr)
 739       local initialName = dr:getTag(tagName)
 740       if not dr:changeName(newDNSName(initialName)) then
 741         errlog('Error rebasing the response')
 742         return DNSAction.Drop
 743       end
 744       return DNSAction.None
 745     end
 746
 747     addAction('changeName.advanced.tests.powerdns.com', LuaAction(luaChangeNamequery))
 748     addResponseAction('changeName.advanced.tests.dnsdist.org', LuaResponseAction(luaChangeNameresponse))
 749     newServer{address="127.0.0.1:%s"}
 750     """
 751
 752     def testChangeName(self):
 753         """
 754         Advanced: ChangeName the query name
 755         """
 756         name = 'changeName.advanced.tests.powerdns.com.'
 757         query = dns.message.make_query(name, 'A', 'IN')
 758
 759         changedName = 'changeName.advanced.tests.dnsdist.org.'
 760         changedQuery = dns.message.make_query(changedName, 'A', 'IN')
 761         changedQuery.id = query.id
 762
 763         response = dns.message.make_response(changedQuery)
 764         rrset = dns.rrset.from_text(changedName,
 765                                     60,
 766                                     dns.rdataclass.IN,
 767                                     dns.rdatatype.A,
 768                                     '4.3.2.1')
 769         response.answer.append(rrset)
 770         rrset = dns.rrset.from_text('sub.sub2.changeName.advanced.tests.dnsdist.org.',
 771                                     60,
 772                                     dns.rdataclass.IN,
 773                                     dns.rdatatype.TXT,
 774                                     'This text contains sub.sub2.changeName.advanced.tests.dnsdist.org.')
 775         response.additional.append(rrset)
 776
 777         expectedResponse = dns.message.make_response(query)
 778         rrset = dns.rrset.from_text(name,
 779                                     60,
 780                                     dns.rdataclass.IN,
 781                                     dns.rdatatype.A,
 782                                     '4.3.2.1')
 783         expectedResponse.answer.append(rrset)
 784         # we only rewrite records if the owner name matches the new target, nothing else
 785         rrset = dns.rrset.from_text('sub.sub2.changeName.advanced.tests.dnsdist.org.',
 786                                     60,
 787                                     dns.rdataclass.IN,
 788                                     dns.rdatatype.TXT,
 789                                     'This text contains sub.sub2.changeName.advanced.tests.dnsdist.org.')
 790         expectedResponse.additional.append(rrset)
 791
 792         for method in ("sendUDPQuery", "sendTCPQuery"):
 793             sender = getattr(self, method)
 794             (receivedQuery, receivedResponse) = sender(query, response)
 795             receivedQuery.id = query.id
 796             self.assertEqual(receivedQuery, changedQuery)
 797             self.assertEqual(receivedResponse, expectedResponse)
 798
 799 class TestFlagsOnTimeout(DNSDistTest):
 800
 801     _consoleKey = DNSDistTest.generateConsoleKey()
 802     _consoleKeyB64 = base64.b64encode(_consoleKey).decode('ascii')
 803     _config_params = ['_consoleKeyB64', '_consolePort', '_testServerPort']
 804     _config_template = """
 805     setKey("%s")
 806     controlSocket("127.0.0.1:%s")
 807     -- this server is not going to answer, resulting in a timeout
 808     newServer{address="192.0.2.1:%s"}:setUp()
 809     """
 810
 811     def testFlags(self):
 812         """
 813         Advanced: Test that we record the correct incoming flags on a timeout
 814         """
 815         name = 'timeout-flags.advanced.tests.powerdns.com.'
 816
 817         # first with RD=1
 818         query = dns.message.make_query(name, 'A', 'IN')
 819         query.id = 42
 820         query.flags |= dns.flags.RD
 821
 822         (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
 823         self.assertFalse(receivedResponse)
 824
 825         # then with RD=0
 826         query = dns.message.make_query(name, 'A', 'IN')
 827         query.id = 84
 828         query.flags &= ~dns.flags.RD
 829
 830         (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
 831         self.assertFalse(receivedResponse)
 832
 833         # make sure that the timeouts have been detected and recorded
 834         for _ in range(6):
 835             content = self.sendConsoleCommand("grepq('')")
 836             lines = content.splitlines()
 837             if len(lines) == 5:
 838                 break
 839             # and otherwise sleep for a short while
 840             time.sleep(1)
 841
 842         print(lines)
 843         self.assertEqual(len(lines), 5)
 844         # header line
 845         self.assertIn('TC RD AA', lines[0])
 846
 847         queries = {}
 848         timeouts = {}
 849
 850         for line in lines[1:]:
 851             self.assertIn('DoUDP', line)
 852             if 'T.O' in line:
 853                 queryID = int(line.split()[4])
 854                 timeouts[queryID] = line
 855             else:
 856                 queryID = int(line.split()[3])
 857                 queries[queryID] = line
 858             if queryID == 42:
 859                 self.assertIn('RD', line)
 860             else:
 861                 self.assertNotIn('RD', line)
 862
 863         self.assertEqual(len(timeouts), 2)
 864         self.assertEqual(len(queries), 2)