2 * This file is part of PowerDNS or dnsdist.
3 * Copyright -- PowerDNS.COM B.V. and its contributors
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.
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.
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.
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.
31 // #include <netinet/in.h>
34 #include <boost/tuple/tuple.hpp>
35 #include <boost/tuple/tuple_comparison.hpp>
37 #include "dnswriter.hh"
39 #include "pdnsexception.hh"
42 /** DNS records have three representations:
44 2) parsed in a class, ready for use
47 We should implement bidirectional transitions between 1&2 and 2&3.
48 Currently we have: 1 -> 2
51 We can add: 2 -> 1 easily by reversing the packetwriter
52 And we might be able to reverse 2 -> 3 as well
55 #include "namespaces.hh"
56 #include "namespaces.hh"
58 class MOADNSException : public runtime_error
61 MOADNSException(const string& str) : runtime_error(str)
71 PacketReader(const vector<uint8_t>& content)
72 : d_pos(0), d_startrecordpos(0), d_content(content)
74 if(content.size() > std::numeric_limits<uint16_t>::max())
75 throw std::out_of_range("packet too large");
77 d_recordlen = (uint16_t) content.size();
81 uint32_t get32BitInt();
82 uint16_t get16BitInt();
85 void xfr48BitInt(uint64_t& val);
87 void xfr32BitInt(uint32_t& val)
92 void xfrIP(uint32_t& val)
98 void xfrIP6(std::string &val) {
102 void xfrCAWithoutPort(uint8_t version, ComboAddress &val) {
104 if (version == 4) xfrBlob(blob, 4);
105 else if (version == 6) xfrBlob(blob, 16);
106 else throw runtime_error("invalid IP protocol");
107 val = makeComboAddressFromRaw(version, blob);
110 void xfrCAPort(ComboAddress &val) {
113 val.sin4.sin_port = port;
116 void xfrTime(uint32_t& val)
122 void xfr16BitInt(uint16_t& val)
127 void xfrType(uint16_t& val)
133 void xfr8BitInt(uint8_t& val)
139 void xfrName(DNSName &name, bool compress=false, bool noDot=false)
144 void xfrText(string &text, bool multi=false, bool lenField=true)
146 text=getText(multi, lenField);
149 void xfrUnquotedText(string &text, bool lenField){
150 text=getUnquotedText(lenField);
153 void xfrBlob(string& blob);
154 void xfrBlobNoSpaces(string& blob, int len);
155 void xfrBlob(string& blob, int length);
156 void xfrHexBlob(string& blob, bool keepReading=false);
158 static uint16_t get16BitInt(const vector<unsigned char>&content, uint16_t& pos);
160 void getDnsrecordheader(struct dnsrecordheader &ah);
161 void copyRecord(vector<unsigned char>& dest, uint16_t len);
162 void copyRecord(unsigned char* dest, uint16_t len);
165 string getText(bool multi, bool lenField);
166 string getUnquotedText(bool lenField);
170 bool eof() { return true; };
171 const string getRemaining() const {
176 uint16_t d_startrecordpos; // needed for getBlob later on
177 uint16_t d_recordlen; // ditto
178 uint16_t not_used; // Aligns the whole class on 8-byte boundries
179 const vector<uint8_t>& d_content;
184 class DNSRecordContent
187 static std::shared_ptr<DNSRecordContent> mastermake(const DNSRecord &dr, PacketReader& pr);
188 static std::shared_ptr<DNSRecordContent> mastermake(const DNSRecord &dr, PacketReader& pr, uint16_t opcode);
189 static std::shared_ptr<DNSRecordContent> mastermake(uint16_t qtype, uint16_t qclass, const string& zone);
190 static std::unique_ptr<DNSRecordContent> makeunique(uint16_t qtype, uint16_t qclass, const string& content);
192 virtual std::string getZoneRepresentation(bool noDot=false) const = 0;
193 virtual ~DNSRecordContent() {}
194 virtual void toPacket(DNSPacketWriter& pw)=0;
195 virtual string serialize(const DNSName& qname, bool canonic=false, bool lowerCase=false) // it would rock if this were const, but it is too hard
197 vector<uint8_t> packet;
198 DNSPacketWriter pw(packet, g_rootdnsname, 1);
203 pw.setLowercase(true);
205 pw.startRecord(qname, this->getType());
209 pw.getRecordPayload(record); // needs to be called before commit()
213 virtual bool operator==(const DNSRecordContent& rhs) const
215 return typeid(*this)==typeid(rhs) && this->getZoneRepresentation() == rhs.getZoneRepresentation();
218 static shared_ptr<DNSRecordContent> unserialize(const DNSName& qname, uint16_t qtype, const string& serialized);
220 void doRecordCheck(const struct DNSRecord&){}
222 typedef DNSRecordContent* makerfunc_t(const struct DNSRecord& dr, PacketReader& pr);
223 typedef DNSRecordContent* zmakerfunc_t(const string& str);
225 static void regist(uint16_t cl, uint16_t ty, makerfunc_t* f, zmakerfunc_t* z, const char* name)
228 getTypemap()[make_pair(cl,ty)]=f;
230 getZmakermap()[make_pair(cl,ty)]=z;
232 getT2Namemap().insert(make_pair(make_pair(cl,ty), name));
233 getN2Typemap().insert(make_pair(name, make_pair(cl,ty)));
236 static void unregist(uint16_t cl, uint16_t ty)
238 pair<uint16_t, uint16_t> key=make_pair(cl, ty);
239 getTypemap().erase(key);
240 getZmakermap().erase(key);
243 static uint16_t TypeToNumber(const string& name)
245 n2typemap_t::const_iterator iter = getN2Typemap().find(toUpper(name));
246 if(iter != getN2Typemap().end())
247 return iter->second.second;
249 if(boost::starts_with(name, "TYPE") || boost::starts_with(name, "type"))
250 return (uint16_t) pdns_stou(name.substr(4));
252 throw runtime_error("Unknown DNS type '"+name+"'");
255 static const string NumberToType(uint16_t num, uint16_t classnum=1)
257 t2namemap_t::const_iterator iter = getT2Namemap().find(make_pair(classnum, num));
258 if(iter == getT2Namemap().end())
259 return "TYPE" + std::to_string(num);
260 // throw runtime_error("Unknown DNS type with numerical id "+std::to_string(num));
264 virtual uint16_t getType() const = 0;
267 typedef std::map<std::pair<uint16_t, uint16_t>, makerfunc_t* > typemap_t;
268 typedef std::map<std::pair<uint16_t, uint16_t>, zmakerfunc_t* > zmakermap_t;
269 typedef std::map<std::pair<uint16_t, uint16_t>, string > t2namemap_t;
270 typedef std::map<string, std::pair<uint16_t, uint16_t> > n2typemap_t;
271 static typemap_t& getTypemap();
272 static t2namemap_t& getT2Namemap();
273 static n2typemap_t& getN2Typemap();
274 static zmakermap_t& getZmakermap();
279 DNSRecord() : d_type(0), d_class(QClass::IN), d_ttl(0), d_clen(0), d_place(DNSResourceRecord::ANSWER)
281 explicit DNSRecord(const DNSResourceRecord& rr);
283 std::shared_ptr<DNSRecordContent> d_content;
288 DNSResourceRecord::Place d_place;
290 bool operator<(const DNSRecord& rhs) const
292 if(tie(d_name, d_type, d_class, d_ttl) < tie(rhs.d_name, rhs.d_type, rhs.d_class, rhs.d_ttl))
295 if(tie(d_name, d_type, d_class, d_ttl) != tie(rhs.d_name, rhs.d_type, rhs.d_class, rhs.d_ttl))
300 lzrp=toLower(d_content->getZoneRepresentation());
302 rzrp=toLower(rhs.d_content->getZoneRepresentation());
307 // this orders in canonical order and keeps the SOA record on top
308 static bool prettyCompare(const DNSRecord& a, const DNSRecord& b)
310 auto aType = (a.d_type == QType::SOA) ? 0 : a.d_type;
311 auto bType = (b.d_type == QType::SOA) ? 0 : b.d_type;
313 if(a.d_name.canonCompare(b.d_name))
315 if(b.d_name.canonCompare(a.d_name))
318 if(tie(aType, a.d_class, a.d_ttl) < tie(bType, b.d_class, b.d_ttl))
321 if(tie(aType, a.d_class, a.d_ttl) != tie(bType, b.d_class, b.d_ttl))
326 lzrp=toLower(a.d_content->getZoneRepresentation());
328 rzrp=toLower(b.d_content->getZoneRepresentation());
334 bool operator==(const DNSRecord& rhs) const
336 if(d_type != rhs.d_type || d_class != rhs.d_class || d_name != rhs.d_name)
339 return *d_content == *rhs.d_content;
346 uint8_t scopeMask{0};
348 DNSName wildcardname;
354 //! This class can be used to parse incoming packets, and is copyable
355 class MOADNSParser : public boost::noncopyable
358 //! Parse from a string
359 MOADNSParser(bool query, const string& buffer) : d_tsigPos(0)
361 init(query, buffer.c_str(), (unsigned int)buffer.size());
364 //! Parse from a pointer and length
365 MOADNSParser(bool query, const char *packet, unsigned int len) : d_tsigPos(0)
367 init(query, packet, len);
371 uint16_t d_qclass, d_qtype;
375 typedef vector<pair<DNSRecord, uint16_t > > answers_t;
377 //! All answers contained in this packet (everything *but* the question section)
380 shared_ptr<PacketReader> getPacketReader(uint16_t offset)
382 shared_ptr<PacketReader> pr(new PacketReader(d_content));
387 uint16_t getTSIGPos() const
392 void getDnsrecordheader(struct dnsrecordheader &ah);
393 void init(bool query, const char *packet, unsigned int len);
394 vector<uint8_t> d_content;
398 string simpleCompress(const string& label, const string& root="");
399 void ageDNSPacket(char* packet, size_t length, uint32_t seconds);
400 void ageDNSPacket(std::string& packet, uint32_t seconds);
401 void editDNSPacketTTL(char* packet, size_t length, std::function<uint32_t(uint8_t, uint16_t, uint16_t, uint32_t)> visitor);
402 uint32_t getDNSPacketMinTTL(const char* packet, size_t length);
403 uint32_t getDNSPacketLength(const char* packet, size_t length);
404 uint16_t getRecordsOfTypeCount(const char* packet, size_t length, uint8_t section, uint16_t type);
407 std::shared_ptr<T> getRR(const DNSRecord& dr)
409 return std::dynamic_pointer_cast<T>(dr.d_content);