pdns/test-dnswriter_cc.cc

   1 #ifndef BOOST_TEST_DYN_LINK
   2 #define BOOST_TEST_DYN_LINK
   3 #endif
   4
   5 #define BOOST_TEST_NO_MAIN
   6
   7 #ifdef HAVE_CONFIG_H
   8 #include "config.h"
   9 #endif
  10
  11 #include <boost/test/unit_test.hpp>
  12 #include <fstream>
  13
  14 #include "dnswriter.hh"
  15 #include "dnsparser.hh"
  16
  17 BOOST_AUTO_TEST_SUITE(test_dnswriter_cc)
  18
  19 BOOST_AUTO_TEST_CASE(test_compressionBool) {
  20   auto testCompressionBool = [](bool compress, size_t size1, size_t size2) {
  21     DNSName name("powerdns.com.");
  22
  23     vector<uint8_t> packet;
  24     DNSPacketWriter pwR(packet, name, QType::A, QClass::IN, 0);
  25     pwR.getHeader()->qr = 1;
  26
  27     pwR.startRecord(DNSName("mediumsizedlabel.example.net"), QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER, compress);
  28     pwR.xfrIP('P'<<24 |
  29               'Q'<<16 |
  30               'R'<<8  |
  31               'S');
  32     pwR.commit();
  33     BOOST_CHECK_EQUAL(pwR.size(), size1);
  34
  35     pwR.startRecord(DNSName("adifferentlabel.example.net"), QType::NS, 3600, QClass::IN, DNSResourceRecord::ANSWER, compress);
  36     pwR.xfrName(DNSName("target.example.net"), true);
  37     pwR.commit();
  38     BOOST_CHECK_EQUAL(pwR.size(), size2);
  39
  40     string spacket(packet.begin(), packet.end());
  41
  42     BOOST_CHECK_NO_THROW(MOADNSParser mdp(false, spacket));
  43   };
  44
  45   testCompressionBool(true, 74, 111);
  46   testCompressionBool(false, 74, 133);
  47 }
  48
  49 BOOST_AUTO_TEST_CASE(test_compressionBoundary) {
  50   DNSName name("powerdns.com.");
  51
  52   vector<uint8_t> packet;
  53   DNSPacketWriter pwR(packet, name, QType::A, QClass::IN, 0);
  54   pwR.getHeader()->qr = 1;
  55
  56   /* record we want to see altered */
  57   pwR.startRecord(name, QType::TXT, 3600, QClass::IN, DNSResourceRecord::ANSWER);
  58   auto txt = string("\"")+string(16262, 'A')+string("\"");
  59   pwR.xfrText(txt);
  60   pwR.commit();
  61   BOOST_CHECK_EQUAL(pwR.size(), 16368U);
  62
  63   pwR.startRecord(DNSName("mediumsizedlabel.example.net"), QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER);
  64   pwR.xfrIP('P'<<24 |
  65             'Q'<<16 |
  66             'R'<<8  |
  67             'S');
  68   pwR.commit();
  69   BOOST_CHECK_EQUAL(pwR.size(), 16412U); // 16412 (0x401c) puts '7example3net' at 0x4001
  70
  71   pwR.startRecord(DNSName("adifferentlabel.example.net"), QType::A, 3600, QClass::IN, DNSResourceRecord::ANSWER);
  72   pwR.xfrIP('D'<<24 |
  73             'E'<<16 |
  74             'F'<<8  |
  75             'G');
  76   pwR.commit();
  77   BOOST_CHECK_EQUAL(pwR.size(), 16455U);
  78
  79   string spacket(packet.begin(), packet.end());
  80
  81   BOOST_CHECK_NO_THROW(MOADNSParser mdp(false, spacket));
  82 }
  83
  84 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_mandatory) {
  85   DNSName name("powerdns.com.");
  86   vector<uint8_t> packet;
  87   DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
  88   pwR.getHeader()->qr = 1;
  89
  90   set<string> keys({"alpn", "ipv6hint"});
  91   set<SvcParam> params({SvcParam(SvcParam::mandatory, std::move(keys))});
  92
  93   pwR.startRecord(name, QType::SVCB);
  94   pwR.commit();
  95   auto start = pwR.getContent().size();
  96
  97   pwR.xfrSvcParamKeyVals(params);
  98   pwR.commit();
  99   auto cit = pwR.getContent().begin();
 100   for (size_t i = 0; i<start; i++)
 101     cit++;
 102
 103   vector<uint8_t> c(cit, pwR.getContent().end());
 104   BOOST_CHECK(c == vector<uint8_t>({0,0,0,4,0,1,0,6}));
 105 }
 106
 107 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_alpn) {
 108   DNSName name("powerdns.com.");
 109   vector<uint8_t> packet;
 110   DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
 111   pwR.getHeader()->qr = 1;
 112
 113   vector<string> alpns({"h2", "h2c", "h3"});
 114   set<SvcParam> params({SvcParam(SvcParam::alpn, std::move(alpns))});
 115
 116   pwR.startRecord(name, QType::SVCB);
 117   pwR.commit();
 118   auto start = pwR.getContent().size();
 119
 120   pwR.xfrSvcParamKeyVals(params);
 121   pwR.commit();
 122   auto cit = pwR.getContent().begin();
 123   for (size_t i = 0; i<start; i++)
 124     cit++;
 125
 126   vector<uint8_t> c(cit, pwR.getContent().end());
 127   BOOST_CHECK(c == vector<uint8_t>({
 128     0,1,0,10,
 129     2,'h','2',
 130     3,'h','2','c',
 131     2,'h','3'}));
 132 }
 133
 134 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_no_default_alpn) {
 135   DNSName name("powerdns.com.");
 136   vector<uint8_t> packet;
 137   DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
 138   pwR.getHeader()->qr = 1;
 139
 140   set<SvcParam> params({SvcParam(SvcParam::no_default_alpn)});
 141
 142   pwR.startRecord(name, QType::SVCB);
 143   pwR.commit();
 144   auto start = pwR.getContent().size();
 145
 146   pwR.xfrSvcParamKeyVals(params);
 147   pwR.commit();
 148   auto cit = pwR.getContent().begin();
 149   for (size_t i = 0; i<start; i++)
 150     cit++;
 151
 152   vector<uint8_t> c(cit, pwR.getContent().end());
 153   BOOST_CHECK(c == vector<uint8_t>({0,2,0,0}));
 154 }
 155
 156 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_port) {
 157   DNSName name("powerdns.com.");
 158   vector<uint8_t> packet;
 159   DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
 160   pwR.getHeader()->qr = 1;
 161
 162   set<SvcParam> params({SvcParam(SvcParam::port, 53)});
 163
 164   pwR.startRecord(name, QType::SVCB);
 165   pwR.commit();
 166   auto start = pwR.getContent().size();
 167
 168   pwR.xfrSvcParamKeyVals(params);
 169   pwR.commit();
 170   auto cit = pwR.getContent().begin();
 171   for (size_t i = 0; i<start; i++)
 172     cit++;
 173
 174   vector<uint8_t> c(cit, pwR.getContent().end());
 175   BOOST_CHECK(c == vector<uint8_t>({0,3,0,2,0,53}));
 176 }
 177
 178 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv4hint) {
 179   DNSName name("powerdns.com.");
 180   vector<uint8_t> packet;
 181   DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
 182   pwR.getHeader()->qr = 1;
 183
 184   vector<ComboAddress> addrs({ComboAddress("192.0.2.1"), ComboAddress("192.0.2.2")});
 185   set<SvcParam> params({SvcParam(SvcParam::ipv4hint, std::move(addrs))});
 186
 187   pwR.startRecord(name, QType::SVCB);
 188   pwR.commit();
 189   auto start = pwR.getContent().size();
 190
 191   pwR.xfrSvcParamKeyVals(params);
 192   pwR.commit();
 193   auto cit = pwR.getContent().begin();
 194   for (size_t i = 0; i<start; i++)
 195     cit++;
 196
 197   vector<uint8_t> c(cit, pwR.getContent().end());
 198   BOOST_CHECK(c == vector<uint8_t>({0,4,0,8,192,0,2,1,192,0,2,2}));
 199 }
 200
 201 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ech) {
 202   DNSName name("powerdns.com.");
 203   vector<uint8_t> packet;
 204   DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
 205   pwR.getHeader()->qr = 1;
 206
 207   set<SvcParam> params({SvcParam(SvcParam::ech, "a very bogus echconfig value")});
 208
 209   pwR.startRecord(name, QType::SVCB);
 210   pwR.commit();
 211   auto start = pwR.getContent().size();
 212
 213   pwR.xfrSvcParamKeyVals(params);
 214   pwR.commit();
 215   auto cit = pwR.getContent().begin();
 216   for (size_t i = 0; i<start; i++)
 217     cit++;
 218
 219   vector<uint8_t> c(cit, pwR.getContent().end());
 220   BOOST_CHECK(c == vector<uint8_t>({0,5,0,28,
 221   'a',' ','v','e','r','y',' ','b','o','g','u','s',' ',
 222   'e','c','h','c','o','n','f','i','g',' ','v','a','l','u','e'
 223   }));
 224 }
 225
 226 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_ipv6hint) {
 227   DNSName name("powerdns.com.");
 228   vector<uint8_t> packet;
 229   DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
 230   pwR.getHeader()->qr = 1;
 231
 232   vector<ComboAddress> addrs({ComboAddress("2001:db8::1"), ComboAddress("2001:db8::2")});
 233   set<SvcParam> params({SvcParam(SvcParam::ipv6hint, std::move(addrs))});
 234
 235   pwR.startRecord(name, QType::SVCB);
 236   pwR.commit();
 237   auto start = pwR.getContent().size();
 238
 239   pwR.xfrSvcParamKeyVals(params);
 240   pwR.commit();
 241   auto cit = pwR.getContent().begin();
 242   for (size_t i = 0; i<start; i++)
 243     cit++;
 244
 245   vector<uint8_t> c(cit, pwR.getContent().end());
 246   BOOST_CHECK(c == vector<uint8_t>({0,6,0,32,
 247   32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,1,
 248   32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,2}));
 249 }
 250
 251 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_generic) {
 252   DNSName name("powerdns.com.");
 253   vector<uint8_t> packet;
 254   DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
 255   pwR.getHeader()->qr = 1;
 256
 257   set<SvcParam> params({SvcParam(SvcParam::keyFromString("key666"), "mycoolvalue")});
 258
 259   pwR.startRecord(name, QType::SVCB);
 260   pwR.commit();
 261   auto start = pwR.getContent().size();
 262
 263   pwR.xfrSvcParamKeyVals(params);
 264   pwR.commit();
 265   auto cit = pwR.getContent().begin();
 266   for (size_t i = 0; i<start; i++)
 267     cit++;
 268
 269   vector<uint8_t> c(cit, pwR.getContent().end());
 270   BOOST_CHECK(c == vector<uint8_t>({2,154,0,11,
 271   'm','y','c','o','o','l','v','a','l','u','e'
 272   }));
 273 }
 274
 275 BOOST_AUTO_TEST_CASE(test_xfrSvcParamKeyVals_multiple) {
 276   DNSName name("powerdns.com.");
 277   vector<uint8_t> packet;
 278   DNSPacketWriter pwR(packet, name, QType::SVCB, QClass::IN, 0);
 279   pwR.getHeader()->qr = 1;
 280
 281   vector<ComboAddress> addrs({ComboAddress("2001:db8::1"), ComboAddress("2001:db8::2")});
 282   vector<string> alpns({"h2", "h2c", "h3"});
 283   set<SvcParam> params({SvcParam(SvcParam::alpn, std::move(alpns)), SvcParam(SvcParam::ipv6hint, std::move(addrs)), SvcParam(SvcParam::port, 53)});
 284
 285   pwR.startRecord(name, QType::SVCB);
 286   pwR.commit();
 287   auto start = pwR.getContent().size();
 288
 289   pwR.xfrSvcParamKeyVals(params);
 290   pwR.commit();
 291   auto cit = pwR.getContent().begin();
 292   for (size_t i = 0; i<start; i++)
 293     cit++;
 294
 295   vector<uint8_t> c(cit, pwR.getContent().end());
 296   BOOST_CHECK(c == vector<uint8_t>({
 297   0,1,0,10,2,'h','2',3,'h','2','c',2,'h','3',  // alpn
 298   0,3,0,2,0,53,                                // port
 299   0,6,0,32,                                    // ipv6
 300   32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,1,
 301   32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,2}));
 302 }
 303
 304 BOOST_AUTO_TEST_CASE(test_NodeOrLocatorID) {
 305   DNSName name("powerdns.com.");
 306   vector<uint8_t> packet;
 307
 308   NodeOrLocatorID in = {0, 0, 0, 0, 0, 0, 0, 1};
 309
 310   DNSPacketWriter writer(packet, name, QType::NID, QClass::IN, 0);
 311   writer.getHeader()->qr = 1;
 312
 313   writer.startRecord(name, QType::NID);
 314   writer.commit();
 315   auto start = writer.getContent().size();
 316
 317   writer.xfrNodeOrLocatorID(in);
 318   writer.commit();
 319   auto cit = writer.getContent().begin();
 320   for (size_t i = 0; i<start; i++)
 321     cit++;
 322
 323   vector<uint8_t> c(cit, writer.getContent().end());
 324   BOOST_CHECK(c == vector<uint8_t>({
 325     0, 0, 0, 0,
 326     0, 0, 0, 1}));
 327 }
 328
 329 BOOST_AUTO_TEST_SUITE_END()