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 TestAdvancedAllowHeaderOnly(DNSDistTest):
 418
 419     _config_template = """
 420     newServer{address="127.0.0.1:%s"}
 421     setAllowEmptyResponse(true)
 422     """
 423
 424     def testHeaderOnlyRefused(self):
 425         """
 426         Advanced: Header-only refused response
 427         """
 428         name = 'header-only-refused-response.advanced.tests.powerdns.com.'
 429         query = dns.message.make_query(name, 'A', 'IN')
 430         response = dns.message.make_response(query)
 431         response.set_rcode(dns.rcode.REFUSED)
 432         response.question = []
 433
 434         for method in ("sendUDPQuery", "sendTCPQuery"):
 435             sender = getattr(self, method)
 436             (receivedQuery, receivedResponse) = sender(query, response)
 437             self.assertTrue(receivedQuery)
 438             receivedQuery.id = query.id
 439             self.assertEqual(query, receivedQuery)
 440             self.assertEqual(receivedResponse, response)
 441
 442     def testHeaderOnlyNoErrorResponse(self):
 443         """
 444         Advanced: Header-only NoError response should be allowed
 445         """
 446         name = 'header-only-noerror-response.advanced.tests.powerdns.com.'
 447         query = dns.message.make_query(name, 'A', 'IN')
 448         response = dns.message.make_response(query)
 449         response.question = []
 450
 451         for method in ("sendUDPQuery", "sendTCPQuery"):
 452             sender = getattr(self, method)
 453             (receivedQuery, receivedResponse) = sender(query, response)
 454             self.assertTrue(receivedQuery)
 455             receivedQuery.id = query.id
 456             self.assertEqual(query, receivedQuery)
 457             self.assertEqual(receivedResponse, response)
 458
 459     def testHeaderOnlyNXDResponse(self):
 460         """
 461         Advanced: Header-only NXD response should be allowed
 462         """
 463         name = 'header-only-nxd-response.advanced.tests.powerdns.com.'
 464         query = dns.message.make_query(name, 'A', 'IN')
 465         response = dns.message.make_response(query)
 466         response.set_rcode(dns.rcode.NXDOMAIN)
 467         response.question = []
 468
 469         for method in ("sendUDPQuery", "sendTCPQuery"):
 470             sender = getattr(self, method)
 471             (receivedQuery, receivedResponse) = sender(query, response)
 472             self.assertTrue(receivedQuery)
 473             receivedQuery.id = query.id
 474             self.assertEqual(query, receivedQuery)
 475             self.assertEqual(receivedResponse, response)
 476
 477 class TestAdvancedDropEmptyQueries(DNSDistTest):
 478
 479     _config_template = """
 480     setDropEmptyQueries(true)
 481     newServer{address="127.0.0.1:%s"}
 482     """
 483
 484     def testAdvancedDropEmptyQueries(self):
 485         """
 486         Advanced: Drop empty queries
 487         """
 488         name = 'drop-empty-queries.advanced.tests.powerdns.com.'
 489         query = dns.message.Message()
 490
 491         for method in ("sendUDPQuery", "sendTCPQuery"):
 492             sender = getattr(self, method)
 493             (_, receivedResponse) = sender(query, response=None, useQueue=False)
 494             self.assertEqual(receivedResponse, None)
 495
 496 class TestProtocols(DNSDistTest):
 497     _config_template = """
 498     function checkUDP(dq)
 499       if dq:getProtocol() ~= "Do53 UDP" then
 500         return DNSAction.Spoof, '1.2.3.4'
 501       end
 502       return DNSAction.None
 503     end
 504
 505     function checkTCP(dq)
 506       if dq:getProtocol() ~= "Do53 TCP" then
 507         return DNSAction.Spoof, '1.2.3.4'
 508       end
 509       return DNSAction.None
 510     end
 511
 512     addAction("udp.protocols.advanced.tests.powerdns.com.", LuaAction(checkUDP))
 513     addAction("tcp.protocols.advanced.tests.powerdns.com.", LuaAction(checkTCP))
 514     newServer{address="127.0.0.1:%s"}
 515     """
 516
 517     def testProtocolUDP(self):
 518         """
 519         Advanced: Test DNSQuestion.Protocol over UDP
 520         """
 521         name = 'udp.protocols.advanced.tests.powerdns.com.'
 522         query = dns.message.make_query(name, 'A', 'IN')
 523         response = dns.message.make_response(query)
 524
 525         (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
 526         receivedQuery.id = query.id
 527         self.assertEqual(receivedQuery, query)
 528         self.assertEqual(receivedResponse, response)
 529
 530     def testProtocolTCP(self):
 531         """
 532         Advanced: Test DNSQuestion.Protocol over TCP
 533         """
 534         name = 'tcp.protocols.advanced.tests.powerdns.com.'
 535         query = dns.message.make_query(name, 'A', 'IN')
 536         response = dns.message.make_response(query)
 537
 538         (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
 539         receivedQuery.id = query.id
 540         self.assertEqual(receivedQuery, query)
 541         self.assertEqual(receivedResponse, response)
 542
 543 class TestCustomMetrics(DNSDistTest):
 544     _config_template = """
 545     function custommetrics(dq)
 546       initialCounter = getMetric("my-custom-counter")
 547       initialGauge = getMetric("my-custom-counter")
 548       incMetric("my-custom-counter")
 549       setMetric("my-custom-gauge", initialGauge + 1.3)
 550       if getMetric("my-custom-counter") ~= (initialCounter + 1) or getMetric("my-custom-gauge") ~= (initialGauge + 1.3) then
 551         return DNSAction.Spoof, '1.2.3.5'
 552       end
 553       return DNSAction.Spoof, '4.3.2.1'
 554     end
 555
 556     function declareNewMetric(dq)
 557       if declareMetric("new-runtime-metric", "counter", "Metric declaration at runtime should fail") then
 558         return DNSAction.Spoof, '1.2.3.4'
 559       end
 560       return DNSAction.None
 561     end
 562
 563     declareMetric("my-custom-counter", "counter", "Number of tests run")
 564     declareMetric("my-custom-gauge", "gauge", "Temperature of the tests")
 565     addAction("declare.metric.advanced.tests.powerdns.com.", LuaAction(declareNewMetric))
 566     addAction("operations.metric.advanced.tests.powerdns.com.", LuaAction(custommetrics))
 567     newServer{address="127.0.0.1:%s"}
 568     """
 569
 570     def testDeclareAfterConfig(self):
 571         """
 572         Advanced: Test custom metric declaration after config done
 573         """
 574         name = 'declare.metric.advanced.tests.powerdns.com.'
 575         query = dns.message.make_query(name, 'A', 'IN')
 576         response = dns.message.make_response(query)
 577
 578         for method in ("sendUDPQuery", "sendTCPQuery"):
 579             sender = getattr(self, method)
 580             (receivedQuery, receivedResponse) = sender(query, response)
 581             receivedQuery.id = query.id
 582             self.assertEqual(receivedQuery, query)
 583             self.assertEqual(receivedResponse, response)
 584
 585     def testMetricOperations(self):
 586         """
 587         Advanced: Test basic operations on custom metrics
 588         """
 589         name = 'operations.metric.advanced.tests.powerdns.com.'
 590         query = dns.message.make_query(name, 'A', 'IN')
 591         # dnsdist set RA = RD for spoofed responses
 592         query.flags &= ~dns.flags.RD
 593         response = dns.message.make_response(query)
 594         rrset = dns.rrset.from_text(name,
 595                                     60,
 596                                     dns.rdataclass.IN,
 597                                     dns.rdatatype.A,
 598                                     '4.3.2.1')
 599         response.answer.append(rrset)
 600
 601         for method in ("sendUDPQuery", "sendTCPQuery"):
 602             sender = getattr(self, method)
 603             (_, receivedResponse) = sender(query, response=None, useQueue=False)
 604             self.assertEqual(receivedResponse, response)
 605
 606 class TestDNSQuestionTime(DNSDistTest):
 607     _config_template = """
 608     local queryTime = nil
 609
 610     function luaquery(dq)
 611       if queryTime then
 612         errlog('Error, the time variable is already set')
 613         return DNSAction.Drop
 614       end
 615       queryTime = dq:getQueryTime()
 616       local currentTime = getCurrentTime()
 617       if queryTime.tv_sec > currentTime.tv_sec then
 618         errlog('Error, query time is higher than current time')
 619         return DNSAction.Drop
 620       end
 621       if queryTime.tv_sec == currentTime.tv_sec and queryTime.tv_nsec > currentTime.tv_nsec then
 622         errlog('Error, query time NS is higher than current time')
 623         return DNSAction.Drop
 624       end
 625       return DNSAction.None
 626     end
 627
 628     function luaresponse(dr)
 629       if queryTime == nil then
 630         errlog('Error, the time variable is NOT set')
 631         return DNSAction.Drop
 632       end
 633       local currentTime = getCurrentTime()
 634       local queryTimeFromResponse = dr:getQueryTime()
 635       if queryTime.tv_sec ~= queryTimeFromResponse.tv_sec or queryTime.tv_nsec ~= queryTimeFromResponse.tv_nsec then
 636         errlog('Error, the query time in the response does NOT match the one from the query')
 637         return DNSAction.Drop
 638       end
 639       if queryTime.tv_sec > currentTime.tv_sec then
 640         errlog('Error, query time is higher than current time')
 641         return DNSAction.Drop
 642       end
 643       if queryTime.tv_sec == currentTime.tv_sec and queryTime.tv_nsec > currentTime.tv_nsec then
 644         errlog('Error, query time (NS) is higher than current time')
 645         return DNSAction.Drop
 646       end
 647
 648       queryTime = nil
 649       return DNSAction.None
 650     end
 651
 652     addAction(AllRule(), LuaAction(luaquery))
 653     addResponseAction(AllRule(), LuaResponseAction(luaresponse))
 654     newServer{address="127.0.0.1:%s"}
 655     """
 656
 657     def testQueryTime(self):
 658         """
 659         Advanced: Test query time
 660         """
 661         name = 'query.time.advanced.tests.powerdns.com.'
 662         query = dns.message.make_query(name, 'A', 'IN')
 663         response = dns.message.make_response(query)
 664         rrset = dns.rrset.from_text(name,
 665                                     60,
 666                                     dns.rdataclass.IN,
 667                                     dns.rdatatype.A,
 668                                     '4.3.2.1')
 669         response.answer.append(rrset)
 670
 671         for method in ("sendUDPQuery", "sendTCPQuery"):
 672             sender = getattr(self, method)
 673             (receivedQuery, receivedResponse) = sender(query, response)
 674             receivedQuery.id = query.id
 675             self.assertEqual(receivedQuery, query)
 676             self.assertEqual(receivedResponse, response)
 677
 678 class TestChangeName(DNSDistTest):
 679     _config_template = """
 680     local tagName = 'initial-name'
 681     function luaChangeNamequery(dq)
 682       dq:setTag(tagName, dq.qname:toString())
 683       if not dq:changeName(newDNSName('changeName.advanced.tests.dnsdist.org')) then
 684         errlog('Error rebasing the query')
 685         return DNSAction.Drop
 686       end
 687       return DNSAction.None
 688     end
 689
 690     function luaChangeNameresponse(dr)
 691       local initialName = dr:getTag(tagName)
 692       if not dr:changeName(newDNSName(initialName)) then
 693         errlog('Error rebasing the response')
 694         return DNSAction.Drop
 695       end
 696       return DNSAction.None
 697     end
 698
 699     addAction('changeName.advanced.tests.powerdns.com', LuaAction(luaChangeNamequery))
 700     addResponseAction('changeName.advanced.tests.dnsdist.org', LuaResponseAction(luaChangeNameresponse))
 701     newServer{address="127.0.0.1:%s"}
 702     """
 703
 704     def testChangeName(self):
 705         """
 706         Advanced: ChangeName the query name
 707         """
 708         name = 'changeName.advanced.tests.powerdns.com.'
 709         query = dns.message.make_query(name, 'A', 'IN')
 710
 711         changedName = 'changeName.advanced.tests.dnsdist.org.'
 712         changedQuery = dns.message.make_query(changedName, 'A', 'IN')
 713         changedQuery.id = query.id
 714
 715         response = dns.message.make_response(changedQuery)
 716         rrset = dns.rrset.from_text(changedName,
 717                                     60,
 718                                     dns.rdataclass.IN,
 719                                     dns.rdatatype.A,
 720                                     '4.3.2.1')
 721         response.answer.append(rrset)
 722         rrset = dns.rrset.from_text('sub.sub2.changeName.advanced.tests.dnsdist.org.',
 723                                     60,
 724                                     dns.rdataclass.IN,
 725                                     dns.rdatatype.TXT,
 726                                     'This text contains sub.sub2.changeName.advanced.tests.dnsdist.org.')
 727         response.additional.append(rrset)
 728
 729         expectedResponse = dns.message.make_response(query)
 730         rrset = dns.rrset.from_text(name,
 731                                     60,
 732                                     dns.rdataclass.IN,
 733                                     dns.rdatatype.A,
 734                                     '4.3.2.1')
 735         expectedResponse.answer.append(rrset)
 736         # we only rewrite records if the owner name matches the new target, nothing else
 737         rrset = dns.rrset.from_text('sub.sub2.changeName.advanced.tests.dnsdist.org.',
 738                                     60,
 739                                     dns.rdataclass.IN,
 740                                     dns.rdatatype.TXT,
 741                                     'This text contains sub.sub2.changeName.advanced.tests.dnsdist.org.')
 742         expectedResponse.additional.append(rrset)
 743
 744         for method in ("sendUDPQuery", "sendTCPQuery"):
 745             sender = getattr(self, method)
 746             (receivedQuery, receivedResponse) = sender(query, response)
 747             receivedQuery.id = query.id
 748             self.assertEqual(receivedQuery, changedQuery)
 749             self.assertEqual(receivedResponse, expectedResponse)
 750
 751 class TestFlagsOnTimeout(DNSDistTest):
 752
 753     _consoleKey = DNSDistTest.generateConsoleKey()
 754     _consoleKeyB64 = base64.b64encode(_consoleKey).decode('ascii')
 755     _config_params = ['_consoleKeyB64', '_consolePort', '_testServerPort']
 756     _config_template = """
 757     setKey("%s")
 758     controlSocket("127.0.0.1:%s")
 759     -- this server is not going to answer, resulting in a timeout
 760     newServer{address="192.0.2.1:%s"}:setUp()
 761     """
 762
 763     def testFlags(self):
 764         """
 765         Advanced: Test that we record the correct incoming flags on a timeout
 766         """
 767         name = 'timeout-flags.advanced.tests.powerdns.com.'
 768
 769         # first with RD=1
 770         query = dns.message.make_query(name, 'A', 'IN')
 771         query.id = 42
 772         query.flags |= dns.flags.RD
 773
 774         (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
 775         self.assertFalse(receivedResponse)
 776
 777         # then with RD=0
 778         query = dns.message.make_query(name, 'A', 'IN')
 779         query.id = 84
 780         query.flags &= ~dns.flags.RD
 781
 782         (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
 783         self.assertFalse(receivedResponse)
 784
 785         # make sure that the timeouts have been detected and recorded
 786         for _ in range(6):
 787             content = self.sendConsoleCommand("grepq('')")
 788             lines = content.splitlines()
 789             if len(lines) == 5:
 790                 break
 791             # and otherwise sleep for a short while
 792             time.sleep(1)
 793
 794         print(lines)
 795         self.assertEqual(len(lines), 5)
 796         # header line
 797         self.assertIn('TC RD AA', lines[0])
 798
 799         queries = {}
 800         timeouts = {}
 801
 802         for line in lines[1:]:
 803             self.assertIn('DoUDP', line)
 804             if 'T.O' in line:
 805                 queryID = int(line.split()[4])
 806                 timeouts[queryID] = line
 807             else:
 808                 queryID = int(line.split()[3])
 809                 queries[queryID] = line
 810             if queryID == 42:
 811                 self.assertIn('RD', line)
 812             else:
 813                 self.assertNotIn('RD', line)
 814
 815         self.assertEqual(len(timeouts), 2)
 816         self.assertEqual(len(queries), 2)