11213595982

Committed 07 Oct 2024 10:26AM UTC coverage: 64.724% (+0.002%) from 64.722%

Build # 11213595982

Build Type

Pull #14693

github

Committed by

web-flow

Commit Message

Merge 458a9064c into 9dd0277ef

Pull Request Pull Request #14693: rec: implement rfc6303 special zones (mostly v6 reverse mappings)

Run Details

37111 of 88060 branches covered (42.14%)

Branch coverage included in aggregate %.

27 of 33 new or added lines in 2 files covered. (81.82%)

5531 existing lines in 74 files now uncovered.

125039 of 162466 relevant lines covered (76.96%)

4121305.12 hits per line

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

78.27

/pdns/dnsparser.hh

/*
 * 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.
 */
#pragma once
#include <map>
#include <sstream>
#include <stdexcept>
#include <iostream>
#include <unordered_set>
#include <utility>
#include <vector>
#include <cerrno>
// #include <netinet/in.h>
#include "misc.hh"

#include "dns.hh"
#include "dnswriter.hh"
#include "dnsname.hh"
#include "noinitvector.hh"
#include "pdnsexception.hh"
#include "iputils.hh"
#include "svc-records.hh"

/** DNS records have three representations:
    1) in the packet
    2) parsed in a class, ready for use
    3) in the zone

    We should implement bidirectional transitions between 1&2 and 2&3.
    Currently we have: 1 -> 2
                       2 -> 3

    We can add:        2 -> 1  easily by reversing the packetwriter
    And we might be able to reverse 2 -> 3 as well
*/

#include "namespaces.hh"

class MOADNSException : public runtime_error
{
public:
  MOADNSException(const string& str) : runtime_error(str)
  {}
};


class MOADNSParser;

class PacketReader
{
public:
  PacketReader(const std::string_view& content, uint16_t initialPos=sizeof(dnsheader))
    : d_pos(initialPos), d_startrecordpos(initialPos), d_content(content)
  {
    if(content.size() > std::numeric_limits<uint16_t>::max())
      throw std::out_of_range("packet too large");

    d_recordlen = (uint16_t) content.size();
    not_used = 0;
  }

  uint32_t get32BitInt();
  uint16_t get16BitInt();
  uint8_t get8BitInt();

  void xfrNodeOrLocatorID(NodeOrLocatorID& val);
  void xfr48BitInt(uint64_t& val);

  void xfr32BitInt(uint32_t& val)
  {
    val=get32BitInt();
  }

  void xfrIP(uint32_t& val)
  {
    xfr32BitInt(val);
    val=htonl(val);
  }

  void xfrIP6(std::string &val) {
    xfrBlob(val, 16);
  }

  void xfrCAWithoutPort(uint8_t version, ComboAddress &val) {
    string blob;
    if (version == 4) xfrBlob(blob, 4);
    else if (version == 6) xfrBlob(blob, 16);
    else throw runtime_error("invalid IP protocol");
    val = makeComboAddressFromRaw(version, blob);
  }

  void xfrCAPort(ComboAddress &val) {
    uint16_t port;
    xfr16BitInt(port);
    val.sin4.sin_port = port;
  }

  void xfrTime(uint32_t& val)
  {
    xfr32BitInt(val);
  }


  void xfr16BitInt(uint16_t& val)
  {
    val=get16BitInt();
  }

  void xfrType(uint16_t& val)
  {
    xfr16BitInt(val);
  }


  void xfr8BitInt(uint8_t& val)
  {
    val=get8BitInt();
  }

  void xfrName(DNSName& name, bool /* compress */ = false, bool /* noDot */ = false)
  {
    name = getName();
  }

  void xfrText(string &text, bool multi=false, bool lenField=true)
  {
    text=getText(multi, lenField);
  }

  void xfrUnquotedText(string &text, bool lenField){
    text=getUnquotedText(lenField);
  }

  void xfrBlob(string& blob);
  void xfrBlobNoSpaces(string& blob, int len);
  void xfrBlob(string& blob, int length);
  void xfrHexBlob(string& blob, bool keepReading=false);
  void xfrSvcParamKeyVals(set<SvcParam> &kvs);

  void getDnsrecordheader(struct dnsrecordheader &ah);
  void copyRecord(vector<unsigned char>& dest, uint16_t len);
  void copyRecord(unsigned char* dest, uint16_t len);

  DNSName getName();
  string getText(bool multi, bool lenField);
  string getUnquotedText(bool lenField);


  bool eof() { return true; };
  const string getRemaining() const {
    return "";
  };

  uint16_t getPosition() const
  {
    return d_pos;
  }

  void skip(uint16_t n)
  {
    d_pos += n;
  }

private:
  uint16_t d_pos;
  uint16_t d_startrecordpos; // needed for getBlob later on
  uint16_t d_recordlen;      // ditto
  uint16_t not_used; // Aligns the whole class on 8-byte boundaries
  const std::string_view d_content;
};

struct DNSRecord;

class DNSRecordContent
{
public:
  static std::shared_ptr<DNSRecordContent> make(const DNSRecord& dr, PacketReader& pr);
  static std::shared_ptr<DNSRecordContent> make(const DNSRecord& dr, PacketReader& pr, uint16_t opcode);
  static std::shared_ptr<DNSRecordContent> make(uint16_t qtype, uint16_t qclass, const string& zone);
  static string upgradeContent(const DNSName& qname, const QType& qtype, const string& content);

  virtual std::string getZoneRepresentation(bool noDot=false) const = 0;
  virtual ~DNSRecordContent() = default;
  virtual void toPacket(DNSPacketWriter& pw) const = 0;
  // returns the wire format of the content, possibly including compressed pointers pointing to the owner name (unless canonic or lowerCase are set)
  string serialize(const DNSName& qname, bool canonic=false, bool lowerCase=false) const
  {
    vector<uint8_t> packet;
    DNSPacketWriter pw(packet, g_rootdnsname, 1);
    if(canonic)
      pw.setCanonic(true);

    if(lowerCase)
      pw.setLowercase(true);

    pw.startRecord(qname, this->getType());
    this->toPacket(pw);

    string record;
    pw.getRecordPayload(record); // needs to be called before commit()
    return record;
  }

  virtual bool operator==(const DNSRecordContent& rhs) const
  {
    return typeid(*this)==typeid(rhs) && this->getZoneRepresentation() == rhs.getZoneRepresentation();
  }

  // parse the content in wire format, possibly including compressed pointers pointing to the owner name
  static shared_ptr<DNSRecordContent> deserialize(const DNSName& qname, uint16_t qtype, const string& serialized);

  void doRecordCheck(const struct DNSRecord&){}

  typedef std::shared_ptr<DNSRecordContent> makerfunc_t(const struct DNSRecord& dr, PacketReader& pr);
  typedef std::shared_ptr<DNSRecordContent> zmakerfunc_t(const string& str);

  static void regist(uint16_t cl, uint16_t ty, makerfunc_t* f, zmakerfunc_t* z, const char* name)
  {
    if(f)
      getTypemap()[pair(cl,ty)]=f;
    if(z)
      getZmakermap()[pair(cl,ty)]=z;

    getT2Namemap().emplace(pair(cl, ty), name);
    getN2Typemap().emplace(name, pair(cl, ty));
  }

  static void unregist(uint16_t cl, uint16_t ty)
  {
    auto key = pair(cl, ty);
    getTypemap().erase(key);
    getZmakermap().erase(key);
  }

  static bool isUnknownType(const string& name)
  {
    return boost::starts_with(name, "TYPE") || boost::starts_with(name, "type");
  }

  static uint16_t TypeToNumber(const string& name)
  {
    n2typemap_t::const_iterator iter = getN2Typemap().find(toUpper(name));
    if(iter != getN2Typemap().end())
      return iter->second.second;

    if (isUnknownType(name)) {
      return pdns::checked_stoi<uint16_t>(name.substr(4));
    }

    throw runtime_error("Unknown DNS type '"+name+"'");
  }

  static const string NumberToType(uint16_t num, uint16_t classnum = QClass::IN)
  {
    auto iter = getT2Namemap().find(pair(classnum, num));
    if(iter == getT2Namemap().end())
      return "TYPE" + std::to_string(num);
      //      throw runtime_error("Unknown DNS type with numerical id "+std::to_string(num));
    return iter->second;
  }

  /**
   * \brief Return whether we have implemented a content representation for this type
   */
  static bool isRegisteredType(uint16_t rtype, uint16_t rclass = QClass::IN);

  virtual uint16_t getType() const = 0;

protected:
  typedef std::map<std::pair<uint16_t, uint16_t>, makerfunc_t* > typemap_t;
  typedef std::map<std::pair<uint16_t, uint16_t>, zmakerfunc_t* > zmakermap_t;
  typedef std::map<std::pair<uint16_t, uint16_t>, string > t2namemap_t;
  typedef std::map<string, std::pair<uint16_t, uint16_t> > n2typemap_t;
  static typemap_t& getTypemap();
  static t2namemap_t& getT2Namemap();
  static n2typemap_t& getN2Typemap();
  static zmakermap_t& getZmakermap();
};

struct DNSRecord
{
  DNSRecord() :
    d_class(QClass::IN)
  {}
  explicit DNSRecord(const DNSResourceRecord& rr);
  DNSRecord(const std::string& name,
            std::shared_ptr<DNSRecordContent> content,
            const uint16_t type,
            const uint16_t qclass = QClass::IN,
            const uint32_t ttl = 86400,
            const uint16_t clen = 0,
            const DNSResourceRecord::Place place = DNSResourceRecord::ANSWER) :
    d_name(DNSName(name)),
    d_content(std::move(content)),
    d_type(type),
    d_class(qclass),
    d_ttl(ttl),
    d_clen(clen),
    d_place(place) {}

  DNSName d_name;
private:
  std::shared_ptr<const DNSRecordContent> d_content;
public:
  uint16_t d_type{};
  uint16_t d_class{};
  uint32_t d_ttl{};
  uint16_t d_clen{};
  DNSResourceRecord::Place d_place{DNSResourceRecord::ANSWER};

  [[nodiscard]] std::string print(const std::string& indent = "") const
  {
    std::stringstream s;
    s << indent << "Content = " << d_content->getZoneRepresentation() << std::endl;
    s << indent << "Type = " << d_type << std::endl;
    s << indent << "Class = " << d_class << std::endl;
    s << indent << "TTL = " << d_ttl << std::endl;
    s << indent << "clen = " << d_clen << std::endl;
    s << indent << "Place = " << std::to_string(d_place) << std::endl;
    return s.str();
  }

  [[nodiscard]] std::string toString() const
  {
    std::string ret(d_name.toLogString());
    ret += '|';
    ret += QType(d_type).toString();
    ret += '|';
    ret += getContent()->getZoneRepresentation();
    return ret;
  }

  void setContent(const std::shared_ptr<const DNSRecordContent>& content)
  {
    d_content = content;
  }

  void setContent(std::shared_ptr<const DNSRecordContent>&& content)
  {
    d_content = std::move(content);
  }

  [[nodiscard]] const std::shared_ptr<const DNSRecordContent>& getContent() const
  {
    return d_content;
  }

  bool operator<(const DNSRecord& rhs) const
  {
    if(std::tie(d_name, d_type, d_class, d_ttl) < std::tie(rhs.d_name, rhs.d_type, rhs.d_class, rhs.d_ttl))
      return true;

    if(std::tie(d_name, d_type, d_class, d_ttl) != std::tie(rhs.d_name, rhs.d_type, rhs.d_class, rhs.d_ttl))
      return false;

    string lzrp, rzrp;
    if(d_content)
      lzrp=toLower(d_content->getZoneRepresentation());
    if(rhs.d_content)
      rzrp=toLower(rhs.d_content->getZoneRepresentation());

    return lzrp < rzrp;
  }

  // this orders in canonical order and keeps the SOA record on top
  static bool prettyCompare(const DNSRecord& a, const DNSRecord& b)
  {
    auto aType = (a.d_type == QType::SOA) ? 0 : a.d_type;
    auto bType = (b.d_type == QType::SOA) ? 0 : b.d_type;

    if(a.d_name.canonCompare(b.d_name))
      return true;
    if(b.d_name.canonCompare(a.d_name))
      return false;

    if(std::tie(aType, a.d_class, a.d_ttl) < std::tie(bType, b.d_class, b.d_ttl))
      return true;

    if(std::tie(aType, a.d_class, a.d_ttl) != std::tie(bType, b.d_class, b.d_ttl))
      return false;

    string lzrp, rzrp;
    if(a.d_content)
      lzrp = a.d_content->getZoneRepresentation();
    if(b.d_content)
      rzrp = b.d_content->getZoneRepresentation();

    switch (a.d_type) {
    case QType::TXT:
    case QType::SPF:
#if !defined(RECURSOR)
    case QType::LUA:
#endif
      return lzrp < rzrp;
    default:
      return toLower(lzrp) < toLower(rzrp);
    }
  }

  bool operator==(const DNSRecord& rhs) const
  {
    if (d_type != rhs.d_type || d_class != rhs.d_class || d_name != rhs.d_name) {
      return false;
    }

    return *d_content == *rhs.d_content;
  }
};

struct DNSZoneRecord
{
  int domain_id{-1};
  uint8_t scopeMask{0};
  int signttl{0};
  DNSName wildcardname;
  bool auth{true};
  bool disabled{false};
  DNSRecord dr;
};

class UnknownRecordContent : public DNSRecordContent
{
public:
  UnknownRecordContent(const DNSRecord& dr, PacketReader& pr)
    : d_dr(dr)
  {
    pr.copyRecord(d_record, dr.d_clen);
  }

  UnknownRecordContent(const string& zone);

  string getZoneRepresentation(bool noDot) const override;
  void toPacket(DNSPacketWriter& pw) const override;
  uint16_t getType() const override
  {
    return d_dr.d_type;
  }

  const vector<uint8_t>& getRawContent() const
  {
    return d_record;
  }

private:
  DNSRecord d_dr;
  vector<uint8_t> d_record;
};

//! This class can be used to parse incoming packets, and is copyable
class MOADNSParser : public boost::noncopyable
{
public:
  //! Parse from a string
  MOADNSParser(bool query, const string& buffer): d_tsigPos(0)
  {
    init(query, buffer);
  }

  //! Parse from a pointer and length
  MOADNSParser(bool query, const char *packet, unsigned int len) : d_tsigPos(0)
  {
    init(query, std::string_view(packet, len));
  }

  DNSName d_qname;
  uint16_t d_qclass, d_qtype;
  dnsheader d_header;

  using answers_t = vector<DNSRecord>;

  //! All answers contained in this packet (everything *but* the question section)
  answers_t d_answers;

  uint16_t getTSIGPos() const
  {
    return d_tsigPos;
  }

  bool hasEDNS() const;

private:
  void init(bool query, const std::string_view& packet);
  uint16_t d_tsigPos;
};

string simpleCompress(const string& label, const string& root="");
void ageDNSPacket(char* packet, size_t length, uint32_t seconds, const dnsheader_aligned&);
void ageDNSPacket(std::string& packet, uint32_t seconds, const dnsheader_aligned&);
void editDNSPacketTTL(char* packet, size_t length, const std::function<uint32_t(uint8_t, uint16_t, uint16_t, uint32_t)>& visitor);
void clearDNSPacketRecordTypes(vector<uint8_t>& packet, const std::unordered_set<QType>& qtypes);
void clearDNSPacketRecordTypes(PacketBuffer& packet, const std::unordered_set<QType>& qtypes);
void clearDNSPacketRecordTypes(char* packet, size_t& length, const std::unordered_set<QType>& qtypes);
uint32_t getDNSPacketMinTTL(const char* packet, size_t length, bool* seenAuthSOA=nullptr);
uint32_t getDNSPacketLength(const char* packet, size_t length);
uint16_t getRecordsOfTypeCount(const char* packet, size_t length, uint8_t section, uint16_t type);
bool getEDNSUDPPayloadSizeAndZ(const char* packet, size_t length, uint16_t* payloadSize, uint16_t* z);
/* call the visitor for every records in the answer, authority and additional sections, passing the section, class, type, ttl, rdatalength and rdata
   to the visitor. Stops whenever the visitor returns false or at the end of the packet */
bool visitDNSPacket(const std::string_view& packet, const std::function<bool(uint8_t, uint16_t, uint16_t, uint32_t, uint16_t, const char*)>& visitor);

template<typename T>
std::shared_ptr<const T> getRR(const DNSRecord& dr)
{
  return std::dynamic_pointer_cast<const T>(dr.getContent());
}

/** Simple DNSPacketMangler. Ritual is: get a pointer into the packet and moveOffset() to beyond your needs
 *  If you survive that, feel free to read from the pointer */
class DNSPacketMangler
{
public:
  explicit DNSPacketMangler(std::string& packet)
    : d_packet(packet.data()), d_length(packet.length()), d_notyouroffset(12), d_offset(d_notyouroffset)
  {}
  DNSPacketMangler(char* packet, size_t length)
    : d_packet(packet), d_length(length), d_notyouroffset(12), d_offset(d_notyouroffset)
  {}

  /*! Advances past a wire-format domain name
   * The name is not checked for adherence to length restrictions.
   * Compression pointers are not followed.
   */
  void skipDomainName()
  {
    uint8_t len;
    while((len=get8BitInt())) {
      if(len >= 0xc0) { // extended label
        get8BitInt();
        return;
      }
      skipBytes(len);
    }
  }

  void skipBytes(uint16_t bytes)
  {
    moveOffset(bytes);
  }
  void rewindBytes(uint16_t by)
  {
    rewindOffset(by);
  }
  uint32_t get32BitInt()
  {
    const char* p = d_packet + d_offset;
    moveOffset(4);
    uint32_t ret;
    memcpy(&ret, p, sizeof(ret));
    return ntohl(ret);
  }
  uint16_t get16BitInt()
  {
    const char* p = d_packet + d_offset;
    moveOffset(2);
    uint16_t ret;
    memcpy(&ret, p, sizeof(ret));
    return ntohs(ret);
  }

  uint8_t get8BitInt()
  {
    const char* p = d_packet + d_offset;
    moveOffset(1);
    return *p;
  }

  void skipRData()
  {
    int toskip = get16BitInt();
    moveOffset(toskip);
  }

  void decreaseAndSkip32BitInt(uint32_t decrease)
  {
    const char *p = d_packet + d_offset;
    moveOffset(4);

    uint32_t tmp;
    memcpy(&tmp, p, sizeof(tmp));
    tmp = ntohl(tmp);
    if (tmp > decrease) {
      tmp -= decrease;
    } else {
      tmp = 0;
    }
    tmp = htonl(tmp);
    memcpy(d_packet + d_offset-4, (const char*)&tmp, sizeof(tmp));
  }

  void setAndSkip32BitInt(uint32_t value)
  {
    moveOffset(4);

    value = htonl(value);
    memcpy(d_packet + d_offset-4, (const char*)&value, sizeof(value));
  }

  uint32_t getOffset() const
  {
    return d_offset;
  }

private:
  void moveOffset(uint16_t by)
  {
    d_notyouroffset += by;
    if(d_notyouroffset > d_length)
      throw std::out_of_range("dns packet out of range: "+std::to_string(d_notyouroffset) +" > "
      + std::to_string(d_length) );
  }

  void rewindOffset(uint16_t by)
  {
    if(d_notyouroffset < by)
      throw std::out_of_range("Rewinding dns packet out of range: "+std::to_string(d_notyouroffset) +" < "
                              + std::to_string(by));
    d_notyouroffset -= by;
    if(d_notyouroffset < 12)
      throw std::out_of_range("Rewinding dns packet out of range: "+std::to_string(d_notyouroffset) +" < "
                              + std::to_string(12));
  }

  char* d_packet;
  size_t d_length;

  uint32_t d_notyouroffset;  // only 'moveOffset' can touch this
  const uint32_t&  d_offset; // look.. but don't touch
};

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	#pragma once
23	#include <map>
24	#include <sstream>
25	#include <stdexcept>
26	#include <iostream>
27	#include <unordered_set>
28	#include <utility>
29	#include <vector>
30	#include <cerrno>
31	// #include <netinet/in.h>
32	#include "misc.hh"
33
34	#include "dns.hh"
35	#include "dnswriter.hh"
36	#include "dnsname.hh"
37	#include "noinitvector.hh"
38	#include "pdnsexception.hh"
39	#include "iputils.hh"
40	#include "svc-records.hh"
41
42	/** DNS records have three representations:
43	1) in the packet
44	2) parsed in a class, ready for use
45	3) in the zone
46
47	We should implement bidirectional transitions between 1&2 and 2&3.
48	Currently we have: 1 -> 2
49	2 -> 3
50
51	We can add: 2 -> 1 easily by reversing the packetwriter
52	And we might be able to reverse 2 -> 3 as well
53	*/
54
55	#include "namespaces.hh"
56
57	class MOADNSException : public runtime_error
58	{
59	public:
60	MOADNSException(const string& str) : runtime_error(str)
61	{}	84✔
62	};
63
64
65	class MOADNSParser;
66
67	class PacketReader
68	{
69	public:
70	PacketReader(const std::string_view& content, uint16_t initialPos=sizeof(dnsheader))
71	: d_pos(initialPos), d_startrecordpos(initialPos), d_content(content)
72	{	1,406,602✔
73	if(content.size() > std::numeric_limits<uint16_t>::max())	1,406,602!
74	throw std::out_of_range("packet too large");	×
75
76	d_recordlen = (uint16_t) content.size();	1,406,602✔
77	not_used = 0;	1,406,602✔
78	}	1,406,602✔
79
80	uint32_t get32BitInt();
81	uint16_t get16BitInt();
82	uint8_t get8BitInt();
83
84	void xfrNodeOrLocatorID(NodeOrLocatorID& val);
85	void xfr48BitInt(uint64_t& val);
86
87	void xfr32BitInt(uint32_t& val)
88	{	3,185,001✔
89	val=get32BitInt();	3,185,001✔
90	}	3,185,001✔
91
92	void xfrIP(uint32_t& val)
93	{	904,535✔
94	xfr32BitInt(val);	904,535✔
95	val=htonl(val);	904,535✔
96	}	904,535✔
97
98	void xfrIP6(std::string &val) {	13,699✔
99	xfrBlob(val, 16);	13,699✔
100	}	13,699✔
101
102	void xfrCAWithoutPort(uint8_t version, ComboAddress &val) {	63✔
103	string blob;	63✔
104	if (version == 4) xfrBlob(blob, 4);	63✔
105	else if (version == 6) xfrBlob(blob, 16);	21!
106	else throw runtime_error("invalid IP protocol");	×
107	val = makeComboAddressFromRaw(version, blob);	63✔
108	}	63✔
109
110	void xfrCAPort(ComboAddress &val) {	×
111	uint16_t port;	×
112	xfr16BitInt(port);	×
113	val.sin4.sin_port = port;	×
114	}	×
115
116	void xfrTime(uint32_t& val)
117	{	1,471,977✔
118	xfr32BitInt(val);	1,471,977✔
119	}	1,471,977✔
120
121
122	void xfr16BitInt(uint16_t& val)
123	{	1,752,809✔
124	val=get16BitInt();	1,752,809✔
125	}	1,752,809✔
126
127	void xfrType(uint16_t& val)
128	{	736,104✔
129	xfr16BitInt(val);	736,104✔
130	}	736,104✔
131
132
133	void xfr8BitInt(uint8_t& val)
134	{	2,516,251✔
135	val=get8BitInt();	2,516,251✔
136	}	2,516,251✔
137
138	void xfrName(DNSName& name, bool /* compress / = false, bool / noDot */ = false)
139	{	918,485✔
140	name = getName();	918,485✔
141	}	918,485✔
142
143	void xfrText(string &text, bool multi=false, bool lenField=true)
144	{	6,119✔
145	text=getText(multi, lenField);	6,119✔
146	}	6,119✔
147
148	void xfrUnquotedText(string &text, bool lenField){	21✔
149	text=getUnquotedText(lenField);	21✔
150	}	21✔
151
152	void xfrBlob(string& blob);
153	void xfrBlobNoSpaces(string& blob, int len);
154	void xfrBlob(string& blob, int length);
155	void xfrHexBlob(string& blob, bool keepReading=false);
156	void xfrSvcParamKeyVals(set<SvcParam> &kvs);
157
158	void getDnsrecordheader(struct dnsrecordheader &ah);
159	void copyRecord(vector<unsigned char>& dest, uint16_t len);
160	void copyRecord(unsigned char* dest, uint16_t len);
161
162	DNSName getName();
163	string getText(bool multi, bool lenField);
164	string getUnquotedText(bool lenField);
165
166
167	bool eof() { return true; };	1,860,798✔
168	const string getRemaining() const {	×
169	return "";	×
170	};	×
171
172	uint16_t getPosition() const
173	{	2,223,380✔
174	return d_pos;	2,223,380✔
175	}	2,223,380✔
176
177	void skip(uint16_t n)
178	{	1,427✔
179	d_pos += n;	1,427✔
180	}	1,427✔
181
182	private:
183	uint16_t d_pos;
184	uint16_t d_startrecordpos; // needed for getBlob later on
185	uint16_t d_recordlen; // ditto
186	uint16_t not_used; // Aligns the whole class on 8-byte boundaries
187	const std::string_view d_content;
188	};
189
190	struct DNSRecord;
191
192	class DNSRecordContent
193	{
194	public:
195	static std::shared_ptr<DNSRecordContent> make(const DNSRecord& dr, PacketReader& pr);
196	static std::shared_ptr<DNSRecordContent> make(const DNSRecord& dr, PacketReader& pr, uint16_t opcode);
197	static std::shared_ptr<DNSRecordContent> make(uint16_t qtype, uint16_t qclass, const string& zone);
198	static string upgradeContent(const DNSName& qname, const QType& qtype, const string& content);
199
200	virtual std::string getZoneRepresentation(bool noDot=false) const = 0;
201	virtual ~DNSRecordContent() = default;	12,768,545✔
202	virtual void toPacket(DNSPacketWriter& pw) const = 0;
203	// returns the wire format of the content, possibly including compressed pointers pointing to the owner name (unless canonic or lowerCase are set)
204	string serialize(const DNSName& qname, bool canonic=false, bool lowerCase=false) const
205	{	3,973,126✔
206	vector<uint8_t> packet;	3,973,126✔
207	DNSPacketWriter pw(packet, g_rootdnsname, 1);	3,973,126✔
208	if(canonic)	3,973,126✔
209	pw.setCanonic(true);	2,551,060✔
210
211	if(lowerCase)	3,973,126✔
212	pw.setLowercase(true);	2,429,515✔
213
214	pw.startRecord(qname, this->getType());	3,973,126✔
215	this->toPacket(pw);	3,973,126✔
216
217	string record;	3,973,126✔
218	pw.getRecordPayload(record); // needs to be called before commit()	3,973,126✔
219	return record;	3,973,126✔
220	}	3,973,126✔
221
222	virtual bool operator==(const DNSRecordContent& rhs) const
223	{	5,581✔
224	return typeid(*this)==typeid(rhs) && this->getZoneRepresentation() == rhs.getZoneRepresentation();	5,581!
225	}	5,581✔
226
227	// parse the content in wire format, possibly including compressed pointers pointing to the owner name
228	static shared_ptr<DNSRecordContent> deserialize(const DNSName& qname, uint16_t qtype, const string& serialized);
229
230	void doRecordCheck(const struct DNSRecord&){}	957,744✔
231
232	typedef std::shared_ptr<DNSRecordContent> makerfunc_t(const struct DNSRecord& dr, PacketReader& pr);
233	typedef std::shared_ptr<DNSRecordContent> zmakerfunc_t(const string& str);
234
235	static void regist(uint16_t cl, uint16_t ty, makerfunc_t* f, zmakerfunc_t* z, const char* name)
236	{	3,171,412✔
237	if(f)	3,171,412✔
238	getTypemap()[pair(cl,ty)]=f;	3,086,401✔
239	if(z)	3,171,412✔
240	getZmakermap()[pair(cl,ty)]=z;	3,086,401✔
241
242	getT2Namemap().emplace(pair(cl, ty), name);	3,171,412✔
243	getN2Typemap().emplace(name, pair(cl, ty));	3,171,412✔
244	}	3,171,412✔
245
246	static void unregist(uint16_t cl, uint16_t ty)
247	{	×
248	auto key = pair(cl, ty);	×
249	getTypemap().erase(key);	×
250	getZmakermap().erase(key);	×
251	}	×
252
253	static bool isUnknownType(const string& name)
254	{	23,924✔
255	return boost::starts_with(name, "TYPE") \|\| boost::starts_with(name, "type");	23,924✔
256	}	23,924✔
257
258	static uint16_t TypeToNumber(const string& name)
259	{	5,342,741✔
260	n2typemap_t::const_iterator iter = getN2Typemap().find(toUpper(name));	5,342,741✔
261	if(iter != getN2Typemap().end())	5,342,741✔
262	return iter->second.second;	5,341,895✔
263
264	if (isUnknownType(name)) {	846✔
265	return pdns::checked_stoi<uint16_t>(name.substr(4));	844✔
266	}	844✔
267
268	throw runtime_error("Unknown DNS type '"+name+"'");	2✔
269	}	846✔
270
271	static const string NumberToType(uint16_t num, uint16_t classnum = QClass::IN)
272	{	2,265,156✔
273	auto iter = getT2Namemap().find(pair(classnum, num));	2,265,156✔
274	if(iter == getT2Namemap().end())	2,265,156✔
275	return "TYPE" + std::to_string(num);	393,675✔
276	// throw runtime_error("Unknown DNS type with numerical id "+std::to_string(num));
277	return iter->second;	1,871,481✔
278	}	2,265,156✔
279
280	/**
281	* \brief Return whether we have implemented a content representation for this type
282	*/
283	static bool isRegisteredType(uint16_t rtype, uint16_t rclass = QClass::IN);
284
285	virtual uint16_t getType() const = 0;
286
287	protected:
288	typedef std::map<std::pair<uint16_t, uint16_t>, makerfunc_t* > typemap_t;
289	typedef std::map<std::pair<uint16_t, uint16_t>, zmakerfunc_t* > zmakermap_t;
290	typedef std::map<std::pair<uint16_t, uint16_t>, string > t2namemap_t;
291	typedef std::map<string, std::pair<uint16_t, uint16_t> > n2typemap_t;
292	static typemap_t& getTypemap();
293	static t2namemap_t& getT2Namemap();
294	static n2typemap_t& getN2Typemap();
295	static zmakermap_t& getZmakermap();
296	};
297
298	struct DNSRecord
299	{
300	DNSRecord() :
301	d_class(QClass::IN)
302	{}	4,792,152✔
303	explicit DNSRecord(const DNSResourceRecord& rr);
304	DNSRecord(const std::string& name,
305	std::shared_ptr<DNSRecordContent> content,
306	const uint16_t type,
307	const uint16_t qclass = QClass::IN,
308	const uint32_t ttl = 86400,
309	const uint16_t clen = 0,
310	const DNSResourceRecord::Place place = DNSResourceRecord::ANSWER) :
311	d_name(DNSName(name)),
312	d_content(std::move(content)),
313	d_type(type),
314	d_class(qclass),
315	d_ttl(ttl),
316	d_clen(clen),
317	d_place(place) {}	296✔
318
319	DNSName d_name;
320	private:
321	std::shared_ptr<const DNSRecordContent> d_content;
322	public:
323	uint16_t d_type{};
324	uint16_t d_class{};
325	uint32_t d_ttl{};
326	uint16_t d_clen{};
327	DNSResourceRecord::Place d_place{DNSResourceRecord::ANSWER};
328
329	[[nodiscard]] std::string print(const std::string& indent = "") const
330	{	536✔
331	std::stringstream s;	536✔
332	s << indent << "Content = " << d_content->getZoneRepresentation() << std::endl;	536✔
333	s << indent << "Type = " << d_type << std::endl;	536✔
334	s << indent << "Class = " << d_class << std::endl;	536✔
335	s << indent << "TTL = " << d_ttl << std::endl;	536✔
336	s << indent << "clen = " << d_clen << std::endl;	536✔
337	s << indent << "Place = " << std::to_string(d_place) << std::endl;	536✔
338	return s.str();	536✔
339	}	536✔
340
341	[[nodiscard]] std::string toString() const
UNCOV 342	{	26✔
UNCOV 343	std::string ret(d_name.toLogString());	26✔
UNCOV 344	ret += '\|';	26✔
UNCOV 345	ret += QType(d_type).toString();	26✔
UNCOV 346	ret += '\|';	26✔
UNCOV 347	ret += getContent()->getZoneRepresentation();	26✔
UNCOV 348	return ret;	26✔
UNCOV 349	}	26✔
350
351	void setContent(const std::shared_ptr<const DNSRecordContent>& content)
352	{	708,393✔
353	d_content = content;	708,393✔
354	}	708,393✔
355
356	void setContent(std::shared_ptr<const DNSRecordContent>&& content)
357	{	3,929,789✔
358	d_content = std::move(content);	3,929,789✔
359	}	3,929,789✔
360
361	[[nodiscard]] const std::shared_ptr<const DNSRecordContent>& getContent() const
362	{	7,887,745✔
363	return d_content;	7,887,745✔
364	}	7,887,745✔
365
366	bool operator<(const DNSRecord& rhs) const
367	{	×
368	if(std::tie(d_name, d_type, d_class, d_ttl) < std::tie(rhs.d_name, rhs.d_type, rhs.d_class, rhs.d_ttl))	×
369	return true;	×
370		×
371	if(std::tie(d_name, d_type, d_class, d_ttl) != std::tie(rhs.d_name, rhs.d_type, rhs.d_class, rhs.d_ttl))	×
372	return false;	×
373		×
374	string lzrp, rzrp;	×
375	if(d_content)	×
376	lzrp=toLower(d_content->getZoneRepresentation());	×
377	if(rhs.d_content)	×
378	rzrp=toLower(rhs.d_content->getZoneRepresentation());	×
379		×
380	return lzrp < rzrp;	×
381	}	×
382
383	// this orders in canonical order and keeps the SOA record on top
384	static bool prettyCompare(const DNSRecord& a, const DNSRecord& b)
385	{	×
386	auto aType = (a.d_type == QType::SOA) ? 0 : a.d_type;	×
387	auto bType = (b.d_type == QType::SOA) ? 0 : b.d_type;	×
388		×
389	if(a.d_name.canonCompare(b.d_name))	×
390	return true;	×
391	if(b.d_name.canonCompare(a.d_name))	×
392	return false;	×
393		×
394	if(std::tie(aType, a.d_class, a.d_ttl) < std::tie(bType, b.d_class, b.d_ttl))	×
395	return true;	×
396		×
397	if(std::tie(aType, a.d_class, a.d_ttl) != std::tie(bType, b.d_class, b.d_ttl))	×
398	return false;	×
399		×
400	string lzrp, rzrp;	×
401	if(a.d_content)	×
402	lzrp = a.d_content->getZoneRepresentation();	×
403	if(b.d_content)	×
404	rzrp = b.d_content->getZoneRepresentation();	×
405		×
406	switch (a.d_type) {	×
407	case QType::TXT:	×
408	case QType::SPF:	×
409	#if !defined(RECURSOR)	×
410	case QType::LUA:	×
411	#endif	×
412	return lzrp < rzrp;	×
413	default:	×
414	return toLower(lzrp) < toLower(rzrp);	×
415	}	×
416	}	×
417
418	bool operator==(const DNSRecord& rhs) const
419	{	15,174✔
420	if (d_type != rhs.d_type \|\| d_class != rhs.d_class \|\| d_name != rhs.d_name) {	15,174!
421	return false;	9,229✔
422	}	9,229✔
423
424	return d_content == rhs.d_content;	5,945✔
425	}	15,174✔
426	};
427
428	struct DNSZoneRecord
429	{
430	int domain_id{-1};
431	uint8_t scopeMask{0};
432	int signttl{0};
433	DNSName wildcardname;
434	bool auth{true};
435	bool disabled{false};
436	DNSRecord dr;
437	};
438
439	class UnknownRecordContent : public DNSRecordContent
440	{
441	public:
442	UnknownRecordContent(const DNSRecord& dr, PacketReader& pr)
443	: d_dr(dr)
444	{	4,737✔
445	pr.copyRecord(d_record, dr.d_clen);	4,737✔
446	}	4,737✔
447
448	UnknownRecordContent(const string& zone);
449
450	string getZoneRepresentation(bool noDot) const override;
451	void toPacket(DNSPacketWriter& pw) const override;
452	uint16_t getType() const override
453	{	909✔
454	return d_dr.d_type;	909✔
455	}	909✔
456
457	const vector<uint8_t>& getRawContent() const
458	{	79✔
459	return d_record;	79✔
460	}	79✔
461
462	private:
463	DNSRecord d_dr;
464	vector<uint8_t> d_record;
465	};
466
467	//! This class can be used to parse incoming packets, and is copyable
468	class MOADNSParser : public boost::noncopyable
469	{
470	public:
471	//! Parse from a string
472	MOADNSParser(bool query, const string& buffer): d_tsigPos(0)
473	{	1,338,323✔
474	init(query, buffer);	1,338,323✔
475	}	1,338,323✔
476
477	//! Parse from a pointer and length
478	MOADNSParser(bool query, const char *packet, unsigned int len) : d_tsigPos(0)
479	{	29,934✔
480	init(query, std::string_view(packet, len));	29,934✔
481	}	29,934✔
482
483	DNSName d_qname;
484	uint16_t d_qclass, d_qtype;
485	dnsheader d_header;
486
487	using answers_t = vector<DNSRecord>;
488
489	//! All answers contained in this packet (everything but the question section)
490	answers_t d_answers;
491
492	uint16_t getTSIGPos() const
493	{	1,294,803✔
494	return d_tsigPos;	1,294,803✔
495	}	1,294,803✔
496
497	bool hasEDNS() const;
498
499	private:
500	void init(bool query, const std::string_view& packet);
501	uint16_t d_tsigPos;
502	};
503
504	string simpleCompress(const string& label, const string& root="");
505	void ageDNSPacket(char* packet, size_t length, uint32_t seconds, const dnsheader_aligned&);
506	void ageDNSPacket(std::string& packet, uint32_t seconds, const dnsheader_aligned&);
507	void editDNSPacketTTL(char* packet, size_t length, const std::function<uint32_t(uint8_t, uint16_t, uint16_t, uint32_t)>& visitor);
508	void clearDNSPacketRecordTypes(vector<uint8_t>& packet, const std::unordered_set<QType>& qtypes);
509	void clearDNSPacketRecordTypes(PacketBuffer& packet, const std::unordered_set<QType>& qtypes);
510	void clearDNSPacketRecordTypes(char* packet, size_t& length, const std::unordered_set<QType>& qtypes);
511	uint32_t getDNSPacketMinTTL(const char* packet, size_t length, bool* seenAuthSOA=nullptr);
512	uint32_t getDNSPacketLength(const char* packet, size_t length);
513	uint16_t getRecordsOfTypeCount(const char* packet, size_t length, uint8_t section, uint16_t type);
514	bool getEDNSUDPPayloadSizeAndZ(const char* packet, size_t length, uint16_t* payloadSize, uint16_t* z);
515	/* call the visitor for every records in the answer, authority and additional sections, passing the section, class, type, ttl, rdatalength and rdata
516	to the visitor. Stops whenever the visitor returns false or at the end of the packet */
517	bool visitDNSPacket(const std::string_view& packet, const std::function<bool(uint8_t, uint16_t, uint16_t, uint32_t, uint16_t, const char*)>& visitor);
518
519	template<typename T>
520	std::shared_ptr<const T> getRR(const DNSRecord& dr)
521	{	1,449,419✔
522	return std::dynamic_pointer_cast<const T>(dr.getContent());	1,449,419✔
523	}	1,449,419✔
524
525	/** Simple DNSPacketMangler. Ritual is: get a pointer into the packet and moveOffset() to beyond your needs
526	* If you survive that, feel free to read from the pointer */
527	class DNSPacketMangler
528	{
529	public:
530	explicit DNSPacketMangler(std::string& packet)
531	: d_packet(packet.data()), d_length(packet.length()), d_notyouroffset(12), d_offset(d_notyouroffset)
532	{}	×
533	DNSPacketMangler(char* packet, size_t length)
534	: d_packet(packet), d_length(length), d_notyouroffset(12), d_offset(d_notyouroffset)
535	{}	4,287,240✔
536
537	/*! Advances past a wire-format domain name
538	* The name is not checked for adherence to length restrictions.
539	* Compression pointers are not followed.
540	*/
541	void skipDomainName()
542	{	8,526,570✔
543	uint8_t len;	8,526,570✔
544	while((len=get8BitInt())) {	17,818,368✔
545	if(len >= 0xc0) { // extended label	13,565,097✔
546	get8BitInt();	4,273,299✔
547	return;	4,273,299✔
548	}	4,273,299✔
549	skipBytes(len);	9,291,798✔
550	}	9,291,798✔
551	}	8,526,570✔
552
553	void skipBytes(uint16_t bytes)
554	{	15,392,873✔
555	moveOffset(bytes);	15,392,873✔
556	}	15,392,873✔
557	void rewindBytes(uint16_t by)
558	{	20✔
559	rewindOffset(by);	20✔
560	}	20✔
561	uint32_t get32BitInt()
562	{	1,196,947✔
563	const char* p = d_packet + d_offset;	1,196,947✔
564	moveOffset(4);	1,196,947✔
565	uint32_t ret;	1,196,947✔
566	memcpy(&ret, p, sizeof(ret));	1,196,947✔
567	return ntohl(ret);	1,196,947✔
568	}	1,196,947✔
569	uint16_t get16BitInt()
570	{	10,882,715✔
571	const char* p = d_packet + d_offset;	10,882,715✔
572	moveOffset(2);	10,882,715✔
573	uint16_t ret;	10,882,715✔
574	memcpy(&ret, p, sizeof(ret));	10,882,715✔
575	return ntohs(ret);	10,882,715✔
576	}	10,882,715✔
577
578	uint8_t get8BitInt()
579	{	21,935,208✔
580	const char* p = d_packet + d_offset;	21,935,208✔
581	moveOffset(1);	21,935,208✔
582	return *p;	21,935,208✔
583	}	21,935,208✔
584
585	void skipRData()
586	{	4,257,317✔
587	int toskip = get16BitInt();	4,257,317✔
588	moveOffset(toskip);	4,257,317✔
589	}	4,257,317✔
590
591	void decreaseAndSkip32BitInt(uint32_t decrease)
592	{	942,677✔
593	const char *p = d_packet + d_offset;	942,677✔
594	moveOffset(4);	942,677✔
595
596	uint32_t tmp;	942,677✔
597	memcpy(&tmp, p, sizeof(tmp));	942,677✔
598	tmp = ntohl(tmp);	942,677✔
599	if (tmp > decrease) {	942,677✔
600	tmp -= decrease;	938,299✔
601	} else {	938,300✔
602	tmp = 0;	4,378✔
603	}	4,378✔
604	tmp = htonl(tmp);	942,677✔
605	memcpy(d_packet + d_offset-4, (const char*)&tmp, sizeof(tmp));	942,677✔
606	}	942,677✔
607
608	void setAndSkip32BitInt(uint32_t value)
609	{	20✔
610	moveOffset(4);	20✔
611
612	value = htonl(value);	20✔
613	memcpy(d_packet + d_offset-4, (const char*)&value, sizeof(value));	20✔
614	}	20✔
615
616	uint32_t getOffset() const
617	{	131✔
618	return d_offset;	131✔
619	}	131✔
620
621	private:
622	void moveOffset(uint16_t by)
623	{	55,903,780✔
624	d_notyouroffset += by;	55,903,780✔
625	if(d_notyouroffset > d_length)	55,903,780✔
626	throw std::out_of_range("dns packet out of range: "+std::to_string(d_notyouroffset) +" > "	40✔
627	+ std::to_string(d_length) );	40✔
628	}	55,903,780✔
629
630	void rewindOffset(uint16_t by)
631	{	20✔
632	if(d_notyouroffset < by)	20!
633	throw std::out_of_range("Rewinding dns packet out of range: "+std::to_string(d_notyouroffset) +" < "	×
634	+ std::to_string(by));	×
635	d_notyouroffset -= by;	20✔
636	if(d_notyouroffset < 12)	20!
637	throw std::out_of_range("Rewinding dns packet out of range: "+std::to_string(d_notyouroffset) +" < "	×
638	+ std::to_string(12));	×
639	}	20✔
640
641	char* d_packet;
642	size_t d_length;
643
644	uint32_t d_notyouroffset; // only 'moveOffset' can touch this
645	const uint32_t& d_offset; // look.. but don't touch
646	};

PowerDNS / pdns / 11213595982

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