pdns/dnswriter.hh

   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 <string>
  24 #include <vector>
  25 #include <map>
  26 #include "dns.hh"
  27 #include "dnsname.hh"
  28 #include "namespaces.hh"
  29 #include "iputils.hh"
  30 #include <arpa/inet.h>
  31
  32
  33 /** this class can be used to write DNS packets. It knows about DNS in the sense that it makes
  34     the packet header and record headers.
  35
  36     The model is:
  37
  38     packetheader (recordheader recordcontent)*
  39
  40     The packetheader needs to be updated with the amount of packets of each kind (answer, auth, additional)
  41
  42     Each recordheader contains the length of a dns record.
  43
  44     Calling convention:
  45
  46     vector<uint8_t> content;
  47     DNSPacketWriter dpw(content, const string& qname, uint16_t qtype, uint16_t qclass=QClass:IN);  // sets the question
  48     dpw.startrecord("this.is.an.ip.address.", ns_t_a);    // does nothing, except store qname and qtype
  49     dpw.xfr32BitInt(0x01020304);                         // adds 4 bytes (0x01020304) to the record buffer
  50     dpw.startrecord("this.is.an.ip.address.", ns_t_a);    // aha! writes out dnsrecord header containing qname and qtype and length 4, plus the recordbuffer, which gets emptied
  51                                                          // new qname and qtype are stored
  52     dpw.xfr32BitInt(0x04030201);                         // adds 4 bytes (0x04030201) to the record buffer
  53     dpw.commit();                                        // writes out dnsrecord header containing qname and qtype and length 4, plus the recordbuffer
  54
  55     // content now contains the ready packet, with 1 question and 2 answers
  56
  57 */
  58
  59 class DNSPacketWriter : public boost::noncopyable
  60 {
  61
  62 public:
  63   //! Start a DNS Packet in the vector passed, with question qname, qtype and qclass
  64   DNSPacketWriter(vector<uint8_t>& content, const DNSName& qname, uint16_t  qtype, uint16_t qclass=QClass::IN, uint8_t opcode=0);
  65
  66   /** Start a new DNS record within this packet for namq, qtype, ttl, class and in the requested place. Note that packets can only be written in natural order -
  67       ANSWER, AUTHORITY, ADDITIONAL */
  68   void startRecord(const DNSName& name, uint16_t qtype, uint32_t ttl=3600, uint16_t qclass=QClass::IN, DNSResourceRecord::Place place=DNSResourceRecord::ANSWER, bool compress=true);
  69
  70   /** Shorthand way to add an Opt-record, for example for EDNS0 purposes */
  71   typedef vector<pair<uint16_t,std::string> > optvect_t;
  72   void addOpt(const uint16_t udpsize, const uint16_t extRCode, const uint16_t ednsFlags, const optvect_t& options=optvect_t(), const uint8_t version=0);
  73
  74   /** needs to be called after the last record is added, but can be called again and again later on. Is called internally by startRecord too.
  75       The content of the vector<> passed to the constructor is inconsistent until commit is called.
  76    */
  77   void commit();
  78
  79   uint32_t size(); // needs to be 32 bit because otherwise we don't see the wrap coming when it happened!
  80
  81   /** Should the packet have grown too big for the writer's liking, rollback removes the record currently being written */
  82   void rollback();
  83
  84   /** Discard all content except the question section */
  85   void truncate();
  86
  87   void xfr48BitInt(uint64_t val);
  88   void xfr32BitInt(uint32_t val);
  89   void xfr16BitInt(uint16_t val);
  90   void xfrType(uint16_t val)
  91   {
  92     xfr16BitInt(val);
  93   }
  94   void xfrIP(const uint32_t& val)
  95   {
  96     xfr32BitInt(htonl(val));
  97   }
  98   void xfrIP6(const std::string& val)
  99   {
 100     xfrBlob(val,16);
 101   }
 102
 103   void xfrCAWithoutPort(uint8_t version, ComboAddress &val)
 104   {
 105     if (version == 4) xfrIP(val.sin4.sin_addr.s_addr);
 106     else if (version == 6) {
 107       string blob;
 108       blob.assign((const char*)val.sin6.sin6_addr.s6_addr, 16);
 109       xfrBlob(blob, 16);
 110     }
 111     else throw runtime_error("invalid IP protocol");
 112   }
 113
 114   void xfrCAPort(ComboAddress &val)
 115   {
 116     uint16_t port;
 117     port = val.sin4.sin_port;
 118     xfr16BitInt(port);
 119   }
 120
 121   void xfrTime(const uint32_t& val)
 122   {
 123     xfr32BitInt(val);
 124   }
 125
 126   void xfr8BitInt(uint8_t val);
 127
 128   void xfrName(const DNSName& label, bool compress=false, bool noDot=false);
 129   void xfrText(const string& text, bool multi=false, bool lenField=true);
 130   void xfrUnquotedText(const string& text, bool lenField);
 131   void xfrBlob(const string& blob, int len=-1);
 132   void xfrBlobNoSpaces(const string& blob, int len=-1);
 133   void xfrHexBlob(const string& blob, bool keepReading=false);
 134
 135   dnsheader* getHeader();
 136   void getRecordPayload(string& records); // call __before commit__
 137
 138   void setCanonic(bool val)
 139   {
 140     d_canonic=val;
 141   }
 142
 143   void setLowercase(bool val)
 144   {
 145     d_lowerCase=val;
 146   }
 147   vector <uint8_t>& getContent()
 148   {
 149     return d_content;
 150   }
 151   bool eof() { return true; } // we don't know how long the record should be
 152
 153   const string getRemaining() const {
 154     return "";
 155   }
 156 private:
 157   uint16_t lookupName(const DNSName& name, uint16_t* matchlen);
 158   vector<uint16_t> d_namepositions;
 159   // We declare 1 uint_16 in the public section, these 3 align on a 8-byte boundary
 160   uint16_t d_sor;
 161   uint16_t d_rollbackmarker; // start of last complete packet, for rollback
 162
 163   vector <uint8_t>& d_content;
 164   DNSName d_qname;
 165
 166   uint16_t d_truncatemarker; // end of header, for truncate
 167   DNSResourceRecord::Place d_recordplace;
 168   bool d_canonic, d_lowerCase, d_compress{false};
 169 };
 170
 171 typedef vector<pair<string::size_type, string::size_type> > labelparts_t;
 172 // bool labeltokUnescape(labelparts_t& parts, const DNSName& label);
 173 std::vector<string> segmentDNSText(const string& text); // from dnslabeltext.rl
 174 std::deque<string> segmentDNSName(const string& input); // from dnslabeltext.rl