6671102387

Committed 27 Oct 2023 06:57PM CUT coverage: 56.33% (-1.2%) from 57.482%

Build # 6671102387

Build Type

Pull #13226

github

Committed by

web-flow

Commit Message

Merge 1c1bd17ff into f8c2901a6

Pull Request Pull Request #13226: Cleanup `ueberbackend.cc` a bit

Run Details

30307 of 84938 branches covered (0.0%)

Branch coverage included in aggregate %.

198 of 250 new or added lines in 1 file covered. (79.2%)

2290 existing lines in 48 files now uncovered.

103604 of 152789 relevant lines covered (67.81%)

2444444.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.92

/pdns/dnswriter.cc

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <boost/version.hpp>
#if BOOST_VERSION >= 105400
#include <boost/container/static_vector.hpp>
#endif
#include "dnswriter.hh"
#include "misc.hh"
#include "dnsparser.hh"

#include <limits.h>

/* d_content:                                      <---- d_stuff ---->
                                      v d_truncatemarker
   dnsheader | qname | qtype | qclass | {recordname| dnsrecordheader | record }
                                        ^ d_rollbackmarker           ^ d_sor


*/


template <typename Container> GenericDNSPacketWriter<Container>::GenericDNSPacketWriter(Container& content, const DNSName& qname, uint16_t  qtype, uint16_t qclass, uint8_t opcode)
  : d_content(content), d_qname(qname), d_canonic(false), d_lowerCase(false)
{
  d_content.clear();
  dnsheader dnsheader;

  memset(&dnsheader, 0, sizeof(dnsheader));
  dnsheader.id=0;
  dnsheader.qdcount=htons(1);
  dnsheader.opcode=opcode;

  const uint8_t* ptr=(const uint8_t*)&dnsheader;
  d_content.reserve(sizeof(dnsheader) + qname.wirelength() + sizeof(qtype) + sizeof(qclass));
  d_content.resize(sizeof(dnsheader));
  uint8_t* dptr=(&*d_content.begin());

  memcpy(dptr, ptr, sizeof(dnsheader));
  d_namepositions.reserve(16);
  xfrName(qname, false);
  xfr16BitInt(qtype);
  xfr16BitInt(qclass);

  d_truncatemarker=d_content.size();
  d_sor = 0;
  d_rollbackmarker = 0;
}

template <typename Container> dnsheader* GenericDNSPacketWriter<Container>::getHeader()
{
  return reinterpret_cast<dnsheader*>(&*d_content.begin());
}


template <typename Container> void GenericDNSPacketWriter<Container>::startRecord(const DNSName& name, uint16_t qtype, uint32_t ttl, uint16_t qclass, DNSResourceRecord::Place place, bool compress)
{
  d_compress = compress;
  commit();
  d_rollbackmarker=d_content.size();

  if(compress && !name.isRoot() && d_qname==name) {  // don't do the whole label compression thing if we *know* we can get away with "see question" - except when compressing the root
    static unsigned char marker[2]={0xc0, 0x0c};
    d_content.insert(d_content.end(), (const char *) &marker[0], (const char *) &marker[2]);
  }
  else {
    xfrName(name, compress);
  }
  xfr16BitInt(qtype);
  xfr16BitInt(qclass);
  xfr32BitInt(ttl);
  xfr16BitInt(0); // this will be the record size
  d_recordplace = place;
  d_sor=d_content.size(); // this will remind us where to stuff the record size
}

template <typename Container> void GenericDNSPacketWriter<Container>::addOpt(const uint16_t udpsize, const uint16_t extRCode, const uint16_t ednsFlags, const optvect_t& options, const uint8_t version)
{
  uint32_t ttl=0;

  EDNS0Record stuff;

  stuff.version = version;
  stuff.extFlags = htons(ednsFlags);

  /* RFC 6891 section 4 on the Extended RCode wire format
   *    EXTENDED-RCODE
   *        Forms the upper 8 bits of extended 12-bit RCODE (together with the
   *        4 bits defined in [RFC1035].  Note that EXTENDED-RCODE value 0
   *        indicates that an unextended RCODE is in use (values 0 through 15).
   */
  // XXX Should be check for extRCode > 1<<12 ?
  stuff.extRCode = extRCode>>4;
  if (extRCode != 0) { // As this trumps the existing RCODE
    getHeader()->rcode = extRCode;
  }

  static_assert(sizeof(EDNS0Record) == sizeof(ttl), "sizeof(EDNS0Record) must match sizeof(ttl)");
  memcpy(&ttl, &stuff, sizeof(stuff));

  ttl=ntohl(ttl); // will be reversed later on

  startRecord(g_rootdnsname, QType::OPT, ttl, udpsize, DNSResourceRecord::ADDITIONAL, false);
  for(auto const &option : options) {
    xfr16BitInt(option.first);
    xfr16BitInt(option.second.length());
    xfrBlob(option.second);
  }
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfr48BitInt(uint64_t val)
{
  std::array<unsigned char, 6> bytes;
  uint16_t theLeft = htons((val >> 32)&0xffffU);
  uint32_t theRight = htonl(val & 0xffffffffU);
  memcpy(&bytes[0], (void*)&theLeft, sizeof(theLeft));
  memcpy(&bytes[2], (void*)&theRight, sizeof(theRight));

  d_content.insert(d_content.end(), bytes.begin(), bytes.end());
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfrNodeOrLocatorID(const NodeOrLocatorID& val)
{
  d_content.insert(d_content.end(), val.content, val.content + sizeof(val.content));
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfr32BitInt(uint32_t val)
{
  uint32_t rval=htonl(val);
  uint8_t* ptr=reinterpret_cast<uint8_t*>(&rval);
  d_content.insert(d_content.end(), ptr, ptr+4);
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfr16BitInt(uint16_t val)
{
  uint16_t rval=htons(val);
  uint8_t* ptr=reinterpret_cast<uint8_t*>(&rval);
  d_content.insert(d_content.end(), ptr, ptr+2);
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfr8BitInt(uint8_t val)
{
  d_content.push_back(val);
}


/* input:
 if lenField is true
  "" -> 0
  "blah" -> 4blah
  "blah" "blah" -> output 4blah4blah
  "verylongstringlongerthan256....characters" \xffverylongstring\x23characters (autosplit)
  "blah\"blah" -> 9blah"blah
  "blah\97" -> 5blahb

 if lenField is false
  "blah" -> blah
  "blah\"blah" -> blah"blah
  */
template <typename Container> void GenericDNSPacketWriter<Container>::xfrText(const string& text, bool, bool lenField)
{
  if(text.empty()) {
    d_content.push_back(0);
    return;
  }
  vector<string> segments = segmentDNSText(text);
  for(const string& str :  segments) {
    if(lenField)
      d_content.push_back(str.length());
    d_content.insert(d_content.end(), str.c_str(), str.c_str() + str.length());
  }
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfrUnquotedText(const string& text, bool lenField)
{
  if(text.empty()) {
    d_content.push_back(0);
    return;
  }
  if(lenField)
    d_content.push_back(text.length());
  d_content.insert(d_content.end(), text.c_str(), text.c_str() + text.length());
}


static constexpr bool l_verbose=false;
static constexpr uint16_t maxCompressionOffset=16384;
template <typename Container> uint16_t GenericDNSPacketWriter<Container>::lookupName(const DNSName& name, uint16_t* matchLen)
{
  // iterate over the written labels, see if we find a match
  const auto& raw = name.getStorage();

  /* name might be a.root-servers.net, we need to be able to benefit from finding:
     b.root-servers.net, or even:
     b\xc0\x0c
  */
  unsigned int bestpos=0;
  *matchLen=0;
#if BOOST_VERSION >= 105400
  boost::container::static_vector<uint16_t, 34> nvect, pvect;
#else
  vector<uint16_t> nvect, pvect;
#endif

  try {
    for(auto riter= raw.cbegin(); riter < raw.cend(); ) {
      if(!*riter)
        break;
      nvect.push_back(riter - raw.cbegin());
      riter+=*riter+1;
    }
  }
  catch(std::bad_alloc& ba) {
    if(l_verbose)
      cout<<"Domain "<<name<<" too large to compress"<<endl;
    return 0;
  }

  if(l_verbose) {
    cout<<"Input vector for lookup "<<name<<": ";
    for(const auto n : nvect)
      cout << n<<" ";
    cout<<endl;
    cout<<makeHexDump(string(raw.c_str(), raw.c_str()+raw.size()))<<endl;
  }

  if(l_verbose)
    cout<<"Have "<<d_namepositions.size()<<" to ponder"<<endl;
  int counter=1;
  for(auto p : d_namepositions) {
    if(l_verbose) {
      cout<<"Pos: "<<p<<", "<<d_content.size()<<endl;
      DNSName pname((const char*)&d_content[0], d_content.size(), p, true); // only for debugging
      cout<<"Looking at '"<<pname<<"' in packet at position "<<p<<"/"<<d_content.size()<<", option "<<counter<<"/"<<d_namepositions.size()<<endl;
      ++counter;
    }
    // memcmp here makes things _slower_
    pvect.clear();
    try {
      for(auto iter = d_content.cbegin() + p; iter < d_content.cend();) {
        uint8_t c=*iter;
        if(l_verbose)
          cout<<"Found label length: "<<(int)c<<endl;
        if(c & 0xc0) {
          uint16_t npos = 0x100*(c & (~0xc0)) + *++iter;
          iter = d_content.begin() + npos;
          if(l_verbose)
            cout<<"Is compressed label to newpos "<<npos<<", going there"<<endl;
          // check against going forward here
          continue;
        }
        if(!c)
          break;
        auto offset = iter - d_content.cbegin();
        if (offset >= maxCompressionOffset) break; // compression pointers cannot point here
        pvect.push_back(offset);
        iter+=*iter+1;
      }
    }
    catch(std::bad_alloc& ba) {
      if(l_verbose)
        cout<<"Domain "<<name<<" too large to compress"<<endl;
      continue;
    }
    if(l_verbose) {
      cout<<"Packet vector: "<<endl;
      for(const auto n : pvect)
        cout << n<<" ";
      cout<<endl;
    }
    auto niter=nvect.crbegin(), piter=pvect.crbegin();
    unsigned int cmatchlen=1;
    for(; niter != nvect.crend() && piter != pvect.crend(); ++niter, ++piter) {
      // niter is an offset in raw, pvect an offset in packet
      uint8_t nlen = raw[*niter], plen=d_content[*piter];
      if(l_verbose)
        cout<<"nlnen="<<(int)nlen<<", plen="<<(int)plen<<endl;
      if(nlen != plen)
        break;
      if(strncasecmp(raw.c_str()+*niter+1, (const char*)&d_content[*piter]+1, nlen)) {
        if(l_verbose)
          cout<<"Mismatch: "<<string(raw.c_str()+*niter+1, raw.c_str()+*niter+nlen+1)<< " != "<<string((const char*)&d_content[*piter]+1, (const char*)&d_content[*piter]+nlen+1)<<endl;
        break;
      }
      cmatchlen+=nlen+1;
      if(cmatchlen == raw.length()) { // have matched all of it, can't improve
        if(l_verbose)
          cout<<"Stopping search, matched whole name"<<endl;
        *matchLen = cmatchlen;
        return *piter;
      }
    }
    if(piter != pvect.crbegin() && *matchLen < cmatchlen) {
      *matchLen = cmatchlen;
      bestpos=*--piter;
    }
  }
  return bestpos;
}
// this is the absolute hottest function in the pdns recursor
template <typename Container> void GenericDNSPacketWriter<Container>::xfrName(const DNSName& name, bool compress, bool)
{
  if(l_verbose)
    cout<<"Wants to write "<<name<<", compress="<<compress<<", canonic="<<d_canonic<<", LC="<<d_lowerCase<<endl;
  if(d_canonic || d_lowerCase)   // d_lowerCase implies canonic
    compress=false;

  if(name.empty() || name.isRoot()) { // for speed
    d_content.push_back(0);
    return;
  }

  uint16_t li=0;
  uint16_t matchlen=0;
  if(d_compress && compress && (li=lookupName(name, &matchlen)) && li < maxCompressionOffset) {
    const auto& dns=name.getStorage();
    if(l_verbose)
      cout<<"Found a substring of "<<matchlen<<" bytes from the back, offset: "<<li<<", dnslen: "<<dns.size()<<endl;
    // found a substring, if www.powerdns.com matched powerdns.com, we get back matchlen = 13

    unsigned int pos=d_content.size();
    if(pos < maxCompressionOffset && matchlen != dns.size()) {
      if(l_verbose)
        cout<<"Inserting pos "<<pos<<" for "<<name<<" for compressed case"<<endl;
      d_namepositions.push_back(pos);
    }

    if(l_verbose)
      cout<<"Going to write unique part: '"<<makeHexDump(string(dns.c_str(), dns.c_str() + dns.size() - matchlen)) <<"'"<<endl;
    d_content.insert(d_content.end(), (const unsigned char*)dns.c_str(), (const unsigned char*)dns.c_str() + dns.size() - matchlen);
    uint16_t offset=li;
    offset|=0xc000;

    d_content.push_back((char)(offset >> 8));
    d_content.push_back((char)(offset & 0xff));
  }
  else {
    unsigned int pos=d_content.size();
    if(l_verbose)
      cout<<"Found nothing, we are at pos "<<pos<<", inserting whole name"<<endl;
    if(pos < maxCompressionOffset) {
      if(l_verbose)
        cout<<"Inserting pos "<<pos<<" for "<<name<<" for uncompressed case"<<endl;
      d_namepositions.push_back(pos);
    }

    std::unique_ptr<DNSName> lc;
    if(d_lowerCase)
      lc = make_unique<DNSName>(name.makeLowerCase());

    const DNSName::string_t& raw = (lc ? *lc : name).getStorage();
    if(l_verbose)
      cout<<"Writing out the whole thing "<<makeHexDump(string(raw.c_str(),  raw.c_str() + raw.length()))<<endl;
    d_content.insert(d_content.end(), raw.c_str(), raw.c_str() + raw.size());
  }
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfrBlob(const string& blob, int  )
{
  const uint8_t* ptr=reinterpret_cast<const uint8_t*>(blob.c_str());
  d_content.insert(d_content.end(), ptr, ptr+blob.size());
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfrBlob(const std::vector<uint8_t>& blob)
{
  d_content.insert(d_content.end(), blob.begin(), blob.end());
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfrBlobNoSpaces(const string& blob, int  )
{
  xfrBlob(blob);
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfrHexBlob(const string& blob, bool /* keepReading */)
{
  xfrBlob(blob);
}

template <typename Container> void GenericDNSPacketWriter<Container>::xfrSvcParamKeyVals(const std::set<SvcParam> &kvs)
{
  for (auto const &param : kvs) {
    // Key first!
    xfr16BitInt(param.getKey());

    switch (param.getKey())
    {
    case SvcParam::mandatory:
      xfr16BitInt(2 * param.getMandatory().size());
      for (auto const &m: param.getMandatory()) {
        xfr16BitInt(m);
      }
      break;
    case SvcParam::alpn:
    {
      uint16_t totalSize = param.getALPN().size(); // All 1 octet size headers for each value
      for (auto const &a : param.getALPN()) {
        totalSize += a.length();
      }
      xfr16BitInt(totalSize);
      for (auto const &a : param.getALPN()) {
        xfrUnquotedText(a, true); // will add the 1-byte length field
      }
      break;
    }
    case SvcParam::no_default_alpn:
      xfr16BitInt(0); // no size :)
      break;
    case SvcParam::port:
      xfr16BitInt(2); // size
      xfr16BitInt(param.getPort());
      break;
    case SvcParam::ipv4hint:
      xfr16BitInt(param.getIPHints().size() * 4); // size
      for (const auto& a: param.getIPHints()) {
        xfrCAWithoutPort(param.getKey(), a);
      }
      break;
    case SvcParam::ipv6hint:
      xfr16BitInt(param.getIPHints().size() * 16); // size
      for (const auto& a: param.getIPHints()) {
        xfrCAWithoutPort(param.getKey(), a);
      }
      break;
    case SvcParam::ech:
      xfr16BitInt(param.getECH().size()); // size
      xfrBlobNoSpaces(param.getECH());
      break;
    default:
      xfr16BitInt(param.getValue().size());
      xfrBlob(param.getValue());
      break;
    }
  }
}

// call __before commit__
template <typename Container> void GenericDNSPacketWriter<Container>::getRecordPayload(string& records)
{
  records.assign(d_content.begin() + d_sor, d_content.end());
}

template <typename Container> uint32_t GenericDNSPacketWriter<Container>::size() const
{
  return d_content.size();
}

template <typename Container> void GenericDNSPacketWriter<Container>::rollback()
{
  d_content.resize(d_rollbackmarker);
  d_sor = 0;
}

template <typename Container> void GenericDNSPacketWriter<Container>::truncate()
{
  d_content.resize(d_truncatemarker);
  dnsheader* dh=reinterpret_cast<dnsheader*>( &*d_content.begin());
  dh->ancount = dh->nscount = dh->arcount = 0;
}

template <typename Container> void GenericDNSPacketWriter<Container>::commit()
{
  if(!d_sor)
    return;
  uint16_t rlen = d_content.size() - d_sor;
  d_content[d_sor-2]=rlen >> 8;
  d_content[d_sor-1]=rlen & 0xff;
  d_sor=0;
  dnsheader* dh=reinterpret_cast<dnsheader*>( &*d_content.begin());
  switch(d_recordplace) {
  case DNSResourceRecord::QUESTION:
    dh->qdcount = htons(ntohs(dh->qdcount) + 1);
    break;
  case DNSResourceRecord::ANSWER:
    dh->ancount = htons(ntohs(dh->ancount) + 1);
    break;
  case DNSResourceRecord::AUTHORITY:
    dh->nscount = htons(ntohs(dh->nscount) + 1);
    break;
  case DNSResourceRecord::ADDITIONAL:
    dh->arcount = htons(ntohs(dh->arcount) + 1);
    break;
  }

}

template <typename Container> size_t GenericDNSPacketWriter<Container>::getSizeWithOpts(const optvect_t& options) const
{
  size_t result = size() + /* root */ 1 + DNS_TYPE_SIZE + DNS_CLASS_SIZE + DNS_TTL_SIZE + DNS_RDLENGTH_SIZE;

  for(auto const &option : options) {
    result += 4;
    result += option.second.size();
  }

  return result;
}

template class GenericDNSPacketWriter<std::vector<uint8_t>>;
#include "noinitvector.hh"
template class GenericDNSPacketWriter<PacketBuffer>;

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22	#ifdef HAVE_CONFIG_H
23	#include "config.h"
24	#endif
25	#include <boost/version.hpp>
26	#if BOOST_VERSION >= 105400
27	#include <boost/container/static_vector.hpp>
28	#endif
29	#include "dnswriter.hh"
30	#include "misc.hh"
31	#include "dnsparser.hh"
32
33	#include <limits.h>
34
35	/* d_content: <---- d_stuff ---->
36	v d_truncatemarker
37	dnsheader \| qname \| qtype \| qclass \| {recordname\| dnsrecordheader \| record }
38	^ d_rollbackmarker ^ d_sor
39
40
41	*/
42
43
44	template <typename Container> GenericDNSPacketWriter<Container>::GenericDNSPacketWriter(Container& content, const DNSName& qname, uint16_t qtype, uint16_t qclass, uint8_t opcode)
45	: d_content(content), d_qname(qname), d_canonic(false), d_lowerCase(false)
46	{	6,543,285✔
47	d_content.clear();	6,543,285✔
48	dnsheader dnsheader;	6,543,285✔
49
50	memset(&dnsheader, 0, sizeof(dnsheader));	6,543,285✔
51	dnsheader.id=0;	6,543,285✔
52	dnsheader.qdcount=htons(1);	6,543,285✔
53	dnsheader.opcode=opcode;	6,543,285✔
54
55	const uint8_t* ptr=(const uint8_t*)&dnsheader;	6,543,285✔
56	d_content.reserve(sizeof(dnsheader) + qname.wirelength() + sizeof(qtype) + sizeof(qclass));	6,543,285✔
57	d_content.resize(sizeof(dnsheader));	6,543,285✔
58	uint8_t* dptr=(&*d_content.begin());	6,543,285✔
59
60	memcpy(dptr, ptr, sizeof(dnsheader));	6,543,285✔
61	d_namepositions.reserve(16);	6,543,285✔
62	xfrName(qname, false);	6,543,285✔
63	xfr16BitInt(qtype);	6,543,285✔
64	xfr16BitInt(qclass);	6,543,285✔
65
66	d_truncatemarker=d_content.size();	6,543,285✔
67	d_sor = 0;	6,543,285✔
68	d_rollbackmarker = 0;	6,543,285✔
69	}	6,543,285✔
70
71	template <typename Container> dnsheader* GenericDNSPacketWriter<Container>::getHeader()
72	{	9,519,381✔
73	return reinterpret_cast<dnsheader>(&d_content.begin());	9,519,381✔
74	}	9,519,381✔
75
76
77	template <typename Container> void GenericDNSPacketWriter<Container>::startRecord(const DNSName& name, uint16_t qtype, uint32_t ttl, uint16_t qclass, DNSResourceRecord::Place place, bool compress)
78	{	3,801,930✔
79	d_compress = compress;	3,801,930✔
80	commit();	3,801,930✔
81	d_rollbackmarker=d_content.size();	3,801,930✔
82
83	if(compress && !name.isRoot() && d_qname==name) { // don't do the whole label compression thing if we know we can get away with "see question" - except when compressing the root	3,807,163✔
84	static unsigned char marker[2]={0xc0, 0x0c};	1,655,713✔
85	d_content.insert(d_content.end(), (const char ) &marker[0], (const char ) &marker[2]);	1,655,713✔
86	}	1,655,713✔
87	else {	4,297,116,726✔
88	xfrName(name, compress);	4,297,116,726✔
89	}	4,297,116,726✔
90	xfr16BitInt(qtype);	3,801,930✔
91	xfr16BitInt(qclass);	3,801,930✔
92	xfr32BitInt(ttl);	3,801,930✔
93	xfr16BitInt(0); // this will be the record size	3,801,930✔
94	d_recordplace = place;	3,801,930✔
95	d_sor=d_content.size(); // this will remind us where to stuff the record size	3,801,930✔
96	}	3,801,930✔
97
98	template <typename Container> void GenericDNSPacketWriter<Container>::addOpt(const uint16_t udpsize, const uint16_t extRCode, const uint16_t ednsFlags, const optvect_t& options, const uint8_t version)
99	{	35,636✔
100	uint32_t ttl=0;	35,636✔
101
102	EDNS0Record stuff;	35,636✔
103
104	stuff.version = version;	35,636✔
105	stuff.extFlags = htons(ednsFlags);	35,636✔
106
107	/* RFC 6891 section 4 on the Extended RCode wire format
108	* EXTENDED-RCODE
109	* Forms the upper 8 bits of extended 12-bit RCODE (together with the
110	* 4 bits defined in [RFC1035]. Note that EXTENDED-RCODE value 0
111	* indicates that an unextended RCODE is in use (values 0 through 15).
112	*/
113	// XXX Should be check for extRCode > 1<<12 ?
114	stuff.extRCode = extRCode>>4;	35,636✔
115	if (extRCode != 0) { // As this trumps the existing RCODE	35,636!
UNCOV 116	getHeader()->rcode = extRCode;	×
UNCOV 117	}	×
118
119	static_assert(sizeof(EDNS0Record) == sizeof(ttl), "sizeof(EDNS0Record) must match sizeof(ttl)");	35,636✔
120	memcpy(&ttl, &stuff, sizeof(stuff));	35,636✔
121
122	ttl=ntohl(ttl); // will be reversed later on	35,636✔
123
124	startRecord(g_rootdnsname, QType::OPT, ttl, udpsize, DNSResourceRecord::ADDITIONAL, false);	35,636✔
125	for(auto const &option : options) {	35,636✔
126	xfr16BitInt(option.first);	273✔
127	xfr16BitInt(option.second.length());	273✔
128	xfrBlob(option.second);	273✔
129	}	273✔
130	}	35,636✔
131
132	template <typename Container> void GenericDNSPacketWriter<Container>::xfr48BitInt(uint64_t val)
133	{	315✔
134	std::array<unsigned char, 6> bytes;	315✔
135	uint16_t theLeft = htons((val >> 32)&0xffffU);	315✔
136	uint32_t theRight = htonl(val & 0xffffffffU);	315✔
137	memcpy(&bytes[0], (void*)&theLeft, sizeof(theLeft));	315✔
138	memcpy(&bytes[2], (void*)&theRight, sizeof(theRight));	315✔
139
140	d_content.insert(d_content.end(), bytes.begin(), bytes.end());	315✔
141	}	315✔
142
143	template <typename Container> void GenericDNSPacketWriter<Container>::xfrNodeOrLocatorID(const NodeOrLocatorID& val)
144	{	7✔
145	d_content.insert(d_content.end(), val.content, val.content + sizeof(val.content));	7✔
146	}	7✔
147
148	template <typename Container> void GenericDNSPacketWriter<Container>::xfr32BitInt(uint32_t val)
149	{	8,222,773✔
150	uint32_t rval=htonl(val);	8,222,773✔
151	uint8_t* ptr=reinterpret_cast<uint8_t*>(&rval);	8,222,773✔
152	d_content.insert(d_content.end(), ptr, ptr+4);	8,222,773✔
153	}	8,222,773✔
154
155	template <typename Container> void GenericDNSPacketWriter<Container>::xfr16BitInt(uint16_t val)
156	{	26,241,485✔
157	uint16_t rval=htons(val);	26,241,485✔
158	uint8_t* ptr=reinterpret_cast<uint8_t*>(&rval);	26,241,485✔
159	d_content.insert(d_content.end(), ptr, ptr+2);	26,241,485✔
160	}	26,241,485✔
161
162	template <typename Container> void GenericDNSPacketWriter<Container>::xfr8BitInt(uint8_t val)
163	{	2,813,692✔
164	d_content.push_back(val);	2,813,692✔
165	}	2,813,692✔
166
167
168	/* input:
169	if lenField is true
170	"" -> 0
171	"blah" -> 4blah
172	"blah" "blah" -> output 4blah4blah
173	"verylongstringlongerthan256....characters" \xffverylongstring\x23characters (autosplit)
174	"blah\"blah" -> 9blah"blah
175	"blah\97" -> 5blahb
176
177	if lenField is false
178	"blah" -> blah
179	"blah\"blah" -> blah"blah
180	*/
181	template <typename Container> void GenericDNSPacketWriter<Container>::xfrText(const string& text, bool, bool lenField)
182	{	6,812✔
183	if(text.empty()) {	6,812!
184	d_content.push_back(0);	×
185	return;	×
186	}	×
187	vector<string> segments = segmentDNSText(text);	6,812✔
188	for(const string& str : segments) {	8,703✔
189	if(lenField)	8,703!
190	d_content.push_back(str.length());	8,695✔
191	d_content.insert(d_content.end(), str.c_str(), str.c_str() + str.length());	8,703✔
192	}	8,703✔
193	}	6,812✔
194
195	template <typename Container> void GenericDNSPacketWriter<Container>::xfrUnquotedText(const string& text, bool lenField)
196	{	932✔
197	if(text.empty()) {	932!
198	d_content.push_back(0);	×
199	return;	×
200	}	×
201	if(lenField)	932!
202	d_content.push_back(text.length());	932✔
203	d_content.insert(d_content.end(), text.c_str(), text.c_str() + text.length());	932✔
204	}	932✔
205
206
207	static constexpr bool l_verbose=false;
208	static constexpr uint16_t maxCompressionOffset=16384;
209	template <typename Container> uint16_t GenericDNSPacketWriter<Container>::lookupName(const DNSName& name, uint16_t* matchLen)
210	{	1,086,523✔
211	// iterate over the written labels, see if we find a match
212	const auto& raw = name.getStorage();	1,086,523✔
213
214	/* name might be a.root-servers.net, we need to be able to benefit from finding:
215	b.root-servers.net, or even:
216	b\xc0\x0c
217	*/
218	unsigned int bestpos=0;	1,086,523✔
219	*matchLen=0;	1,086,523✔
220	#if BOOST_VERSION >= 105400	1,086,523✔
221	boost::container::static_vector<uint16_t, 34> nvect, pvect;	1,086,523✔
222	#else
223	vector<uint16_t> nvect, pvect;
224	#endif
225
226	try {	1,086,523✔
227	for(auto riter= raw.cbegin(); riter < raw.cend(); ) {	4,350,452!
228	if(!*riter)	4,350,450✔
229	break;	1,086,523✔
230	nvect.push_back(riter - raw.cbegin());	3,263,927✔
231	riter+=*riter+1;	3,263,927✔
232	}	3,263,927✔
233	}	1,086,523✔
234	catch(std::bad_alloc& ba) {	1,086,523✔
235	if(l_verbose)	2✔
236	cout<<"Domain "<<name<<" too large to compress"<<endl;	×
237	return 0;	2✔
238	}	2✔
239
240	if(l_verbose) {	1,086,523✔
241	cout<<"Input vector for lookup "<<name<<": ";	×
242	for(const auto n : nvect)	×
243	cout << n<<" ";	×
244	cout<<endl;	×
245	cout<<makeHexDump(string(raw.c_str(), raw.c_str()+raw.size()))<<endl;	×
246	}	×
247
248	if(l_verbose)	1,086,523✔
249	cout<<"Have "<<d_namepositions.size()<<" to ponder"<<endl;	×
250	int counter=1;	1,086,523✔
251	for(auto p : d_namepositions) {	27,114,325✔
252	if(l_verbose) {	27,093,034✔
253	cout<<"Pos: "<<p<<", "<<d_content.size()<<endl;	×
254	DNSName pname((const char*)&d_content[0], d_content.size(), p, true); // only for debugging	×
255	cout<<"Looking at '"<<pname<<"' in packet at position "<<p<<"/"<<d_content.size()<<", option "<<counter<<"/"<<d_namepositions.size()<<endl;	×
256	++counter;	×
257	}	×
258	// memcmp here makes things _slower_
259	pvect.clear();	27,093,034✔
260	try {	27,093,034✔
261	for(auto iter = d_content.cbegin() + p; iter < d_content.cend();) {	109,149,037!
262	uint8_t c=*iter;	109,148,993✔
263	if(l_verbose)	109,148,993✔
264	cout<<"Found label length: "<<(int)c<<endl;	×
265	if(c & 0xc0) {	109,148,993✔
266	uint16_t npos = 0x100(c & (~0xc0)) + ++iter;	12,866,473✔
267	iter = d_content.begin() + npos;	12,866,473✔
268	if(l_verbose)	12,866,473✔
269	cout<<"Is compressed label to newpos "<<npos<<", going there"<<endl;	×
270	// check against going forward here
271	continue;	12,866,473✔
272	}	12,866,473✔
273	if(!c)	96,282,520✔
274	break;	27,092,989✔
275	auto offset = iter - d_content.cbegin();	69,189,531✔
276	if (offset >= maxCompressionOffset) break; // compression pointers cannot point here	69,189,531!
277	pvect.push_back(offset);	69,189,530✔
278	iter+=*iter+1;	69,189,530✔
279	}	69,189,530✔
280	}	27,093,034✔
281	catch(std::bad_alloc& ba) {	27,093,034✔
282	if(l_verbose)	4✔
283	cout<<"Domain "<<name<<" too large to compress"<<endl;	×
284	continue;	4✔
285	}	4✔
286	if(l_verbose) {	27,092,990✔
287	cout<<"Packet vector: "<<endl;	×
288	for(const auto n : pvect)	×
289	cout << n<<" ";	×
290	cout<<endl;	×
291	}	×
292	auto niter=nvect.crbegin(), piter=pvect.crbegin();	27,092,990✔
293	unsigned int cmatchlen=1;	27,092,990✔
294	for(; niter != nvect.crend() && piter != pvect.crend(); ++niter, ++piter) {	81,196,060!
295	// niter is an offset in raw, pvect an offset in packet
296	uint8_t nlen = raw[niter], plen=d_content[piter];	68,920,054✔
297	if(l_verbose)	68,920,054✔
298	cout<<"nlnen="<<(int)nlen<<", plen="<<(int)plen<<endl;	×
299	if(nlen != plen)	68,920,054✔
300	break;	4,413,949✔
301	if(strncasecmp(raw.c_str()+niter+1, (const char)&d_content[*piter]+1, nlen)) {	64,506,105✔
302	if(l_verbose)	10,070,663✔
303	cout<<"Mismatch: "<<string(raw.c_str()+niter+1, raw.c_str()+niter+nlen+1)<< " != "<<string((const char)&d_content[piter]+1, (const char)&d_content[piter]+nlen+1)<<endl;	×
304	break;	10,070,663✔
305	}	10,070,663✔
306	cmatchlen+=nlen+1;	54,435,442✔
307	if(cmatchlen == raw.length()) { // have matched all of it, can't improve	54,435,442✔
308	if(l_verbose)	332,429✔
309	cout<<"Stopping search, matched whole name"<<endl;	×
310	*matchLen = cmatchlen;	332,429✔
311	return *piter;	332,429✔
312	}	332,429✔
313	}	54,435,442✔
314	if(piter != pvect.crbegin() && *matchLen < cmatchlen) {	26,760,561✔
315	*matchLen = cmatchlen;	657,396✔
316	bestpos=*--piter;	657,396✔
317	}	657,396✔
318	}	26,760,561✔
319	return bestpos;	754,054✔
320	}	1,086,523✔
321	// this is the absolute hottest function in the pdns recursor
322	template <typename Container> void GenericDNSPacketWriter<Container>::xfrName(const DNSName& name, bool compress, bool)
323	{	9,598,537✔
324	if(l_verbose)	9,598,537✔
325	cout<<"Wants to write "<<name<<", compress="<<compress<<", canonic="<<d_canonic<<", LC="<<d_lowerCase<<endl;	×
326	if(d_canonic \|\| d_lowerCase) // d_lowerCase implies canonic	9,598,543✔
327	compress=false;	1,175,974✔
328
329	if(name.empty() \|\| name.isRoot()) { // for speed	9,598,537✔
330	d_content.push_back(0);	2,651,495✔
331	return;	2,651,495✔
332	}	2,651,495✔
333
334	uint16_t li=0;	6,947,042✔
335	uint16_t matchlen=0;	6,947,042✔
336	if(d_compress && compress && (li=lookupName(name, &matchlen)) && li < maxCompressionOffset) {	6,947,042!
337	const auto& dns=name.getStorage();	671,053✔
338	if(l_verbose)	671,053✔
339	cout<<"Found a substring of "<<matchlen<<" bytes from the back, offset: "<<li<<", dnslen: "<<dns.size()<<endl;	×
340	// found a substring, if www.powerdns.com matched powerdns.com, we get back matchlen = 13
341
342	unsigned int pos=d_content.size();	671,053✔
343	if(pos < maxCompressionOffset && matchlen != dns.size()) {	671,053!
344	if(l_verbose)	338,624✔
345	cout<<"Inserting pos "<<pos<<" for "<<name<<" for compressed case"<<endl;	×
346	d_namepositions.push_back(pos);	338,624✔
347	}	338,624✔
348
349	if(l_verbose)	671,053✔
350	cout<<"Going to write unique part: '"<<makeHexDump(string(dns.c_str(), dns.c_str() + dns.size() - matchlen)) <<"'"<<endl;	×
351	d_content.insert(d_content.end(), (const unsigned char)dns.c_str(), (const unsigned char)dns.c_str() + dns.size() - matchlen);	671,053✔
352	uint16_t offset=li;	671,053✔
353	offset\|=0xc000;	671,053✔
354
355	d_content.push_back((char)(offset >> 8));	671,053✔
356	d_content.push_back((char)(offset & 0xff));	671,053✔
357	}	671,053✔
358	else {	6,275,989✔
359	unsigned int pos=d_content.size();	6,275,989✔
360	if(l_verbose)	6,275,989✔
361	cout<<"Found nothing, we are at pos "<<pos<<", inserting whole name"<<endl;	×
362	if(pos < maxCompressionOffset) {	6,276,132✔
363	if(l_verbose)	6,271,401✔
364	cout<<"Inserting pos "<<pos<<" for "<<name<<" for uncompressed case"<<endl;	×
365	d_namepositions.push_back(pos);	6,271,401✔
366	}	6,271,401✔
367
368	std::unique_ptr<DNSName> lc;	6,275,989✔
369	if(d_lowerCase)	6,275,989!
370	lc = make_unique<DNSName>(name.makeLowerCase());	311,312✔
371
372	const DNSName::string_t& raw = (lc ? *lc : name).getStorage();	6,275,989!
373	if(l_verbose)	6,275,989✔
374	cout<<"Writing out the whole thing "<<makeHexDump(string(raw.c_str(), raw.c_str() + raw.length()))<<endl;	×
375	d_content.insert(d_content.end(), raw.c_str(), raw.c_str() + raw.size());	6,275,989✔
376	}	6,275,989✔
377	}	6,947,042✔
378
379	template <typename Container> void GenericDNSPacketWriter<Container>::xfrBlob(const string& blob, int )
380	{	1,885,474✔
381	const uint8_t* ptr=reinterpret_cast<const uint8_t*>(blob.c_str());	1,885,474✔
382	d_content.insert(d_content.end(), ptr, ptr+blob.size());	1,885,474✔
383	}	1,885,474✔
384
385	template <typename Container> void GenericDNSPacketWriter<Container>::xfrBlob(const std::vector<uint8_t>& blob)
386	{	14✔
387	d_content.insert(d_content.end(), blob.begin(), blob.end());	14✔
388	}	14✔
389
390	template <typename Container> void GenericDNSPacketWriter<Container>::xfrBlobNoSpaces(const string& blob, int )
391	{	126✔
392	xfrBlob(blob);	126✔
393	}	126✔
394
395	template <typename Container> void GenericDNSPacketWriter<Container>::xfrHexBlob(const string& blob, bool /* keepReading */)
396	{	4,472✔
397	xfrBlob(blob);	4,472✔
398	}	4,472✔
399
400	template <typename Container> void GenericDNSPacketWriter<Container>::xfrSvcParamKeyVals(const std::set<SvcParam> &kvs)
401	{	788✔
402	for (auto const &param : kvs) {	1,161!
403	// Key first!
404	xfr16BitInt(param.getKey());	1,161✔
405
406	switch (param.getKey())	1,161✔
407	{	1,161✔
408	case SvcParam::mandatory:	30!
409	xfr16BitInt(2 * param.getMandatory().size());	30✔
410	for (auto const &m: param.getMandatory()) {	33!
411	xfr16BitInt(m);	33✔
412	}	33✔
413	break;	30✔
414	case SvcParam::alpn:	745!
415	{	745✔
416	uint16_t totalSize = param.getALPN().size(); // All 1 octet size headers for each value	745✔
417	for (auto const &a : param.getALPN()) {	930!
418	totalSize += a.length();	930✔
419	}	930✔
420	xfr16BitInt(totalSize);	745✔
421	for (auto const &a : param.getALPN()) {	930!
422	xfrUnquotedText(a, true); // will add the 1-byte length field	930✔
423	}	930✔
424	break;	745✔
425	}	×
426	case SvcParam::no_default_alpn:	13!
427	xfr16BitInt(0); // no size :)	13✔
428	break;	13✔
429	case SvcParam::port:	296!
430	xfr16BitInt(2); // size	296✔
431	xfr16BitInt(param.getPort());	296✔
432	break;	296✔
433	case SvcParam::ipv4hint:	26!
434	xfr16BitInt(param.getIPHints().size() * 4); // size	26✔
435	for (const auto& a: param.getIPHints()) {	30!
436	xfrCAWithoutPort(param.getKey(), a);	30✔
437	}	30✔
438	break;	26✔
439	case SvcParam::ipv6hint:	22!
440	xfr16BitInt(param.getIPHints().size() * 16); // size	22✔
441	for (const auto& a: param.getIPHints()) {	28!
442	xfrCAWithoutPort(param.getKey(), a);	28✔
443	}	28✔
444	break;	22✔
445	case SvcParam::ech:	8!
446	xfr16BitInt(param.getECH().size()); // size	8✔
447	xfrBlobNoSpaces(param.getECH());	8✔
448	break;	8✔
449	default:	21!
450	xfr16BitInt(param.getValue().size());	21✔
451	xfrBlob(param.getValue());	21✔
452	break;	21✔
453	}	1,161✔
454	}	1,161✔
455	}	788✔
456
457	// call __before commit__
458	template <typename Container> void GenericDNSPacketWriter<Container>::getRecordPayload(string& records)
459	{	1,512,548✔
460	records.assign(d_content.begin() + d_sor, d_content.end());	1,512,548✔
461	}	1,512,548✔
462
463	template <typename Container> uint32_t GenericDNSPacketWriter<Container>::size() const
464	{	668,746✔
465	return d_content.size();	668,746✔
466	}	668,746✔
467
468	template <typename Container> void GenericDNSPacketWriter<Container>::rollback()
469	{	166✔
470	d_content.resize(d_rollbackmarker);	166✔
471	d_sor = 0;	166✔
472	}	166✔
473
474	template <typename Container> void GenericDNSPacketWriter<Container>::truncate()
475	{	166✔
476	d_content.resize(d_truncatemarker);	166✔
477	dnsheader* dh=reinterpret_cast<dnsheader>( &d_content.begin());	166✔
478	dh->ancount = dh->nscount = dh->arcount = 0;	166✔
479	}	166✔
480
481	template <typename Container> void GenericDNSPacketWriter<Container>::commit()
482	{	5,463,392✔
483	if(!d_sor)	5,463,392✔
484	return;	3,175,938✔
485	uint16_t rlen = d_content.size() - d_sor;	2,287,454✔
486	d_content[d_sor-2]=rlen >> 8;	2,287,454✔
487	d_content[d_sor-1]=rlen & 0xff;	2,287,454✔
488	d_sor=0;	2,287,454✔
489	dnsheader* dh=reinterpret_cast<dnsheader>( &d_content.begin());	2,287,454✔
490	switch(d_recordplace) {	2,287,454✔
491	case DNSResourceRecord::QUESTION:	×
492	dh->qdcount = htons(ntohs(dh->qdcount) + 1);	×
493	break;	×
494	case DNSResourceRecord::ANSWER:	2,186,872✔
495	dh->ancount = htons(ntohs(dh->ancount) + 1);	2,186,872✔
496	break;	2,186,872✔
497	case DNSResourceRecord::AUTHORITY:	50,551✔
498	dh->nscount = htons(ntohs(dh->nscount) + 1);	50,551✔
499	break;	50,551✔
500	case DNSResourceRecord::ADDITIONAL:	55,947✔
501	dh->arcount = htons(ntohs(dh->arcount) + 1);	55,947✔
502	break;	55,947✔
503	}	2,287,454✔
504
505	}	2,287,454✔
506
507	template <typename Container> size_t GenericDNSPacketWriter<Container>::getSizeWithOpts(const optvect_t& options) const
508	{	×
509	size_t result = size() + /* root */ 1 + DNS_TYPE_SIZE + DNS_CLASS_SIZE + DNS_TTL_SIZE + DNS_RDLENGTH_SIZE;	×
510
511	for(auto const &option : options) {	×
512	result += 4;	×
513	result += option.second.size();	×
514	}	×
515
516	return result;	×
517	}	×
518
519	template class GenericDNSPacketWriter<std::vector<uint8_t>>;
520	#include "noinitvector.hh"
521	template class GenericDNSPacketWriter<PacketBuffer>;

PowerDNS / pdns / 6671102387

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous