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     g_QCmissing = 0;
 108     AuthQueryCache QC;
 109     QC.setMaxEntries(1000000);
 110     g_QC=&QC;
 111     pthread_t tid[4];
 112     for(int i=0; i < 4; ++i)
 113       pthread_create(&tid[i], 0, threadQCMangler, (void*)(i*1000000UL));
 114     void* res;
 115     for(int i=0; i < 4 ; ++i)
 116       pthread_join(tid[i], &res);
 117
 118     BOOST_CHECK_EQUAL(QC.size() + S.read("deferred-cache-inserts"), 400000);
 119     BOOST_CHECK_SMALL(1.0*S.read("deferred-cache-inserts"), 10000.0);
 120
 121     for(int i=0; i < 4; ++i)
 122       pthread_create(&tid[i], 0, threadQCReader, (void*)(i*1000000UL));
 123     for(int i=0; i < 4 ; ++i)
 124       pthread_join(tid[i], &res);
 125
 126     BOOST_CHECK(S.read("deferred-cache-inserts") + S.read("deferred-cache-lookup") >= g_QCmissing);
 127     //    BOOST_CHECK_EQUAL(S.read("deferred-cache-lookup"), 0); // cache cleaning invalidates this
 128   }
 129   catch(PDNSException& e) {
 130     cerr<<"Had error: "<<e.reason<<endl;
 131     throw;
 132   }
 133
 134 }
 135
 136 static AuthPacketCache* g_PC;
 137 static AtomicCounter g_PCmissing;
 138
 139 static void *threadPCMangler(void* a)
 140 try
 141 {
 142   unsigned int offset=(unsigned int)(unsigned long)a;
 143   for(unsigned int counter=0; counter < 100000; ++counter) {
 144     vector<uint8_t> pak;
 145     DNSName qname = DNSName("hello ")+DNSName(std::to_string(counter+offset));
 146
 147     DNSPacketWriter pw(pak, qname, QType::A);
 148     DNSPacket q(true);
 149     q.parse((char*)&pak[0], pak.size());
 150
 151     pak.clear();
 152     DNSPacketWriter pw2(pak, qname, QType::A);
 153     pw2.startRecord(qname, QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER);
 154     pw2.xfrIP(htonl(0x7f000001));
 155     pw2.commit();
 156
 157     DNSPacket r(false);
 158     r.parse((char*)&pak[0], pak.size());
 159
 160     /* this step is necessary to get a valid hash
 161        we directly compute the hash instead of querying the
 162        cache because 1/ it's faster 2/ no deferred-lookup issues
 163     */
 164     q.setHash(g_PC->canHashPacket(q.getString()));
 165
 166     const unsigned int maxTTL = 3600;
 167     g_PC->insert(&q, &r, maxTTL);
 168   }
 169
 170   return 0;
 171 }
 172  catch(PDNSException& e) {
 173    cerr<<"Had error: "<<e.reason<<endl;
 174    throw;
 175  }
 176
 177 static void *threadPCReader(void* a)
 178 try
 179 {
 180   unsigned int offset=(unsigned int)(unsigned long)a;
 181   vector<DNSZoneRecord> entry;
 182   for(unsigned int counter=0; counter < 100000; ++counter) {
 183     vector<uint8_t> pak;
 184     DNSName qname = DNSName("hello ")+DNSName(std::to_string(counter+offset));
 185
 186     DNSPacketWriter pw(pak, qname, QType::A);
 187     DNSPacket q(true);
 188     q.parse((char*)&pak[0], pak.size());
 189     DNSPacket r(false);
 190
 191     if(!g_PC->get(&q, &r)) {
 192       g_PCmissing++;
 193     }
 194   }
 195
 196   return 0;
 197 }
 198 catch(PDNSException& e) {
 199   cerr<<"Had error in threadPCReader: "<<e.reason<<endl;
 200   throw;
 201 }
 202
 203 BOOST_AUTO_TEST_CASE(test_PacketCacheThreaded) {
 204   try {
 205     AuthPacketCache PC;
 206     PC.setMaxEntries(1000000);
 207     PC.setTTL(3600);
 208
 209     g_PC=&PC;
 210     g_PCmissing = 0;
 211     pthread_t tid[4];
 212     for(int i=0; i < 4; ++i)
 213       pthread_create(&tid[i], 0, threadPCMangler, (void*)(i*1000000UL));
 214     void* res;
 215     for(int i=0; i < 4 ; ++i)
 216       pthread_join(tid[i], &res);
 217
 218     BOOST_CHECK_EQUAL(PC.size() + S.read("deferred-packetcache-inserts"), 400000);
 219     BOOST_CHECK_EQUAL(S.read("deferred-packetcache-lookup"), 0);
 220     BOOST_CHECK_SMALL(1.0*S.read("deferred-packetcache-inserts"), 10000.0);
 221
 222     for(int i=0; i < 4; ++i)
 223       pthread_create(&tid[i], 0, threadPCReader, (void*)(i*1000000UL));
 224     for(int i=0; i < 4 ; ++i)
 225       pthread_join(tid[i], &res);
 226
 227 /*
 228     cerr<<"Misses: "<<S.read("packetcache-miss")<<endl;
 229     cerr<<"Hits: "<<S.read("packetcache-hit")<<endl;
 230     cerr<<"Deferred inserts: "<<S.read("deferred-packetcache-inserts")<<endl;
 231     cerr<<"Deferred lookups: "<<S.read("deferred-packetcache-lookup")<<endl;
 232     cerr<<g_PCmissing<<endl;
 233     cerr<<PC.size()<<endl;
 234 */
 235
 236     BOOST_CHECK_EQUAL(g_PCmissing + S.read("packetcache-hit"), 400000);
 237     BOOST_CHECK_EQUAL(S.read("deferred-packetcache-inserts") + S.read("deferred-packetcache-lookup"), g_PCmissing);
 238   }
 239   catch(PDNSException& e) {
 240     cerr<<"Had error: "<<e.reason<<endl;
 241     throw;
 242   }
 243
 244 }
 245
 246 bool g_stopCleaning;
 247 static void *cacheCleaner(void*)
 248 try
 249 {
 250   while(!g_stopCleaning) {
 251     g_QC->cleanup();
 252   }
 253
 254   return 0;
 255 }
 256 catch(PDNSException& e) {
 257   cerr<<"Had error in cacheCleaner: "<<e.reason<<endl;
 258   throw;
 259 }
 260
 261 BOOST_AUTO_TEST_CASE(test_QueryCacheClean) {
 262   try {
 263     AuthQueryCache QC;
 264     QC.setMaxEntries(10000);
 265     vector<DNSZoneRecord> records;
 266
 267     for(unsigned int counter = 0; counter < 1000000; ++counter) {
 268       QC.insert(DNSName("hello ")+DNSName(std::to_string(counter)), QType(QType::A), records, 1, 1);
 269     }
 270
 271     sleep(1);
 272
 273     g_QC=&QC;
 274     pthread_t tid[4];
 275
 276     pthread_create(&tid[0], 0, threadQCReader, (void*)(0*1000000UL));
 277     pthread_create(&tid[1], 0, threadQCReader, (void*)(1*1000000UL));
 278     pthread_create(&tid[2], 0, threadQCReader, (void*)(2*1000000UL));
 279     //    pthread_create(&tid[2], 0, threadMangler, (void*)(0*1000000UL));
 280     pthread_create(&tid[3], 0, cacheCleaner, 0);
 281
 282     void *res;
 283     for(int i=0; i < 3 ; ++i)
 284       pthread_join(tid[i], &res);
 285     g_stopCleaning=true;
 286     pthread_join(tid[3], &res);
 287   }
 288   catch(PDNSException& e) {
 289     cerr<<"Had error in test_QueryCacheClean: "<<e.reason<<endl;
 290     throw;
 291   }
 292 }
 293
 294 BOOST_AUTO_TEST_CASE(test_AuthPacketCache) {
 295   try {
 296     ::arg().setSwitch("no-shuffle","Set this to prevent random shuffling of answers - for regression testing")="off";
 297
 298     AuthPacketCache PC;
 299     PC.setTTL(20);
 300     PC.setMaxEntries(100000);
 301
 302     vector<uint8_t> pak;
 303     DNSPacket q(true), differentIDQ(true), ednsQ(true), ednsVersion42(true), ednsDO(true), ecs1(true), ecs2(true), ecs3(true);
 304     DNSPacket r(false), r2(false);
 305
 306     {
 307       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 308       q.parse((char*)&pak[0], pak.size());
 309
 310       differentIDQ.parse((char*)&pak[0], pak.size());
 311       differentIDQ.setID(4242);
 312
 313       pw.addOpt(512, 0, 0);
 314       pw.commit();
 315       ednsQ.parse((char*)&pak[0], pak.size());
 316
 317       pak.clear();
 318     }
 319
 320     DNSPacketWriter::optvect_t opts;
 321     EDNSSubnetOpts ecsOpts;
 322     {
 323       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 324       pw.addOpt(512, 0, 0, DNSPacketWriter::optvect_t(), 42);
 325       pw.commit();
 326       ednsVersion42.parse((char*)&pak[0], pak.size());
 327       pak.clear();
 328     }
 329
 330     {
 331       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 332       pw.addOpt(512, 0, EDNSOpts::DNSSECOK);
 333       pw.commit();
 334       ednsDO.parse((char*)&pak[0], pak.size());
 335       pak.clear();
 336     }
 337
 338     {
 339       ecsOpts.source = Netmask(ComboAddress("192.0.2.1"), 32);
 340       opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts)));
 341       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 342       pw.addOpt(512, 0, 0, opts);
 343       pw.commit();
 344       ecs1.parse((char*)&pak[0], pak.size());
 345       pak.clear();
 346       opts.clear();
 347     }
 348
 349     {
 350       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 351       ecsOpts.source = Netmask(ComboAddress("192.0.2.2"), 32);
 352       opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts)));
 353       pw.addOpt(512, 0, 0, opts);
 354       pw.commit();
 355       ecs2.parse((char*)&pak[0], pak.size());
 356       pak.clear();
 357       opts.clear();
 358     }
 359
 360     {
 361       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 362       ecsOpts.source = Netmask(ComboAddress("192.0.2.3"), 16);
 363       opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts)));
 364       pw.addOpt(512, 0, 0, opts);
 365       pw.commit();
 366       ecs3.parse((char*)&pak[0], pak.size());
 367       pak.clear();
 368       opts.clear();
 369     }
 370
 371     {
 372       DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
 373       pw.startRecord(DNSName("www.powerdns.com"), QType::A, 16, 1, DNSResourceRecord::ANSWER);
 374       pw.xfrIP(htonl(0x7f000001));
 375       pw.commit();
 376
 377       r.parse((char*)&pak[0], pak.size());
 378     }
 379
 380     /* this call is required so the correct hash is set into q->d_hash */
 381     BOOST_CHECK_EQUAL(PC.get(&q, &r2), false);
 382
 383     PC.insert(&q, &r, 3600);
 384     BOOST_CHECK_EQUAL(PC.size(), 1);
 385
 386     BOOST_CHECK_EQUAL(PC.get(&q, &r2), true);
 387     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 388
 389     /* different QID, still should match */
 390     BOOST_CHECK_EQUAL(PC.get(&differentIDQ, &r2), true);
 391     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 392
 393     /* with EDNS, should not match */
 394     BOOST_CHECK_EQUAL(PC.get(&ednsQ, &r2), false);
 395     /* inserting the EDNS-enabled one too */
 396     PC.insert(&ednsQ, &r, 3600);
 397     BOOST_CHECK_EQUAL(PC.size(), 2);
 398
 399     /* different EDNS versions, should not match */
 400     BOOST_CHECK_EQUAL(PC.get(&ednsVersion42, &r2), false);
 401
 402     /* EDNS DO set, should not match */
 403     BOOST_CHECK_EQUAL(PC.get(&ednsDO, &r2), false);
 404
 405     /* EDNS Client Subnet set, should not match
 406        since not only we don't skip the actual option, but the
 407        total EDNS opt RR is still different. */
 408     BOOST_CHECK_EQUAL(PC.get(&ecs1, &r2), false);
 409
 410     /* inserting the version with ECS Client Subnet set,
 411      it should NOT replace the existing EDNS one. */
 412     PC.insert(&ecs1, &r, 3600);
 413     BOOST_CHECK_EQUAL(PC.size(), 3);
 414
 415     /* different subnet of same size, should NOT match
 416      since we don't skip the option */
 417     BOOST_CHECK_EQUAL(PC.get(&ecs2, &r2), false);
 418     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 419
 420     /* different subnet of different size, should NOT match. */
 421     BOOST_CHECK_EQUAL(PC.get(&ecs3, &r2), false);
 422
 423     BOOST_CHECK_EQUAL(PC.purge("www.powerdns.com"), 3);
 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("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("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.get(&q, &r2), true);
 446     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 447     BOOST_CHECK_EQUAL(PC.purge("www.powerdns.com$"), 1);
 448     BOOST_CHECK_EQUAL(PC.get(&q, &r2), false);
 449     BOOST_CHECK_EQUAL(PC.size(), 0);
 450
 451     PC.insert(&q, &r, 3600);
 452     BOOST_CHECK_EQUAL(PC.size(), 1);
 453     BOOST_CHECK_EQUAL(PC.purge("www.powerdns.net"), 0);
 454     BOOST_CHECK_EQUAL(PC.get(&q, &r2), true);
 455     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 456     BOOST_CHECK_EQUAL(PC.size(), 1);
 457
 458     BOOST_CHECK_EQUAL(PC.purge("net$"), 0);
 459     BOOST_CHECK_EQUAL(PC.get(&q, &r2), true);
 460     BOOST_CHECK_EQUAL(r2.qdomain, r.qdomain);
 461     BOOST_CHECK_EQUAL(PC.size(), 1);
 462
 463     BOOST_CHECK_EQUAL(PC.purge("www.powerdns.com$"), 1);
 464     BOOST_CHECK_EQUAL(PC.size(), 0);
 465   }
 466   catch(PDNSException& e) {
 467     cerr<<"Had error in AuthPacketCache: "<<e.reason<<endl;
 468     throw;
 469   }
 470 }
 471
 472 BOOST_AUTO_TEST_SUITE_END()