pdns/test-packetcache_cc.cc

   1 #define BOOST_TEST_DYN_LINK
   2 #define BOOST_TEST_NO_MAIN
   3
   4 #ifdef HAVE_CONFIG_H
   5 #include "config.h"
   6 #endif
   7 #include <boost/test/unit_test.hpp>
   8 #include <boost/test/floating_point_comparison.hpp>
   9 #include "iputils.hh"
  10 #include "nameserver.hh"
  11 #include "statbag.hh"
  12 #include "auth-packetcache.hh"
  13 #include "auth-querycache.hh"
  14 #include "arguments.hh"
  15 #include <utility>
  16 extern StatBag S;
  17
  18 BOOST_AUTO_TEST_SUITE(test_packetcache_cc)
  19
  20 BOOST_AUTO_TEST_CASE(test_AuthQueryCacheSimple) {
  21   AuthQueryCache QC;
  22   QC.setMaxEntries(1000000);
  23
  24   vector<DNSZoneRecord> records;
  25
  26   BOOST_CHECK_EQUAL(QC.size(), 0);
  27   QC.insert(DNSName("hello"), QType(QType::A), records, 3600, 1);
  28   BOOST_CHECK_EQUAL(QC.size(), 1);
  29   BOOST_CHECK_EQUAL(QC.purge(), 1);
  30   BOOST_CHECK_EQUAL(QC.size(), 0);
  31
  32   uint64_t counter=0;
  33   try {
  34     for(counter = 0; counter < 100000; ++counter) {
  35       DNSName a=DNSName("hello ")+DNSName(std::to_string(counter));
  36       BOOST_CHECK_EQUAL(DNSName(a.toString()), a);
  37
  38       QC.insert(a, QType(QType::A), records, 3600, 1);
  39       if(!QC.purge(a.toString()))
  40         BOOST_FAIL("Could not remove entry we just added to the query cache!");
  41       QC.insert(a, QType(QType::A), records, 3600, 1);
  42     }
  43
  44     BOOST_CHECK_EQUAL(QC.size(), counter);
  45
  46     uint64_t delcounter=0;
  47     for(delcounter=0; delcounter < counter/100; ++delcounter) {
  48       DNSName a=DNSName("hello ")+DNSName(std::to_string(delcounter));
  49       BOOST_CHECK_EQUAL(QC.purge(a.toString()), 1);
  50     }
  51
  52     BOOST_CHECK_EQUAL(QC.size(), counter-delcounter);
  53
  54     uint64_t matches=0;
  55     vector<DNSZoneRecord> entry;
  56     int64_t expected=counter-delcounter;
  57     for(; delcounter < counter; ++delcounter) {
  58       if(QC.getEntry(DNSName("hello ")+DNSName(std::to_string(delcounter)), QType(QType::A), entry, 1)) {
  59         matches++;
  60       }
  61     }
  62     BOOST_CHECK_EQUAL(matches, expected);
  63     BOOST_CHECK_EQUAL(entry.size(), records.size());
  64   }
  65   catch(PDNSException& e) {
  66     cerr<<"Had error: "<<e.reason<<endl;
  67     throw;
  68   }
  69
  70 }
  71
  72 static AuthQueryCache* g_QC;
  73 static AtomicCounter g_QCmissing;
  74
  75 static void *threadQCMangler(void* a)
  76 try
  77 {
  78   vector<DNSZoneRecord> records;
  79   unsigned int offset=(unsigned int)(unsigned long)a;
  80   for(unsigned int counter=0; counter < 100000; ++counter)
  81     g_QC->insert(DNSName("hello ")+DNSName(std::to_string(counter+offset)), QType(QType::A), records, 3600, 1);
  82   return 0;
  83 }
  84  catch(PDNSException& e) {
  85    cerr<<"Had error: "<<e.reason<<endl;
  86    throw;
  87  }
  88
  89 static void *threadQCReader(void* a)
  90 try
  91 {
  92   unsigned int offset=(unsigned int)(unsigned long)a;
  93   vector<DNSZoneRecord> entry;
  94   for(unsigned int counter=0; counter < 100000; ++counter)
  95     if(!g_QC->getEntry(DNSName("hello ")+DNSName(std::to_string(counter+offset)), QType(QType::A), entry, 1)) {
  96       g_QCmissing++;
  97     }
  98   return 0;
  99 }
 100 catch(PDNSException& e) {
 101   cerr<<"Had error in threadQCReader: "<<e.reason<<endl;
 102   throw;
 103 }
 104
 105 BOOST_AUTO_TEST_CASE(test_QueryCacheThreaded) {
 106   try {
 107     AuthQueryCache QC;
 108     QC.setMaxEntries(1000000);
 109     g_QC=&QC;
 110     pthread_t tid[4];
 111     for(int i=0; i < 4; ++i)
 112       pthread_create(&tid[i], 0, threadQCMangler, (void*)(i*1000000UL));
 113     void* res;
 114     for(int i=0; i < 4 ; ++i)
 115       pthread_join(tid[i], &res);
 116
 117     BOOST_CHECK_EQUAL(QC.size() + S.read("deferred-cache-inserts"), 400000);
 118     BOOST_CHECK_SMALL(1.0*S.read("deferred-cache-inserts"), 10000.0);
 119
 120     for(int i=0; i < 4; ++i)
 121       pthread_create(&tid[i], 0, threadQCReader, (void*)(i*1000000UL));
 122     for(int i=0; i < 4 ; ++i)
 123       pthread_join(tid[i], &res);
 124
 125     BOOST_CHECK(S.read("deferred-cache-inserts") + S.read("deferred-cache-lookup") >= g_QCmissing);
 126     //    BOOST_CHECK_EQUAL(S.read("deferred-cache-lookup"), 0); // cache cleaning invalidates this
 127   }
 128   catch(PDNSException& e) {
 129     cerr<<"Had error: "<<e.reason<<endl;
 130     throw;
 131   }
 132
 133 }
 134
 135 static AuthPacketCache* g_PC;
 136 static AtomicCounter g_PCmissing;
 137
 138 static void *threadPCMangler(void* a)
 139 try
 140 {
 141   unsigned int offset=(unsigned int)(unsigned long)a;
 142   for(unsigned int counter=0; counter < 100000; ++counter) {
 143     vector<uint8_t> pak;
 144     DNSName qname = DNSName("hello ")+DNSName(std::to_string(counter+offset));
 145
 146     DNSPacketWriter pw(pak, qname, QType::A);
 147     DNSPacket q(true);
 148     q.parse((char*)&pak[0], pak.size());
 149
 150     pak.clear();
 151     DNSPacketWriter pw2(pak, qname, QType::A);
 152     pw2.startRecord(qname, QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER);
 153     pw2.xfrIP(htonl(0x7f000001));
 154     pw2.commit();
 155
 156     DNSPacket r(false);
 157     r.parse((char*)&pak[0], pak.size());
 158
 159     /* this step is necessary to get a valid hash */
 160     DNSPacket cached(false);
 161     g_PC->get(&q, &cached);
 162
 163     const unsigned int maxTTL = 3600;
 164     g_PC->insert(&q, &r, maxTTL);
 165   }
 166
 167   return 0;
 168 }
 169  catch(PDNSException& e) {
 170    cerr<<"Had error: "<<e.reason<<endl;
 171    throw;
 172  }
 173
 174 static void *threadPCReader(void* a)
 175 try
 176 {
 177   unsigned int offset=(unsigned int)(unsigned long)a;
 178   vector<DNSZoneRecord> entry;
 179   for(unsigned int counter=0; counter < 100000; ++counter) {
 180     vector<uint8_t> pak;
 181     DNSName qname = DNSName("hello ")+DNSName(std::to_string(counter+offset));
 182
 183     DNSPacketWriter pw(pak, qname, QType::A);
 184     DNSPacket q(true);
 185     q.parse((char*)&pak[0], pak.size());
 186     DNSPacket r(false);
 187
 188     if(!g_PC->get(&q, &r)) {
 189       g_PCmissing++;
 190     }
 191   }
 192
 193   return 0;
 194 }
 195 catch(PDNSException& e) {
 196   cerr<<"Had error in threadPCReader: "<<e.reason<<endl;
 197   throw;
 198 }
 199
 200 BOOST_AUTO_TEST_CASE(test_PacketCacheThreaded) {
 201   try {
 202     AuthPacketCache PC;
 203     PC.setMaxEntries(1000000);
 204     PC.setTTL(3600);
 205
 206     g_PC=&PC;
 207     pthread_t tid[4];
 208     for(int i=0; i < 4; ++i)
 209       pthread_create(&tid[i], 0, threadPCMangler, (void*)(i*1000000UL));
 210     void* res;
 211     for(int i=0; i < 4 ; ++i)
 212       pthread_join(tid[i], &res);
 213
 214     BOOST_CHECK_EQUAL(PC.size() + S.read("deferred-packetcache-inserts"), 400000);
 215     BOOST_CHECK_SMALL(1.0*S.read("deferred-packetcache-inserts"), 10000.0);
 216
 217     for(int i=0; i < 4; ++i)
 218       pthread_create(&tid[i], 0, threadPCReader, (void*)(i*1000000UL));
 219     for(int i=0; i < 4 ; ++i)
 220       pthread_join(tid[i], &res);
 221
 222 /*
 223     cerr<<"Misses: "<<S.read("packetcache-miss")<<endl;
 224     cerr<<"Hits: "<<S.read("packetcache-hit")<<endl;
 225     cerr<<"Deferred inserts: "<<S.read("deferred-packetcache-inserts")<<endl;
 226     cerr<<"Deferred lookups: "<<S.read("deferred-packetcache-lookup")<<endl;
 227 */
 228     BOOST_CHECK_EQUAL(g_PCmissing + S.read("packetcache-hit"), 400000);
 229     BOOST_CHECK_GT(S.read("deferred-packetcache-inserts") + S.read("deferred-packetcache-lookup"), g_PCmissing);
 230   }
 231   catch(PDNSException& e) {
 232     cerr<<"Had error: "<<e.reason<<endl;
 233     throw;
 234   }
 235
 236 }
 237
 238 bool g_stopCleaning;
 239 static void *cacheCleaner(void*)
 240 try
 241 {
 242   while(!g_stopCleaning) {
 243     g_QC->cleanup();
 244   }
 245
 246   return 0;
 247 }
 248 catch(PDNSException& e) {
 249   cerr<<"Had error in cacheCleaner: "<<e.reason<<endl;
 250   throw;
 251 }
 252
 253 BOOST_AUTO_TEST_CASE(test_QueryCacheClean) {
 254   try {
 255     AuthQueryCache QC;
 256     QC.setMaxEntries(10000);
 257     vector<DNSZoneRecord> records;
 258
 259     for(unsigned int counter = 0; counter < 1000000; ++counter) {
 260       QC.insert(DNSName("hello ")+DNSName(std::to_string(counter)), QType(QType::A), records, 1, 1);
 261     }
 262
 263     sleep(1);
 264
 265     g_QC=&QC;
 266     pthread_t tid[4];
 267
 268     pthread_create(&tid[0], 0, threadQCReader, (void*)(0*1000000UL));
 269     pthread_create(&tid[1], 0, threadQCReader, (void*)(1*1000000UL));
 270     pthread_create(&tid[2], 0, threadQCReader, (void*)(2*1000000UL));
 271     //    pthread_create(&tid[2], 0, threadMangler, (void*)(0*1000000UL));
 272     pthread_create(&tid[3], 0, cacheCleaner, 0);
 273
 274     void *res;
 275     for(int i=0; i < 3 ; ++i)
 276       pthread_join(tid[i], &res);
 277     g_stopCleaning=true;
 278     pthread_join(tid[3], &res);
 279   }
 280   catch(PDNSException& e) {
 281     cerr<<"Had error in test_QueryCacheClean: "<<e.reason<<endl;
 282     throw;
 283   }
 284 }
 285
 286 BOOST_AUTO_TEST_CASE(test_AuthPacketCache) {
 287   try {
 288     ::arg().setSwitch("no-shuffle","Set this to prevent random shuffling of answers - for regression testing")="off";
 289
 290     AuthPacketCache PC;
 291     PC.setTTL(20);
 292     PC.setMaxEntries(100000);
 293
 294     vector<uint8_t> pak;
 295     DNSPacket q(true), differentIDQ(true), ednsQ(true), ednsVersion42(true), ednsDO(true), ecs1(true), ecs2(true), ecs3(true);
 296     DNSPacket r(false), r2(false);
 297
 298     {
 299       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 300       q.parse((char*)&pak[0], pak.size());
 301
 302       differentIDQ.parse((char*)&pak[0], pak.size());
 303       differentIDQ.setID(4242);
 304
 305       pw.addOpt(512, 0, 0);
 306       pw.commit();
 307       ednsQ.parse((char*)&pak[0], pak.size());
 308
 309       pak.clear();
 310     }
 311
 312     DNSPacketWriter::optvect_t opts;
 313     EDNSSubnetOpts ecsOpts;
 314     {
 315       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 316       pw.addOpt(512, 0, 0, DNSPacketWriter::optvect_t(), 42);
 317       pw.commit();
 318       ednsVersion42.parse((char*)&pak[0], pak.size());
 319       pak.clear();
 320     }
 321
 322     {
 323       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 324       pw.addOpt(512, 0, EDNSOpts::DNSSECOK);
 325       pw.commit();
 326       ednsDO.parse((char*)&pak[0], pak.size());
 327       pak.clear();
 328     }
 329
 330     {
 331       ecsOpts.source = Netmask(ComboAddress("192.0.2.1"), 32);
 332       opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts)));
 333       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 334       pw.addOpt(512, 0, 0, opts);
 335       pw.commit();
 336       ecs1.parse((char*)&pak[0], pak.size());
 337       pak.clear();
 338       opts.clear();
 339     }
 340
 341     {
 342       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 343       ecsOpts.source = Netmask(ComboAddress("192.0.2.2"), 32);
 344       opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts)));
 345       pw.addOpt(512, 0, 0, opts);
 346       pw.commit();
 347       ecs2.parse((char*)&pak[0], pak.size());
 348       pak.clear();
 349       opts.clear();
 350     }
 351
 352     {
 353       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 354       ecsOpts.source = Netmask(ComboAddress("192.0.2.3"), 16);
 355       opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts)));
 356       pw.addOpt(512, 0, 0, opts);
 357       pw.commit();
 358       ecs3.parse((char*)&pak[0], pak.size());
 359       pak.clear();
 360       opts.clear();
 361     }
 362
 363     {
 364       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 365       pw.startRecord(DNSName("www.powerdns.com"), QType::A, 16, 1, DNSResourceRecord::ANSWER);
 366       pw.xfrIP(htonl(0x7f000001));
 367       pw.commit();
 368
 369       r.parse((char*)&pak[0], pak.size());
 370     }
 371
 372     /* this call is required so the correct hash is set into q->d_hash */
 373     BOOST_CHECK_EQUAL(PC.get(&q, &r2), false);
 374
 375     PC.insert(&q, &r, 3600);
 376     BOOST_CHECK_EQUAL(PC.size(), 1);
 377
 378     BOOST_CHECK_EQUAL(PC.get(&q, &r2), true);
 379     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 380
 381     /* different QID, still should match */
 382     BOOST_CHECK_EQUAL(PC.get(&differentIDQ, &r2), true);
 383     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 384
 385     /* with EDNS, should not match */
 386     BOOST_CHECK_EQUAL(PC.get(&ednsQ, &r2), false);
 387     /* inserting the EDNS-enabled one too */
 388     PC.insert(&ednsQ, &r, 3600);
 389     BOOST_CHECK_EQUAL(PC.size(), 2);
 390
 391     /* different EDNS versions, should not match */
 392     BOOST_CHECK_EQUAL(PC.get(&ednsVersion42, &r2), false);
 393
 394     /* EDNS DO set, should not match */
 395     BOOST_CHECK_EQUAL(PC.get(&ednsDO, &r2), false);
 396
 397     /* EDNS Client Subnet set, should not match
 398        since not only we don't skip the actual option, but the
 399        total EDNS opt RR is still different. */
 400     BOOST_CHECK_EQUAL(PC.get(&ecs1, &r2), false);
 401
 402     /* inserting the version with ECS Client Subnet set,
 403      it should NOT replace the existing EDNS one. */
 404     PC.insert(&ecs1, &r, 3600);
 405     BOOST_CHECK_EQUAL(PC.size(), 3);
 406
 407     /* different subnet of same size, should NOT match
 408      since we don't skip the option */
 409     BOOST_CHECK_EQUAL(PC.get(&ecs2, &r2), false);
 410     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 411
 412     /* different subnet of different size, should NOT match. */
 413     BOOST_CHECK_EQUAL(PC.get(&ecs3, &r2), false);
 414
 415     BOOST_CHECK_EQUAL(PC.purge("www.powerdns.com"), 3);
 416     BOOST_CHECK_EQUAL(PC.get(&q, &r2), false);
 417     BOOST_CHECK_EQUAL(PC.size(), 0);
 418
 419     PC.insert(&q, &r, 3600);
 420     BOOST_CHECK_EQUAL(PC.size(), 1);
 421     BOOST_CHECK_EQUAL(PC.get(&q, &r2), true);
 422     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 423     BOOST_CHECK_EQUAL(PC.purge("com$"), 1);
 424     BOOST_CHECK_EQUAL(PC.get(&q, &r2), false);
 425     BOOST_CHECK_EQUAL(PC.size(), 0);
 426
 427     PC.insert(&q, &r, 3600);
 428     BOOST_CHECK_EQUAL(PC.size(), 1);
 429     BOOST_CHECK_EQUAL(PC.get(&q, &r2), true);
 430     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 431     BOOST_CHECK_EQUAL(PC.purge("powerdns.com$"), 1);
 432     BOOST_CHECK_EQUAL(PC.get(&q, &r2), false);
 433     BOOST_CHECK_EQUAL(PC.size(), 0);
 434
 435     PC.insert(&q, &r, 3600);
 436     BOOST_CHECK_EQUAL(PC.size(), 1);
 437     BOOST_CHECK_EQUAL(PC.get(&q, &r2), true);
 438     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 439     BOOST_CHECK_EQUAL(PC.purge("www.powerdns.com$"), 1);
 440     BOOST_CHECK_EQUAL(PC.get(&q, &r2), false);
 441     BOOST_CHECK_EQUAL(PC.size(), 0);
 442
 443     PC.insert(&q, &r, 3600);
 444     BOOST_CHECK_EQUAL(PC.size(), 1);
 445     BOOST_CHECK_EQUAL(PC.purge("www.powerdns.net"), 0);
 446     BOOST_CHECK_EQUAL(PC.get(&q, &r2), true);
 447     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 448     BOOST_CHECK_EQUAL(PC.size(), 1);
 449
 450     BOOST_CHECK_EQUAL(PC.purge("net$"), 0);
 451     BOOST_CHECK_EQUAL(PC.get(&q, &r2), true);
 452     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 453     BOOST_CHECK_EQUAL(PC.size(), 1);
 454
 455     BOOST_CHECK_EQUAL(PC.purge("www.powerdns.com$"), 1);
 456     BOOST_CHECK_EQUAL(PC.size(), 0);
 457   }
 458   catch(PDNSException& e) {
 459     cerr<<"Had error in AuthPacketCache: "<<e.reason<<endl;
 460     throw;
 461   }
 462 }
 463
 464 BOOST_AUTO_TEST_SUITE_END()