projects / thirdparty / pdns.git / blame
| Commit | Line | Data |
|---|---|---|
| ec5f5c6b | 1 | #!/usr/bin/env python |
| 26b86deb | 2 | import base64 |
| ec5f5c6b | 3 | from datetime import datetime, timedelta |
| ec5f5c6b | 4 | import os |
| 26b86deb | 5 | import string |
| 856c35e3 | 6 | import time |
| b1bec9f0 | 7 | import dns |
| ec5f5c6b RG |
8 | from dnsdisttests import DNSDistTest |
| 9 | ||
| b1bec9f0 RG |
10 | class TestAdvancedAllow(DNSDistTest): |
| 11 | ||
| 12 | _config_template = """ | |
| 13 | addAction(makeRule("allowed.advanced.tests.powerdns.com."), AllowAction()) | |
| 14 | addAction(AllRule(), DropAction()) | |
| 15 | newServer{address="127.0.0.1:%s"} | |
| 16 | """ | |
| 17 | ||
| 18 | def testAdvancedAllow(self): | |
| 19 | """ | |
| 20 | Advanced: Allowed qname is not dropped | |
| 21 | ||
| 22 | A query for allowed.advanced.tests.powerdns.com. should be allowed | |
| 23 | while others should be dropped. | |
| 24 | """ | |
| 25 | name = 'allowed.advanced.tests.powerdns.com.' | |
| 26 | query = dns.message.make_query(name, 'A', 'IN') | |
| 27 | response = dns.message.make_response(query) | |
| 28 | rrset = dns.rrset.from_text(name, | |
| 29 | 3600, | |
| 30 | dns.rdataclass.IN, | |
| 31 | dns.rdatatype.A, | |
| 32 | '127.0.0.1') | |
| 33 | response.answer.append(rrset) | |
| 34 | ||
| 35 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 36 | self.assertTrue(receivedQuery) | |
| 37 | self.assertTrue(receivedResponse) | |
| 38 | receivedQuery.id = query.id | |
| 39 | self.assertEquals(query, receivedQuery) | |
| 40 | self.assertEquals(response, receivedResponse) | |
| 41 | ||
| 42 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 43 | self.assertTrue(receivedQuery) | |
| 44 | self.assertTrue(receivedResponse) | |
| 45 | receivedQuery.id = query.id | |
| 46 | self.assertEquals(query, receivedQuery) | |
| 47 | self.assertEquals(response, receivedResponse) | |
| 48 | ||
| 49 | def testAdvancedAllowDropped(self): | |
| 50 | """ | |
| 51 | Advanced: Not allowed qname is dropped | |
| 52 | ||
| 53 | A query for notallowed.advanced.tests.powerdns.com. should be dropped. | |
| 54 | """ | |
| 55 | name = 'notallowed.advanced.tests.powerdns.com.' | |
| 56 | query = dns.message.make_query(name, 'A', 'IN') | |
| 57 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 58 | self.assertEquals(receivedResponse, None) | |
| 59 | ||
| 60 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 61 | self.assertEquals(receivedResponse, None) | |
| 62 | ||
| ec5f5c6b RG |
63 | class TestAdvancedFixupCase(DNSDistTest): |
| 64 | ||
| ec5f5c6b RG |
65 | _config_template = """ |
| 66 | truncateTC(true) | |
| 67 | fixupCase(true) | |
| 68 | newServer{address="127.0.0.1:%s"} | |
| 69 | """ | |
| 70 | ||
| ec5f5c6b RG |
71 | def testAdvancedFixupCase(self): |
| 72 | """ | |
| 617dfe22 RG |
73 | Advanced: Fixup Case |
| 74 | ||
| ec5f5c6b RG |
75 | Send a query with lower and upper chars, |
| 76 | make the backend return a lowercase version, | |
| 77 | check that dnsdist fixes the response. | |
| 78 | """ | |
| 79 | name = 'fiXuPCasE.advanced.tests.powerdns.com.' | |
| 80 | query = dns.message.make_query(name, 'A', 'IN') | |
| 81 | lowercasequery = dns.message.make_query(name.lower(), 'A', 'IN') | |
| 82 | response = dns.message.make_response(lowercasequery) | |
| 83 | expectedResponse = dns.message.make_response(query) | |
| 84 | rrset = dns.rrset.from_text(name, | |
| 85 | 3600, | |
| 86 | dns.rdataclass.IN, | |
| 87 | dns.rdatatype.A, | |
| 88 | '127.0.0.1') | |
| 89 | response.answer.append(rrset) | |
| 90 | expectedResponse.answer.append(rrset) | |
| 91 | ||
| 92 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 93 | self.assertTrue(receivedQuery) | |
| 94 | self.assertTrue(receivedResponse) | |
| 95 | receivedQuery.id = query.id | |
| ec5f5c6b RG |
96 | self.assertEquals(query, receivedQuery) |
| 97 | self.assertEquals(expectedResponse, receivedResponse) | |
| 98 | ||
| 99 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 100 | self.assertTrue(receivedQuery) | |
| 101 | self.assertTrue(receivedResponse) | |
| 102 | receivedQuery.id = query.id | |
| ec5f5c6b RG |
103 | self.assertEquals(query, receivedQuery) |
| 104 | self.assertEquals(expectedResponse, receivedResponse) | |
| 105 | ||
| 106 | ||
| 107 | class TestAdvancedRemoveRD(DNSDistTest): | |
| 108 | ||
| ec5f5c6b RG |
109 | _config_template = """ |
| 110 | addNoRecurseRule("norecurse.advanced.tests.powerdns.com.") | |
| 111 | newServer{address="127.0.0.1:%s"} | |
| 112 | """ | |
| 113 | ||
| ec5f5c6b RG |
114 | def testAdvancedNoRD(self): |
| 115 | """ | |
| 617dfe22 RG |
116 | Advanced: No RD |
| 117 | ||
| ec5f5c6b RG |
118 | Send a query with RD, |
| 119 | check that dnsdist clears the RD flag. | |
| 120 | """ | |
| 121 | name = 'norecurse.advanced.tests.powerdns.com.' | |
| 122 | query = dns.message.make_query(name, 'A', 'IN') | |
| 123 | expectedQuery = dns.message.make_query(name, 'A', 'IN') | |
| 124 | expectedQuery.flags &= ~dns.flags.RD | |
| 125 | ||
| 126 | response = dns.message.make_response(query) | |
| 127 | rrset = dns.rrset.from_text(name, | |
| 128 | 3600, | |
| 129 | dns.rdataclass.IN, | |
| 130 | dns.rdatatype.A, | |
| 131 | '127.0.0.1') | |
| 132 | response.answer.append(rrset) | |
| 133 | ||
| 134 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 135 | self.assertTrue(receivedQuery) | |
| 136 | self.assertTrue(receivedResponse) | |
| 137 | receivedQuery.id = expectedQuery.id | |
| ec5f5c6b RG |
138 | self.assertEquals(expectedQuery, receivedQuery) |
| 139 | self.assertEquals(response, receivedResponse) | |
| 140 | ||
| 141 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 142 | self.assertTrue(receivedQuery) | |
| 143 | self.assertTrue(receivedResponse) | |
| 144 | receivedQuery.id = expectedQuery.id | |
| ec5f5c6b RG |
145 | self.assertEquals(expectedQuery, receivedQuery) |
| 146 | self.assertEquals(response, receivedResponse) | |
| 147 | ||
| 148 | def testAdvancedKeepRD(self): | |
| 149 | """ | |
| 617dfe22 RG |
150 | Advanced: No RD canary |
| 151 | ||
| ec5f5c6b RG |
152 | Send a query with RD for a canary domain, |
| 153 | check that dnsdist does not clear the RD flag. | |
| 154 | """ | |
| 155 | name = 'keeprecurse.advanced.tests.powerdns.com.' | |
| 156 | query = dns.message.make_query(name, 'A', 'IN') | |
| 157 | ||
| 158 | response = dns.message.make_response(query) | |
| 159 | rrset = dns.rrset.from_text(name, | |
| 160 | 3600, | |
| 161 | dns.rdataclass.IN, | |
| 162 | dns.rdatatype.A, | |
| 163 | '127.0.0.1') | |
| 164 | response.answer.append(rrset) | |
| 165 | ||
| 166 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 167 | self.assertTrue(receivedQuery) | |
| 168 | self.assertTrue(receivedResponse) | |
| 169 | receivedQuery.id = query.id | |
| ec5f5c6b RG |
170 | self.assertEquals(query, receivedQuery) |
| 171 | self.assertEquals(response, receivedResponse) | |
| 172 | ||
| 173 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 174 | self.assertTrue(receivedQuery) | |
| 175 | self.assertTrue(receivedResponse) | |
| 176 | receivedQuery.id = query.id | |
| ec5f5c6b RG |
177 | self.assertEquals(query, receivedQuery) |
| 178 | self.assertEquals(response, receivedResponse) | |
| 179 | ||
| 180 | ||
| 181 | class TestAdvancedAddCD(DNSDistTest): | |
| 182 | ||
| ec5f5c6b RG |
183 | _config_template = """ |
| 184 | addDisableValidationRule("setcd.advanced.tests.powerdns.com.") | |
| b1bec9f0 | 185 | addAction(makeRule("setcdviaaction.advanced.tests.powerdns.com."), DisableValidationAction()) |
| ec5f5c6b RG |
186 | newServer{address="127.0.0.1:%s"} |
| 187 | """ | |
| 188 | ||
| ec5f5c6b RG |
189 | def testAdvancedSetCD(self): |
| 190 | """ | |
| 617dfe22 RG |
191 | Advanced: Set CD |
| 192 | ||
| ec5f5c6b RG |
193 | Send a query with CD cleared, |
| 194 | check that dnsdist set the CD flag. | |
| 195 | """ | |
| 196 | name = 'setcd.advanced.tests.powerdns.com.' | |
| 197 | query = dns.message.make_query(name, 'A', 'IN') | |
| b1bec9f0 RG |
198 | expectedQuery = dns.message.make_query(name, 'A', 'IN') |
| 199 | expectedQuery.flags |= dns.flags.CD | |
| 200 | ||
| 201 | response = dns.message.make_response(query) | |
| 202 | rrset = dns.rrset.from_text(name, | |
| 203 | 3600, | |
| 204 | dns.rdataclass.IN, | |
| 205 | dns.rdatatype.A, | |
| 206 | '127.0.0.1') | |
| 207 | response.answer.append(rrset) | |
| 208 | ||
| 209 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 210 | self.assertTrue(receivedQuery) | |
| 211 | self.assertTrue(receivedResponse) | |
| 212 | receivedQuery.id = expectedQuery.id | |
| 213 | self.assertEquals(expectedQuery, receivedQuery) | |
| 214 | self.assertEquals(response, receivedResponse) | |
| 215 | ||
| 216 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 217 | self.assertTrue(receivedQuery) | |
| 218 | self.assertTrue(receivedResponse) | |
| 219 | receivedQuery.id = expectedQuery.id | |
| 220 | self.assertEquals(expectedQuery, receivedQuery) | |
| 221 | self.assertEquals(response, receivedResponse) | |
| 222 | ||
| 223 | def testAdvancedSetCDViaAction(self): | |
| 224 | """ | |
| 225 | Advanced: Set CD via Action | |
| 226 | ||
| 227 | Send a query with CD cleared, | |
| 228 | check that dnsdist set the CD flag. | |
| 229 | """ | |
| 230 | name = 'setcdviaaction.advanced.tests.powerdns.com.' | |
| 231 | query = dns.message.make_query(name, 'A', 'IN') | |
| 232 | expectedQuery = dns.message.make_query(name, 'A', 'IN') | |
| ec5f5c6b RG |
233 | expectedQuery.flags |= dns.flags.CD |
| 234 | ||
| 235 | response = dns.message.make_response(query) | |
| 236 | rrset = dns.rrset.from_text(name, | |
| 237 | 3600, | |
| 238 | dns.rdataclass.IN, | |
| 239 | dns.rdatatype.A, | |
| 240 | '127.0.0.1') | |
| 241 | response.answer.append(rrset) | |
| 242 | ||
| 243 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 244 | self.assertTrue(receivedQuery) | |
| 245 | self.assertTrue(receivedResponse) | |
| 246 | receivedQuery.id = expectedQuery.id | |
| ec5f5c6b RG |
247 | self.assertEquals(expectedQuery, receivedQuery) |
| 248 | self.assertEquals(response, receivedResponse) | |
| 249 | ||
| 250 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 251 | self.assertTrue(receivedQuery) | |
| 252 | self.assertTrue(receivedResponse) | |
| 253 | receivedQuery.id = expectedQuery.id | |
| ec5f5c6b RG |
254 | self.assertEquals(expectedQuery, receivedQuery) |
| 255 | self.assertEquals(response, receivedResponse) | |
| 256 | ||
| 257 | def testAdvancedKeepNoCD(self): | |
| 258 | """ | |
| 617dfe22 RG |
259 | Advanced: Preserve CD canary |
| 260 | ||
| ec5f5c6b RG |
261 | Send a query without CD for a canary domain, |
| 262 | check that dnsdist does not set the CD flag. | |
| 263 | """ | |
| 264 | name = 'keepnocd.advanced.tests.powerdns.com.' | |
| 265 | query = dns.message.make_query(name, 'A', 'IN') | |
| 266 | ||
| 267 | response = dns.message.make_response(query) | |
| 268 | rrset = dns.rrset.from_text(name, | |
| 269 | 3600, | |
| 270 | dns.rdataclass.IN, | |
| 271 | dns.rdatatype.A, | |
| 272 | '127.0.0.1') | |
| 273 | response.answer.append(rrset) | |
| 274 | ||
| 275 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 276 | self.assertTrue(receivedQuery) | |
| 277 | self.assertTrue(receivedResponse) | |
| 278 | receivedQuery.id = query.id | |
| ec5f5c6b RG |
279 | self.assertEquals(query, receivedQuery) |
| 280 | self.assertEquals(response, receivedResponse) | |
| 281 | ||
| 282 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 283 | self.assertTrue(receivedQuery) | |
| 284 | self.assertTrue(receivedResponse) | |
| 285 | receivedQuery.id = query.id | |
| ec5f5c6b RG |
286 | self.assertEquals(query, receivedQuery) |
| 287 | self.assertEquals(response, receivedResponse) | |
| 288 | ||
| b1bec9f0 RG |
289 | class TestAdvancedClearRD(DNSDistTest): |
| 290 | ||
| 291 | _config_template = """ | |
| 292 | addNoRecurseRule("clearrd.advanced.tests.powerdns.com.") | |
| 293 | addAction(makeRule("clearrdviaaction.advanced.tests.powerdns.com."), NoRecurseAction()) | |
| 294 | newServer{address="127.0.0.1:%s"} | |
| 295 | """ | |
| 296 | ||
| 297 | def testAdvancedClearRD(self): | |
| 298 | """ | |
| 299 | Advanced: Clear RD | |
| 300 | ||
| 301 | Send a query with RD set, | |
| 302 | check that dnsdist clears the RD flag. | |
| 303 | """ | |
| 304 | name = 'clearrd.advanced.tests.powerdns.com.' | |
| 305 | query = dns.message.make_query(name, 'A', 'IN') | |
| 306 | expectedQuery = dns.message.make_query(name, 'A', 'IN') | |
| 307 | expectedQuery.flags &= ~dns.flags.RD | |
| 308 | ||
| 309 | response = dns.message.make_response(query) | |
| 310 | rrset = dns.rrset.from_text(name, | |
| 311 | 3600, | |
| 312 | dns.rdataclass.IN, | |
| 313 | dns.rdatatype.A, | |
| 314 | '127.0.0.1') | |
| 315 | response.answer.append(rrset) | |
| 316 | ||
| 317 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 318 | self.assertTrue(receivedQuery) | |
| 319 | self.assertTrue(receivedResponse) | |
| 320 | receivedQuery.id = expectedQuery.id | |
| 321 | self.assertEquals(expectedQuery, receivedQuery) | |
| 322 | self.assertEquals(response, receivedResponse) | |
| 323 | ||
| 324 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 325 | self.assertTrue(receivedQuery) | |
| 326 | self.assertTrue(receivedResponse) | |
| 327 | receivedQuery.id = expectedQuery.id | |
| 328 | self.assertEquals(expectedQuery, receivedQuery) | |
| 329 | self.assertEquals(response, receivedResponse) | |
| 330 | ||
| 331 | def testAdvancedClearRDViaAction(self): | |
| 332 | """ | |
| 333 | Advanced: Clear RD via Action | |
| 334 | ||
| 335 | Send a query with RD set, | |
| 336 | check that dnsdist clears the RD flag. | |
| 337 | """ | |
| 338 | name = 'clearrdviaaction.advanced.tests.powerdns.com.' | |
| 339 | query = dns.message.make_query(name, 'A', 'IN') | |
| 340 | expectedQuery = dns.message.make_query(name, 'A', 'IN') | |
| 341 | expectedQuery.flags &= ~dns.flags.RD | |
| 342 | ||
| 343 | response = dns.message.make_response(query) | |
| 344 | rrset = dns.rrset.from_text(name, | |
| 345 | 3600, | |
| 346 | dns.rdataclass.IN, | |
| 347 | dns.rdatatype.A, | |
| 348 | '127.0.0.1') | |
| 349 | response.answer.append(rrset) | |
| 350 | ||
| 351 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 352 | self.assertTrue(receivedQuery) | |
| 353 | self.assertTrue(receivedResponse) | |
| 354 | receivedQuery.id = expectedQuery.id | |
| 355 | self.assertEquals(expectedQuery, receivedQuery) | |
| 356 | self.assertEquals(response, receivedResponse) | |
| 357 | ||
| 358 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 359 | self.assertTrue(receivedQuery) | |
| 360 | self.assertTrue(receivedResponse) | |
| 361 | receivedQuery.id = expectedQuery.id | |
| 362 | self.assertEquals(expectedQuery, receivedQuery) | |
| 363 | self.assertEquals(response, receivedResponse) | |
| 364 | ||
| 365 | def testAdvancedKeepRD(self): | |
| 366 | """ | |
| 367 | Advanced: Preserve RD canary | |
| 368 | ||
| 369 | Send a query with RD for a canary domain, | |
| 370 | check that dnsdist does not clear the RD flag. | |
| 371 | """ | |
| 372 | name = 'keeprd.advanced.tests.powerdns.com.' | |
| 373 | query = dns.message.make_query(name, 'A', 'IN') | |
| 374 | ||
| 375 | response = dns.message.make_response(query) | |
| 376 | rrset = dns.rrset.from_text(name, | |
| 377 | 3600, | |
| 378 | dns.rdataclass.IN, | |
| 379 | dns.rdatatype.A, | |
| 380 | '127.0.0.1') | |
| 381 | response.answer.append(rrset) | |
| 382 | ||
| 383 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 384 | self.assertTrue(receivedQuery) | |
| 385 | self.assertTrue(receivedResponse) | |
| 386 | receivedQuery.id = query.id | |
| 387 | self.assertEquals(query, receivedQuery) | |
| 388 | self.assertEquals(response, receivedResponse) | |
| 389 | ||
| 390 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 391 | self.assertTrue(receivedQuery) | |
| 392 | self.assertTrue(receivedResponse) | |
| 393 | receivedQuery.id = query.id | |
| 394 | self.assertEquals(query, receivedQuery) | |
| 395 | self.assertEquals(response, receivedResponse) | |
| 396 | ||
| ec5f5c6b RG |
397 | |
| 398 | class TestAdvancedACL(DNSDistTest): | |
| 399 | ||
| ec5f5c6b RG |
400 | _config_template = """ |
| 401 | newServer{address="127.0.0.1:%s"} | |
| 402 | """ | |
| 18a0e7c6 | 403 | _acl = ['192.0.2.1/32'] |
| ec5f5c6b RG |
404 | |
| 405 | def testACLBlocked(self): | |
| 406 | """ | |
| 617dfe22 RG |
407 | Advanced: ACL blocked |
| 408 | ||
| ec5f5c6b RG |
409 | Send an A query to "tests.powerdns.com.", |
| 410 | we expect no response since 127.0.0.1 is not on the | |
| 411 | ACL. | |
| 412 | """ | |
| 903853f4 | 413 | name = 'tests.powerdns.com.' |
| 7791f83a | 414 | query = dns.message.make_query(name, 'A', 'IN') |
| 7791f83a RG |
415 | |
| 416 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 903853f4 | 417 | self.assertEquals(receivedResponse, None) |
| 7791f83a RG |
418 | |
| 419 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 903853f4 RG |
420 | self.assertEquals(receivedResponse, None) |
| 421 | ||
| 422 | class TestAdvancedDelay(DNSDistTest): | |
| 423 | ||
| 424 | _config_template = """ | |
| 425 | addAction(AllRule(), DelayAction(1000)) | |
| 426 | newServer{address="127.0.0.1:%s"} | |
| 427 | """ | |
| 7791f83a | 428 | |
| 903853f4 | 429 | def testDelayed(self): |
| 7791f83a | 430 | """ |
| 903853f4 | 431 | Advanced: Delayed |
| 7791f83a | 432 | |
| 903853f4 RG |
433 | Send an A query to "tests.powerdns.com.", |
| 434 | check that the response delay is longer than 1000 ms | |
| 435 | over UDP, less than that over TCP. | |
| 7791f83a | 436 | """ |
| 903853f4 RG |
437 | name = 'tests.powerdns.com.' |
| 438 | query = dns.message.make_query(name, 'A', 'IN') | |
| 439 | response = dns.message.make_response(query) | |
| 7791f83a RG |
440 | rrset = dns.rrset.from_text(name, |
| 441 | 60, | |
| 442 | dns.rdataclass.IN, | |
| 903853f4 RG |
443 | dns.rdatatype.A, |
| 444 | '192.0.2.1') | |
| 445 | response.answer.append(rrset) | |
| 7791f83a | 446 | |
| 903853f4 RG |
447 | begin = datetime.now() |
| 448 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 449 | end = datetime.now() | |
| 450 | receivedQuery.id = query.id | |
| 451 | self.assertEquals(query, receivedQuery) | |
| 452 | self.assertEquals(response, receivedResponse) | |
| 453 | self.assertTrue((end - begin) > timedelta(0, 1)) | |
| 454 | ||
| 455 | begin = datetime.now() | |
| 456 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 457 | end = datetime.now() | |
| 458 | receivedQuery.id = query.id | |
| 459 | self.assertEquals(query, receivedQuery) | |
| 460 | self.assertEquals(response, receivedResponse) | |
| 461 | self.assertTrue((end - begin) < timedelta(0, 1)) | |
| 7791f83a | 462 | |
| e7a1029c RG |
463 | |
| 464 | class TestAdvancedTruncateAnyAndTCP(DNSDistTest): | |
| 465 | ||
| 466 | _config_template = """ | |
| 467 | truncateTC(false) | |
| 468 | addAction(AndRule({QTypeRule("ANY"), TCPRule(true)}), TCAction()) | |
| 469 | newServer{address="127.0.0.1:%s"} | |
| 470 | """ | |
| 471 | def testTruncateAnyOverTCP(self): | |
| 472 | """ | |
| 473 | Advanced: Truncate ANY over TCP | |
| 474 | ||
| b1bec9f0 | 475 | Send an ANY query to "anytruncatetcp.advanced.tests.powerdns.com.", |
| e7a1029c RG |
476 | should be truncated over TCP, not over UDP (yes, it makes no sense, |
| 477 | deal with it). | |
| 478 | """ | |
| b1bec9f0 | 479 | name = 'anytruncatetcp.advanced.tests.powerdns.com.' |
| e7a1029c RG |
480 | query = dns.message.make_query(name, 'ANY', 'IN') |
| 481 | ||
| 482 | response = dns.message.make_response(query) | |
| 483 | rrset = dns.rrset.from_text(name, | |
| 484 | 3600, | |
| 485 | dns.rdataclass.IN, | |
| 486 | dns.rdatatype.A, | |
| 487 | '127.0.0.1') | |
| 488 | ||
| 489 | response.answer.append(rrset) | |
| 490 | ||
| 491 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 492 | self.assertTrue(receivedQuery) | |
| 493 | self.assertTrue(receivedResponse) | |
| 494 | receivedQuery.id = query.id | |
| e7a1029c RG |
495 | self.assertEquals(query, receivedQuery) |
| 496 | self.assertEquals(receivedResponse, response) | |
| 497 | ||
| 498 | expectedResponse = dns.message.make_response(query) | |
| 499 | expectedResponse.flags |= dns.flags.TC | |
| 500 | ||
| 501 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| e7a1029c RG |
502 | self.assertEquals(receivedResponse, expectedResponse) |
| 503 | ||
| 504 | class TestAdvancedAndNot(DNSDistTest): | |
| 505 | ||
| 506 | _config_template = """ | |
| 55baa1f2 | 507 | addAction(AndRule({NotRule(QTypeRule("A")), TCPRule(false)}), RCodeAction(dnsdist.NOTIMP)) |
| e7a1029c RG |
508 | newServer{address="127.0.0.1:%s"} |
| 509 | """ | |
| 510 | def testAOverUDPReturnsNotImplementedCanary(self): | |
| 511 | """ | |
| 512 | Advanced: !A && UDP canary | |
| 513 | ||
| 514 | dnsdist is configured to reply 'not implemented' for query | |
| 515 | over UDP AND !qtype A. | |
| 516 | We send an A query over UDP and TCP, and check that the | |
| 517 | response is OK. | |
| 518 | """ | |
| b1bec9f0 | 519 | name = 'andnot.advanced.tests.powerdns.com.' |
| e7a1029c RG |
520 | query = dns.message.make_query(name, 'A', 'IN') |
| 521 | response = dns.message.make_response(query) | |
| 522 | rrset = dns.rrset.from_text(name, | |
| 523 | 3600, | |
| 524 | dns.rdataclass.IN, | |
| 525 | dns.rdatatype.A, | |
| 526 | '127.0.0.1') | |
| 527 | response.answer.append(rrset) | |
| 528 | ||
| 529 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 530 | self.assertTrue(receivedQuery) | |
| 531 | self.assertTrue(receivedResponse) | |
| 532 | receivedQuery.id = query.id | |
| e7a1029c RG |
533 | self.assertEquals(query, receivedQuery) |
| 534 | self.assertEquals(receivedResponse, response) | |
| 535 | ||
| 536 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 537 | self.assertTrue(receivedQuery) | |
| 538 | self.assertTrue(receivedResponse) | |
| 539 | receivedQuery.id = query.id | |
| e7a1029c RG |
540 | self.assertEquals(query, receivedQuery) |
| 541 | self.assertEquals(receivedResponse, response) | |
| 542 | ||
| 543 | def testAOverUDPReturnsNotImplemented(self): | |
| 544 | """ | |
| 545 | Advanced: !A && UDP | |
| 546 | ||
| 547 | dnsdist is configured to reply 'not implemented' for query | |
| 548 | over UDP AND !qtype A. | |
| 549 | We send a TXT query over UDP and TCP, and check that the | |
| 550 | response is OK for TCP and 'not implemented' for UDP. | |
| 551 | """ | |
| b1bec9f0 | 552 | name = 'andnot.advanced.tests.powerdns.com.' |
| e7a1029c RG |
553 | query = dns.message.make_query(name, 'TXT', 'IN') |
| 554 | ||
| 555 | expectedResponse = dns.message.make_response(query) | |
| 556 | expectedResponse.set_rcode(dns.rcode.NOTIMP) | |
| 557 | ||
| 558 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| e7a1029c RG |
559 | self.assertEquals(receivedResponse, expectedResponse) |
| 560 | ||
| 561 | response = dns.message.make_response(query) | |
| 562 | rrset = dns.rrset.from_text(name, | |
| 563 | 3600, | |
| 564 | dns.rdataclass.IN, | |
| 565 | dns.rdatatype.TXT, | |
| 566 | 'nothing to see here') | |
| 567 | response.answer.append(rrset) | |
| 568 | ||
| 569 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 570 | self.assertTrue(receivedQuery) | |
| 571 | self.assertTrue(receivedResponse) | |
| 572 | receivedQuery.id = query.id | |
| e7a1029c RG |
573 | self.assertEquals(query, receivedQuery) |
| 574 | self.assertEquals(receivedResponse, response) | |
| 575 | ||
| 576 | class TestAdvancedOr(DNSDistTest): | |
| 577 | ||
| 578 | _config_template = """ | |
| 55baa1f2 | 579 | addAction(OrRule({QTypeRule("A"), TCPRule(false)}), RCodeAction(dnsdist.NOTIMP)) |
| e7a1029c RG |
580 | newServer{address="127.0.0.1:%s"} |
| 581 | """ | |
| 582 | def testAAAAOverUDPReturnsNotImplemented(self): | |
| 583 | """ | |
| 584 | Advanced: A || UDP: AAAA | |
| 585 | ||
| 586 | dnsdist is configured to reply 'not implemented' for query | |
| 587 | over UDP OR qtype A. | |
| 588 | We send an AAAA query over UDP and TCP, and check that the | |
| 589 | response is 'not implemented' for UDP and OK for TCP. | |
| 590 | """ | |
| b1bec9f0 | 591 | name = 'aorudp.advanced.tests.powerdns.com.' |
| e7a1029c RG |
592 | query = dns.message.make_query(name, 'AAAA', 'IN') |
| 593 | response = dns.message.make_response(query) | |
| 594 | rrset = dns.rrset.from_text(name, | |
| 595 | 3600, | |
| 596 | dns.rdataclass.IN, | |
| 597 | dns.rdatatype.AAAA, | |
| 598 | '::1') | |
| 599 | response.answer.append(rrset) | |
| 600 | ||
| 601 | expectedResponse = dns.message.make_response(query) | |
| 602 | expectedResponse.set_rcode(dns.rcode.NOTIMP) | |
| 603 | ||
| 604 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| e7a1029c RG |
605 | self.assertEquals(receivedResponse, expectedResponse) |
| 606 | ||
| 607 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 608 | self.assertTrue(receivedQuery) | |
| 609 | self.assertTrue(receivedResponse) | |
| 610 | receivedQuery.id = query.id | |
| e7a1029c RG |
611 | self.assertEquals(query, receivedQuery) |
| 612 | self.assertEquals(receivedResponse, response) | |
| 613 | ||
| 614 | def testAOverUDPReturnsNotImplemented(self): | |
| 615 | """ | |
| 616 | Advanced: A || UDP: A | |
| 617 | ||
| 618 | dnsdist is configured to reply 'not implemented' for query | |
| 619 | over UDP OR qtype A. | |
| 620 | We send an A query over UDP and TCP, and check that the | |
| 621 | response is 'not implemented' for both. | |
| 622 | """ | |
| b1bec9f0 | 623 | name = 'aorudp.advanced.tests.powerdns.com.' |
| e7a1029c RG |
624 | query = dns.message.make_query(name, 'A', 'IN') |
| 625 | ||
| 626 | expectedResponse = dns.message.make_response(query) | |
| 627 | expectedResponse.set_rcode(dns.rcode.NOTIMP) | |
| 628 | ||
| 629 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| e7a1029c RG |
630 | self.assertEquals(receivedResponse, expectedResponse) |
| 631 | ||
| 632 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| e7a1029c | 633 | self.assertEquals(receivedResponse, expectedResponse) |
| 886e2cf2 | 634 | |
| b1bec9f0 RG |
635 | |
| 636 | class TestAdvancedLogAction(DNSDistTest): | |
| 637 | ||
| 638 | _config_template = """ | |
| 639 | newServer{address="127.0.0.1:%s"} | |
| 640 | addAction(AllRule(), LogAction("dnsdist.log", false)) | |
| 641 | """ | |
| 642 | def testAdvancedLogAction(self): | |
| 643 | """ | |
| 644 | Advanced: Log all queries | |
| 645 | ||
| 646 | """ | |
| 647 | count = 50 | |
| 648 | name = 'logaction.advanced.tests.powerdns.com.' | |
| 649 | query = dns.message.make_query(name, 'A', 'IN') | |
| 650 | response = dns.message.make_response(query) | |
| 651 | rrset = dns.rrset.from_text(name, | |
| 652 | 3600, | |
| 653 | dns.rdataclass.IN, | |
| 654 | dns.rdatatype.A, | |
| 655 | '127.0.0.1') | |
| 656 | response.answer.append(rrset) | |
| 657 | ||
| 658 | for _ in range(count): | |
| 659 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 660 | self.assertTrue(receivedQuery) | |
| 661 | self.assertTrue(receivedResponse) | |
| 662 | receivedQuery.id = query.id | |
| b1bec9f0 RG |
663 | self.assertEquals(query, receivedQuery) |
| 664 | self.assertEquals(response, receivedResponse) | |
| 665 | ||
| 666 | self.assertTrue(os.path.isfile('dnsdist.log')) | |
| 667 | self.assertTrue(os.stat('dnsdist.log').st_size > 0) | |
| 668 | ||
| 669 | class TestAdvancedDNSSEC(DNSDistTest): | |
| 670 | ||
| 671 | _config_template = """ | |
| 672 | newServer{address="127.0.0.1:%s"} | |
| 673 | addAction(DNSSECRule(), DropAction()) | |
| 674 | """ | |
| 675 | def testAdvancedDNSSECDrop(self): | |
| 676 | """ | |
| 677 | Advanced: DNSSEC Rule | |
| 678 | ||
| 679 | """ | |
| 680 | name = 'dnssec.advanced.tests.powerdns.com.' | |
| 681 | query = dns.message.make_query(name, 'A', 'IN') | |
| 682 | doquery = dns.message.make_query(name, 'A', 'IN', want_dnssec=True) | |
| 683 | response = dns.message.make_response(query) | |
| 684 | rrset = dns.rrset.from_text(name, | |
| 685 | 3600, | |
| 686 | dns.rdataclass.IN, | |
| 687 | dns.rdatatype.A, | |
| 688 | '127.0.0.1') | |
| 689 | response.answer.append(rrset) | |
| 690 | ||
| 691 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 692 | self.assertTrue(receivedQuery) | |
| 693 | self.assertTrue(receivedResponse) | |
| 694 | receivedQuery.id = query.id | |
| b1bec9f0 RG |
695 | self.assertEquals(query, receivedQuery) |
| 696 | self.assertEquals(response, receivedResponse) | |
| 697 | ||
| 698 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 699 | self.assertTrue(receivedQuery) | |
| 700 | self.assertTrue(receivedResponse) | |
| 701 | receivedQuery.id = query.id | |
| b1bec9f0 RG |
702 | self.assertEquals(query, receivedQuery) |
| 703 | self.assertEquals(response, receivedResponse) | |
| 704 | ||
| 705 | (_, receivedResponse) = self.sendUDPQuery(doquery, response) | |
| 706 | self.assertEquals(receivedResponse, None) | |
| 707 | (_, receivedResponse) = self.sendTCPQuery(doquery, response) | |
| 708 | self.assertEquals(receivedResponse, None) | |
| 709 | ||
| 710 | class TestAdvancedQClass(DNSDistTest): | |
| 711 | ||
| 712 | _config_template = """ | |
| 713 | newServer{address="127.0.0.1:%s"} | |
| 55baa1f2 | 714 | addAction(QClassRule(DNSClass.CHAOS), DropAction()) |
| b1bec9f0 RG |
715 | """ |
| 716 | def testAdvancedQClassChaosDrop(self): | |
| 717 | """ | |
| 718 | Advanced: Drop QClass CHAOS | |
| 719 | ||
| 720 | """ | |
| 721 | name = 'qclasschaos.advanced.tests.powerdns.com.' | |
| 722 | query = dns.message.make_query(name, 'TXT', 'CHAOS') | |
| b1bec9f0 | 723 | |
| 55baa1f2 | 724 | (_, receivedResponse) = self.sendUDPQuery(query, response=None) |
| b1bec9f0 | 725 | self.assertEquals(receivedResponse, None) |
| 55baa1f2 | 726 | (_, receivedResponse) = self.sendTCPQuery(query, response=None) |
| b1bec9f0 RG |
727 | self.assertEquals(receivedResponse, None) |
| 728 | ||
| 729 | def testAdvancedQClassINAllow(self): | |
| 730 | """ | |
| 731 | Advanced: Allow QClass IN | |
| 732 | ||
| 733 | """ | |
| 734 | name = 'qclassin.advanced.tests.powerdns.com.' | |
| 735 | query = dns.message.make_query(name, 'A', 'IN') | |
| 736 | response = dns.message.make_response(query) | |
| 737 | rrset = dns.rrset.from_text(name, | |
| 738 | 3600, | |
| 739 | dns.rdataclass.IN, | |
| 740 | dns.rdatatype.A, | |
| 741 | '127.0.0.1') | |
| 742 | response.answer.append(rrset) | |
| 743 | ||
| 744 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 745 | self.assertTrue(receivedQuery) | |
| 746 | self.assertTrue(receivedResponse) | |
| 747 | receivedQuery.id = query.id | |
| b1bec9f0 RG |
748 | self.assertEquals(query, receivedQuery) |
| 749 | self.assertEquals(response, receivedResponse) | |
| 750 | ||
| 751 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 752 | self.assertTrue(receivedQuery) | |
| 753 | self.assertTrue(receivedResponse) | |
| 754 | receivedQuery.id = query.id | |
| b1bec9f0 RG |
755 | self.assertEquals(query, receivedQuery) |
| 756 | self.assertEquals(response, receivedResponse) | |
| 88d05ca1 | 757 | |
| 55baa1f2 RG |
758 | class TestAdvancedOpcode(DNSDistTest): |
| 759 | ||
| 760 | _config_template = """ | |
| 761 | newServer{address="127.0.0.1:%s"} | |
| 762 | addAction(OpcodeRule(DNSOpcode.Notify), DropAction()) | |
| 763 | """ | |
| 764 | def testAdvancedOpcodeNotifyDrop(self): | |
| 765 | """ | |
| 766 | Advanced: Drop Opcode NOTIFY | |
| 767 | ||
| 768 | """ | |
| 769 | name = 'opcodenotify.advanced.tests.powerdns.com.' | |
| 770 | query = dns.message.make_query(name, 'A', 'IN') | |
| 771 | query.set_opcode(dns.opcode.NOTIFY) | |
| 772 | ||
| 773 | (_, receivedResponse) = self.sendUDPQuery(query, response=None) | |
| 774 | self.assertEquals(receivedResponse, None) | |
| 775 | (_, receivedResponse) = self.sendTCPQuery(query, response=None) | |
| 776 | self.assertEquals(receivedResponse, None) | |
| 777 | ||
| 778 | def testAdvancedOpcodeUpdateINAllow(self): | |
| 779 | """ | |
| 780 | Advanced: Allow Opcode UPDATE | |
| 781 | ||
| 782 | """ | |
| 783 | name = 'opcodeupdate.advanced.tests.powerdns.com.' | |
| 784 | query = dns.message.make_query(name, 'A', 'IN') | |
| 785 | query.set_opcode(dns.opcode.UPDATE) | |
| 786 | response = dns.message.make_response(query) | |
| 787 | rrset = dns.rrset.from_text(name, | |
| 788 | 3600, | |
| 789 | dns.rdataclass.IN, | |
| 790 | dns.rdatatype.A, | |
| 791 | '127.0.0.1') | |
| 792 | response.answer.append(rrset) | |
| 793 | ||
| 794 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 795 | self.assertTrue(receivedQuery) | |
| 796 | self.assertTrue(receivedResponse) | |
| 797 | receivedQuery.id = query.id | |
| 798 | self.assertEquals(query, receivedQuery) | |
| 799 | self.assertEquals(response, receivedResponse) | |
| 800 | ||
| 801 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 802 | self.assertTrue(receivedQuery) | |
| 803 | self.assertTrue(receivedResponse) | |
| 804 | receivedQuery.id = query.id | |
| 805 | self.assertEquals(query, receivedQuery) | |
| 806 | self.assertEquals(response, receivedResponse) | |
| 46a839bf | 807 | |
| 88d05ca1 RG |
808 | class TestAdvancedNonTerminalRule(DNSDistTest): |
| 809 | ||
| 810 | _config_template = """ | |
| 811 | newServer{address="127.0.0.1:%s", pool="real"} | |
| 812 | addAction(AllRule(), DisableValidationAction()) | |
| 813 | addAction(AllRule(), PoolAction("real")) | |
| 814 | addAction(AllRule(), DropAction()) | |
| 815 | """ | |
| 816 | def testAdvancedNonTerminalRules(self): | |
| 817 | """ | |
| 818 | Advanced: Non terminal rules | |
| 819 | ||
| 820 | We check that DisableValidationAction() is applied | |
| 821 | but does not stop the processing, then that | |
| 822 | PoolAction() is applied _and_ stop the processing. | |
| 823 | """ | |
| 824 | name = 'nonterminal.advanced.tests.powerdns.com.' | |
| 825 | query = dns.message.make_query(name, 'A', 'IN') | |
| 826 | expectedQuery = dns.message.make_query(name, 'A', 'IN') | |
| 827 | expectedQuery.flags |= dns.flags.CD | |
| 828 | response = dns.message.make_response(query) | |
| 829 | rrset = dns.rrset.from_text(name, | |
| 830 | 3600, | |
| 831 | dns.rdataclass.IN, | |
| 832 | dns.rdatatype.A, | |
| 46a839bf | 833 | '192.0.2.1') |
| 88d05ca1 RG |
834 | response.answer.append(rrset) |
| 835 | ||
| 836 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 837 | self.assertTrue(receivedQuery) | |
| 838 | self.assertTrue(receivedResponse) | |
| 839 | receivedQuery.id = expectedQuery.id | |
| 840 | self.assertEquals(expectedQuery, receivedQuery) | |
| 841 | self.assertEquals(response, receivedResponse) | |
| 842 | ||
| 843 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 844 | self.assertTrue(receivedQuery) | |
| 845 | self.assertTrue(receivedResponse) | |
| 846 | receivedQuery.id = expectedQuery.id | |
| 847 | self.assertEquals(expectedQuery, receivedQuery) | |
| 848 | self.assertEquals(response, receivedResponse) | |
| 46a839bf RG |
849 | |
| 850 | class TestAdvancedStringOnlyServer(DNSDistTest): | |
| 851 | ||
| 852 | _config_template = """ | |
| 853 | newServer("127.0.0.1:%s") | |
| 854 | """ | |
| 855 | ||
| 856 | def testAdvancedStringOnlyServer(self): | |
| 857 | """ | |
| 858 | Advanced: "string-only" server is placed in the default pool | |
| 859 | """ | |
| 860 | name = 'string-only-server.advanced.tests.powerdns.com.' | |
| 861 | query = dns.message.make_query(name, 'A', 'IN') | |
| 862 | response = dns.message.make_response(query) | |
| 863 | rrset = dns.rrset.from_text(name, | |
| 864 | 3600, | |
| 865 | dns.rdataclass.IN, | |
| 866 | dns.rdatatype.A, | |
| 867 | '192.0.2.1') | |
| 868 | response.answer.append(rrset) | |
| 869 | ||
| 870 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 871 | self.assertTrue(receivedQuery) | |
| 872 | self.assertTrue(receivedResponse) | |
| 873 | receivedQuery.id = query.id | |
| 874 | self.assertEquals(query, receivedQuery) | |
| 875 | self.assertEquals(response, receivedResponse) | |
| 876 | ||
| 877 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 878 | self.assertTrue(receivedQuery) | |
| 879 | self.assertTrue(receivedResponse) | |
| 880 | receivedQuery.id = query.id | |
| 881 | self.assertEquals(query, receivedQuery) | |
| 882 | self.assertEquals(response, receivedResponse) | |
| 0f72fd5c RG |
883 | |
| 884 | class TestAdvancedRestoreFlagsOnSelfResponse(DNSDistTest): | |
| 885 | ||
| 886 | _config_template = """ | |
| 887 | addAction(AllRule(), DisableValidationAction()) | |
| 888 | addAction(AllRule(), SpoofAction("192.0.2.1")) | |
| 889 | newServer{address="127.0.0.1:%s"} | |
| 890 | """ | |
| 891 | ||
| 892 | def testAdvancedRestoreFlagsOnSpoofResponse(self): | |
| 893 | """ | |
| 894 | Advanced: Restore flags on spoofed response | |
| 895 | ||
| 896 | Send a query with CD flag cleared, dnsdist is | |
| 897 | instructed to set it, then to spoof the response, | |
| 898 | check that response has the flag cleared. | |
| 899 | """ | |
| 900 | name = 'spoofed.restoreflags.advanced.tests.powerdns.com.' | |
| 901 | query = dns.message.make_query(name, 'A', 'IN') | |
| 902 | # dnsdist set RA = RD for spoofed responses | |
| 903 | query.flags &= ~dns.flags.RD | |
| 0f72fd5c RG |
904 | |
| 905 | response = dns.message.make_response(query) | |
| 906 | rrset = dns.rrset.from_text(name, | |
| 907 | 60, | |
| 908 | dns.rdataclass.IN, | |
| 909 | dns.rdatatype.A, | |
| 910 | '192.0.2.1') | |
| 911 | response.answer.append(rrset) | |
| 912 | ||
| 913 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 914 | self.assertTrue(receivedResponse) | |
| 915 | self.assertEquals(response, receivedResponse) | |
| 916 | ||
| 917 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 918 | self.assertTrue(receivedResponse) | |
| 919 | self.assertEquals(response, receivedResponse) | |
| 856c35e3 RG |
920 | |
| 921 | class TestAdvancedQPS(DNSDistTest): | |
| 922 | ||
| 923 | _config_template = """ | |
| 924 | addQPSLimit("qps.advanced.tests.powerdns.com", 10) | |
| 925 | newServer{address="127.0.0.1:%s"} | |
| 926 | """ | |
| 927 | ||
| 928 | def testAdvancedQPSLimit(self): | |
| 929 | """ | |
| 930 | Advanced: QPS Limit | |
| 931 | ||
| 932 | Send queries to "qps.advanced.tests.powerdns.com." | |
| 933 | check that dnsdist drops queries when the max QPS has been reached. | |
| 934 | """ | |
| 935 | maxQPS = 10 | |
| 936 | name = 'qps.advanced.tests.powerdns.com.' | |
| 937 | query = dns.message.make_query(name, 'A', 'IN') | |
| 938 | response = dns.message.make_response(query) | |
| 939 | rrset = dns.rrset.from_text(name, | |
| 940 | 60, | |
| 941 | dns.rdataclass.IN, | |
| 942 | dns.rdatatype.A, | |
| 943 | '192.0.2.1') | |
| 944 | response.answer.append(rrset) | |
| 945 | ||
| 946 | for _ in range(maxQPS): | |
| 947 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 948 | receivedQuery.id = query.id | |
| 949 | self.assertEquals(query, receivedQuery) | |
| 950 | self.assertEquals(response, receivedResponse) | |
| 951 | ||
| 952 | # we should now be dropped | |
| 953 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 954 | self.assertEquals(receivedResponse, None) | |
| 955 | ||
| 956 | time.sleep(1) | |
| 957 | ||
| 958 | # again, over TCP this time | |
| 959 | for _ in range(maxQPS): | |
| 960 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 961 | receivedQuery.id = query.id | |
| 962 | self.assertEquals(query, receivedQuery) | |
| 963 | self.assertEquals(response, receivedResponse) | |
| 964 | ||
| 965 | ||
| 966 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 967 | self.assertEquals(receivedResponse, None) | |
| 968 | ||
| 969 | class TestAdvancedQPSNone(DNSDistTest): | |
| 970 | ||
| 971 | _config_template = """ | |
| 972 | addQPSLimit("qpsnone.advanced.tests.powerdns.com", 100) | |
| 55baa1f2 | 973 | addAction(AllRule(), RCodeAction(dnsdist.REFUSED)) |
| 856c35e3 RG |
974 | newServer{address="127.0.0.1:%s"} |
| 975 | """ | |
| 976 | ||
| 977 | def testAdvancedQPSNone(self): | |
| 978 | """ | |
| 979 | Advanced: Not matching QPS returns None, not Allow | |
| 980 | ||
| 981 | Send queries to "qps.advanced.tests.powerdns.com." | |
| 982 | check that the rule returns None when the QPS has not been | |
| 983 | reached, not Allow. | |
| 984 | """ | |
| 985 | name = 'qpsnone.advanced.tests.powerdns.com.' | |
| 986 | query = dns.message.make_query(name, 'A', 'IN') | |
| 987 | expectedResponse = dns.message.make_response(query) | |
| 988 | expectedResponse.set_rcode(dns.rcode.REFUSED) | |
| 989 | ||
| 990 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 991 | self.assertEquals(receivedResponse, expectedResponse) | |
| 992 | ||
| 993 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 994 | self.assertEquals(receivedResponse, expectedResponse) | |
| 36da3ecd RG |
995 | |
| 996 | class TestAdvancedNMGRule(DNSDistTest): | |
| 997 | ||
| 998 | _config_template = """ | |
| 999 | allowed = newNMG() | |
| 1000 | allowed:addMask("192.0.2.1/32") | |
| 55baa1f2 | 1001 | addAction(NotRule(NetmaskGroupRule(allowed)), RCodeAction(dnsdist.REFUSED)) |
| 36da3ecd RG |
1002 | newServer{address="127.0.0.1:%s"} |
| 1003 | """ | |
| 1004 | ||
| 1005 | def testAdvancedNMGRule(self): | |
| 1006 | """ | |
| 1007 | Advanced: NMGRule should refuse our queries | |
| 1008 | ||
| 1009 | Send queries to "nmgrule.advanced.tests.powerdns.com.", | |
| 1010 | check that we are getting a REFUSED response. | |
| 1011 | """ | |
| 1012 | name = 'nmgrule.advanced.tests.powerdns.com.' | |
| 1013 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1014 | expectedResponse = dns.message.make_response(query) | |
| 1015 | expectedResponse.set_rcode(dns.rcode.REFUSED) | |
| 1016 | ||
| 1017 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 1018 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1019 | ||
| 1020 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 1021 | self.assertEquals(receivedResponse, expectedResponse) | |
| 55baa1f2 | 1022 | |
| 57c61ce9 RG |
1023 | class TestAdvancedLabelsCountRule(DNSDistTest): |
| 1024 | ||
| 1025 | _config_template = """ | |
| 1026 | addAction(QNameLabelsCountRule(5,6), RCodeAction(dnsdist.REFUSED)) | |
| 1027 | newServer{address="127.0.0.1:%s"} | |
| 1028 | """ | |
| 1029 | ||
| 1030 | def testAdvancedLabelsCountRule(self): | |
| 1031 | """ | |
| 1032 | Advanced: QNameLabelsCountRule(5,6) | |
| 1033 | """ | |
| 1034 | # 6 labels, we should be fine | |
| 1035 | name = 'ok.labelscount.advanced.tests.powerdns.com.' | |
| 1036 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1037 | response = dns.message.make_response(query) | |
| 1038 | rrset = dns.rrset.from_text(name, | |
| 1039 | 3600, | |
| 1040 | dns.rdataclass.IN, | |
| 1041 | dns.rdatatype.A, | |
| 1042 | '192.0.2.1') | |
| 1043 | response.answer.append(rrset) | |
| 1044 | ||
| 1045 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 1046 | self.assertTrue(receivedQuery) | |
| 1047 | self.assertTrue(receivedResponse) | |
| 1048 | receivedQuery.id = query.id | |
| 1049 | self.assertEquals(query, receivedQuery) | |
| 1050 | self.assertEquals(response, receivedResponse) | |
| 1051 | ||
| 1052 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 1053 | self.assertTrue(receivedQuery) | |
| 1054 | self.assertTrue(receivedResponse) | |
| 1055 | receivedQuery.id = query.id | |
| 1056 | self.assertEquals(query, receivedQuery) | |
| 1057 | self.assertEquals(response, receivedResponse) | |
| 1058 | ||
| 1059 | # more than 6 labels, the query should be refused | |
| 1060 | name = 'not.ok.labelscount.advanced.tests.powerdns.com.' | |
| 1061 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1062 | expectedResponse = dns.message.make_response(query) | |
| 1063 | expectedResponse.set_rcode(dns.rcode.REFUSED) | |
| 1064 | ||
| 1065 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 1066 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1067 | ||
| 1068 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 1069 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1070 | ||
| 1071 | # less than 5 labels, the query should be refused | |
| 1072 | name = 'labelscountadvanced.tests.powerdns.com.' | |
| 1073 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1074 | expectedResponse = dns.message.make_response(query) | |
| 1075 | expectedResponse.set_rcode(dns.rcode.REFUSED) | |
| 1076 | ||
| 1077 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 1078 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1079 | ||
| 1080 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 1081 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1082 | ||
| 1083 | class TestAdvancedWireLengthRule(DNSDistTest): | |
| 1084 | ||
| 1085 | _config_template = """ | |
| 1086 | addAction(QNameWireLengthRule(54,56), RCodeAction(dnsdist.REFUSED)) | |
| 1087 | newServer{address="127.0.0.1:%s"} | |
| 1088 | """ | |
| 1089 | ||
| 1090 | def testAdvancedWireLengthRule(self): | |
| 1091 | """ | |
| 1092 | Advanced: QNameWireLengthRule(54,56) | |
| 1093 | """ | |
| 1094 | name = 'longenough.qnamewirelength.advanced.tests.powerdns.com.' | |
| 1095 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1096 | response = dns.message.make_response(query) | |
| 1097 | rrset = dns.rrset.from_text(name, | |
| 1098 | 3600, | |
| 1099 | dns.rdataclass.IN, | |
| 1100 | dns.rdatatype.A, | |
| 1101 | '192.0.2.1') | |
| 1102 | response.answer.append(rrset) | |
| 1103 | ||
| 1104 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 1105 | self.assertTrue(receivedQuery) | |
| 1106 | self.assertTrue(receivedResponse) | |
| 1107 | receivedQuery.id = query.id | |
| 1108 | self.assertEquals(query, receivedQuery) | |
| 1109 | self.assertEquals(response, receivedResponse) | |
| 1110 | ||
| 1111 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 1112 | self.assertTrue(receivedQuery) | |
| 1113 | self.assertTrue(receivedResponse) | |
| 1114 | receivedQuery.id = query.id | |
| 1115 | self.assertEquals(query, receivedQuery) | |
| 1116 | self.assertEquals(response, receivedResponse) | |
| 1117 | ||
| 1118 | # too short, the query should be refused | |
| 1119 | name = 'short.qnamewirelength.advanced.tests.powerdns.com.' | |
| 1120 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1121 | expectedResponse = dns.message.make_response(query) | |
| 1122 | expectedResponse.set_rcode(dns.rcode.REFUSED) | |
| 1123 | ||
| 1124 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 1125 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1126 | ||
| 1127 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 1128 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1129 | ||
| 1130 | # too long, the query should be refused | |
| 1131 | name = 'toolongtobevalid.qnamewirelength.advanced.tests.powerdns.com.' | |
| 1132 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1133 | expectedResponse = dns.message.make_response(query) | |
| 1134 | expectedResponse.set_rcode(dns.rcode.REFUSED) | |
| 1135 | ||
| 1136 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 1137 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1138 | ||
| 1139 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 1140 | self.assertEquals(receivedResponse, expectedResponse) | |
| 69389510 RG |
1141 | |
| 1142 | class TestAdvancedIncludeDir(DNSDistTest): | |
| 1143 | ||
| 1144 | _config_template = """ | |
| 1145 | -- this directory contains a file allowing includedir.advanced.tests.powerdns.com. | |
| 1146 | includeDirectory('test-include-dir') | |
| 69389510 RG |
1147 | newServer{address="127.0.0.1:%s"} |
| 1148 | """ | |
| 1149 | ||
| 1150 | def testAdvancedIncludeDirAllowed(self): | |
| 1151 | """ | |
| 1152 | Advanced: includeDirectory() | |
| 1153 | """ | |
| 1154 | name = 'includedir.advanced.tests.powerdns.com.' | |
| 1155 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1156 | response = dns.message.make_response(query) | |
| 1157 | rrset = dns.rrset.from_text(name, | |
| 1158 | 3600, | |
| 1159 | dns.rdataclass.IN, | |
| 1160 | dns.rdatatype.A, | |
| 1161 | '192.0.2.1') | |
| 1162 | response.answer.append(rrset) | |
| 1163 | ||
| 1164 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 1165 | self.assertTrue(receivedQuery) | |
| 1166 | self.assertTrue(receivedResponse) | |
| 1167 | receivedQuery.id = query.id | |
| 1168 | self.assertEquals(query, receivedQuery) | |
| 1169 | self.assertEquals(response, receivedResponse) | |
| 1170 | ||
| 1171 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 1172 | self.assertTrue(receivedQuery) | |
| 1173 | self.assertTrue(receivedResponse) | |
| 1174 | receivedQuery.id = query.id | |
| 1175 | self.assertEquals(query, receivedQuery) | |
| 1176 | self.assertEquals(response, receivedResponse) | |
| 1177 | ||
| 1178 | # this one should be refused | |
| 1179 | name = 'notincludedir.advanced.tests.powerdns.com.' | |
| 1180 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1181 | expectedResponse = dns.message.make_response(query) | |
| 1182 | expectedResponse.set_rcode(dns.rcode.REFUSED) | |
| 1183 | ||
| 1184 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 1185 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1186 | ||
| 1187 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 1188 | self.assertEquals(receivedResponse, expectedResponse) | |
| b82f0bc2 RG |
1189 | |
| 1190 | class TestAdvancedLuaDO(DNSDistTest): | |
| 1191 | ||
| 1192 | _config_template = """ | |
| 1193 | function nxDOLua(dq) | |
| 1194 | if dq:getDO() then | |
| 1195 | return DNSAction.Nxdomain, "" | |
| 1196 | end | |
| 1197 | return DNSAction.None, "" | |
| 1198 | end | |
| 1199 | addLuaAction(AllRule(), nxDOLua) | |
| 1200 | newServer{address="127.0.0.1:%s"} | |
| 1201 | """ | |
| 1202 | ||
| 1203 | def testNxDOViaLua(self): | |
| 1204 | """ | |
| 1205 | Advanced: Nx DO queries via Lua | |
| 1206 | """ | |
| 1207 | name = 'nxdo.advanced.tests.powerdns.com.' | |
| 1208 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1209 | response = dns.message.make_response(query) | |
| 1210 | rrset = dns.rrset.from_text(name, | |
| 1211 | 3600, | |
| 1212 | dns.rdataclass.IN, | |
| 1213 | dns.rdatatype.AAAA, | |
| 1214 | '::1') | |
| 1215 | response.answer.append(rrset) | |
| 1216 | queryWithDO = dns.message.make_query(name, 'A', 'IN', want_dnssec=True) | |
| 1217 | doResponse = dns.message.make_response(queryWithDO) | |
| 1218 | doResponse.set_rcode(dns.rcode.NXDOMAIN) | |
| 1219 | ||
| 1220 | # without DO | |
| 1221 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 1222 | self.assertTrue(receivedQuery) | |
| 1223 | self.assertTrue(receivedResponse) | |
| 1224 | receivedQuery.id = query.id | |
| 1225 | self.assertEquals(query, receivedQuery) | |
| 1226 | self.assertEquals(receivedResponse, response) | |
| 1227 | ||
| 1228 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 1229 | self.assertTrue(receivedQuery) | |
| 1230 | self.assertTrue(receivedResponse) | |
| 1231 | receivedQuery.id = query.id | |
| 1232 | self.assertEquals(query, receivedQuery) | |
| 1233 | self.assertEquals(receivedResponse, response) | |
| 1234 | ||
| 1235 | # with DO | |
| 1236 | (_, receivedResponse) = self.sendUDPQuery(queryWithDO, response=None, useQueue=False) | |
| 1237 | self.assertTrue(receivedResponse) | |
| 1238 | doResponse.id = receivedResponse.id | |
| 1239 | print(doResponse) | |
| 1240 | print(receivedResponse) | |
| 1241 | self.assertEquals(receivedResponse, doResponse) | |
| 1242 | ||
| 1243 | (_, receivedResponse) = self.sendTCPQuery(queryWithDO, response=None, useQueue=False) | |
| 1244 | self.assertTrue(receivedResponse) | |
| 1245 | doResponse.id = receivedResponse.id | |
| 1246 | self.assertEquals(receivedResponse, doResponse) | |
| 26b86deb RG |
1247 | |
| 1248 | class TestStatNodeRespRingSince(DNSDistTest): | |
| 1249 | ||
| 1250 | _consoleKey = DNSDistTest.generateConsoleKey() | |
| 1251 | _consoleKeyB64 = base64.b64encode(_consoleKey) | |
| 1252 | _config_params = ['_consoleKeyB64', '_consolePort', '_testServerPort'] | |
| 1253 | _config_template = """ | |
| 1254 | setKey("%s") | |
| 1255 | controlSocket("127.0.0.1:%s") | |
| 1256 | s1 = newServer{address="127.0.0.1:%s"} | |
| 1257 | s1:setUp() | |
| 1258 | function visitor(node, self, childstat) | |
| 1259 | table.insert(nodesSeen, node.fullname) | |
| 1260 | end | |
| 1261 | """ | |
| 1262 | ||
| 1263 | def testStatNodeRespRingSince(self): | |
| 1264 | """ | |
| 1265 | Advanced: StatNodeRespRing with optional since parameter | |
| 1266 | ||
| 1267 | """ | |
| 1268 | name = 'statnodesince.advanced.tests.powerdns.com.' | |
| 1269 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1270 | response = dns.message.make_response(query) | |
| 1271 | rrset = dns.rrset.from_text(name, | |
| 1272 | 1, | |
| 1273 | dns.rdataclass.IN, | |
| 1274 | dns.rdatatype.A, | |
| 1275 | '127.0.0.1') | |
| 1276 | response.answer.append(rrset) | |
| 1277 | ||
| 1278 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 1279 | self.assertTrue(receivedQuery) | |
| 1280 | self.assertTrue(receivedResponse) | |
| 1281 | receivedQuery.id = query.id | |
| 1282 | self.assertEquals(query, receivedQuery) | |
| 1283 | self.assertEquals(response, receivedResponse) | |
| 1284 | ||
| 1285 | self.sendConsoleCommand("nodesSeen = {}") | |
| 1286 | self.sendConsoleCommand("statNodeRespRing(visitor)") | |
| 1287 | nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str") | |
| 1288 | nodes = string.strip(nodes, "\n") | |
| 1289 | self.assertEquals(nodes, """statnodesince.advanced.tests.powerdns.com. | |
| 1290 | advanced.tests.powerdns.com. | |
| 1291 | tests.powerdns.com. | |
| 1292 | powerdns.com. | |
| 1293 | com.""") | |
| 1294 | ||
| 1295 | self.sendConsoleCommand("nodesSeen = {}") | |
| 1296 | self.sendConsoleCommand("statNodeRespRing(visitor, 0)") | |
| 1297 | nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str") | |
| 1298 | nodes = string.strip(nodes, "\n") | |
| 1299 | self.assertEquals(nodes, """statnodesince.advanced.tests.powerdns.com. | |
| 1300 | advanced.tests.powerdns.com. | |
| 1301 | tests.powerdns.com. | |
| 1302 | powerdns.com. | |
| 1303 | com.""") | |
| 1304 | ||
| 1305 | time.sleep(5) | |
| 1306 | ||
| 1307 | self.sendConsoleCommand("nodesSeen = {}") | |
| 1308 | self.sendConsoleCommand("statNodeRespRing(visitor)") | |
| 1309 | nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str") | |
| 1310 | nodes = string.strip(nodes, "\n") | |
| 1311 | self.assertEquals(nodes, """statnodesince.advanced.tests.powerdns.com. | |
| 1312 | advanced.tests.powerdns.com. | |
| 1313 | tests.powerdns.com. | |
| 1314 | powerdns.com. | |
| 1315 | com.""") | |
| 1316 | ||
| 1317 | self.sendConsoleCommand("nodesSeen = {}") | |
| 1318 | self.sendConsoleCommand("statNodeRespRing(visitor, 5)") | |
| 1319 | nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str") | |
| 1320 | nodes = string.strip(nodes, "\n") | |
| 1321 | self.assertEquals(nodes, """""") | |
| 1322 | ||
| 1323 | self.sendConsoleCommand("nodesSeen = {}") | |
| 1324 | self.sendConsoleCommand("statNodeRespRing(visitor, 10)") | |
| 1325 | nodes = self.sendConsoleCommand("str = '' for key,value in pairs(nodesSeen) do str = str..value..\"\\n\" end return str") | |
| 1326 | nodes = string.strip(nodes, "\n") | |
| 1327 | self.assertEquals(nodes, """statnodesince.advanced.tests.powerdns.com. | |
| 1328 | advanced.tests.powerdns.com. | |
| 1329 | tests.powerdns.com. | |
| 1330 | powerdns.com. | |
| 1331 | com.""") | |
| 7caebbb2 RG |
1332 | |
| 1333 | class TestAdvancedRD(DNSDistTest): | |
| 1334 | ||
| 1335 | _config_template = """ | |
| 1336 | addAction(RDRule(), RCodeAction(dnsdist.REFUSED)) | |
| 1337 | newServer{address="127.0.0.1:%s"} | |
| 1338 | """ | |
| 1339 | ||
| 1340 | def testAdvancedRDRefused(self): | |
| 1341 | """ | |
| 1342 | Advanced: RD query is refused | |
| 1343 | """ | |
| 1344 | name = 'rd.advanced.tests.powerdns.com.' | |
| 1345 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1346 | expectedResponse = dns.message.make_response(query) | |
| 1347 | expectedResponse.set_rcode(dns.rcode.REFUSED) | |
| 1348 | ||
| 1349 | (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False) | |
| 1350 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1351 | ||
| 1352 | (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False) | |
| 1353 | self.assertEquals(receivedResponse, expectedResponse) | |
| 1354 | ||
| 1355 | def testAdvancedNoRDAllowed(self): | |
| 1356 | """ | |
| 1357 | Advanced: No-RD query is allowed | |
| 1358 | """ | |
| 1359 | name = 'no-rd.advanced.tests.powerdns.com.' | |
| 1360 | query = dns.message.make_query(name, 'A', 'IN') | |
| 1361 | query.flags &= ~dns.flags.RD | |
| 1362 | response = dns.message.make_response(query) | |
| 1363 | ||
| 1364 | (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response) | |
| 1365 | receivedQuery.id = query.id | |
| 1366 | self.assertEquals(receivedQuery, query) | |
| 1367 | self.assertEquals(receivedResponse, response) | |
| 1368 | ||
| 1369 | (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response) | |
| 1370 | receivedQuery.id = query.id | |
| 1371 | self.assertEquals(receivedQuery, query) | |
| 1372 | self.assertEquals(receivedResponse, response) |