modules/bindbackend/bindbackend2.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
  23 #ifndef PDNS_BINDBACKEND_HH
  24 #define PDNS_BINDBACKEND_HH
  25
  26 #include <string>
  27 #include <map>
  28 #include <set>
  29 #include <pthread.h>
  30 #include <time.h>
  31 #include <fstream>
  32 #include <mutex>
  33 #include <boost/utility.hpp>
  34
  35 #include <boost/tuple/tuple.hpp>
  36 #include <boost/tuple/tuple_comparison.hpp>
  37 #include <boost/multi_index_container.hpp>
  38 #include <boost/multi_index/hashed_index.hpp>
  39 #include <boost/multi_index/ordered_index.hpp>
  40 #include <boost/multi_index/identity.hpp>
  41 #include <boost/multi_index/member.hpp>
  42 #include <sys/types.h>
  43 #include <sys/stat.h>
  44 #include <unistd.h>
  45 #include "pdns/lock.hh"
  46 #include "pdns/misc.hh"
  47 #include "pdns/dnsbackend.hh"
  48 #include "pdns/namespaces.hh"
  49 #include "pdns/backends/gsql/ssql.hh"
  50
  51 using namespace ::boost::multi_index;
  52
  53 /**
  54   This struct is used within the Bind2Backend to store DNS information. It is
  55   almost identical to a DNSResourceRecord, but then a bit smaller and with
  56   different sorting rules, which make sure that the SOA record comes up front.
  57 */
  58
  59 struct Bind2DNSRecord
  60 {
  61   DNSName qname;
  62   string content;
  63   string nsec3hash;
  64   uint32_t ttl;
  65   uint16_t qtype;
  66   mutable bool auth;
  67   bool operator<(const Bind2DNSRecord& rhs) const
  68   {
  69     if(qname.canonCompare(rhs.qname))
  70       return true;
  71     if(rhs.qname.canonCompare(qname))
  72       return false;
  73     if(qtype==QType::SOA && rhs.qtype!=QType::SOA)
  74       return true;
  75     return tie(qtype,content, ttl) < tie(rhs.qtype, rhs.content, rhs.ttl);
  76   }
  77 };
  78
  79 struct Bind2DNSCompare : std::less<Bind2DNSRecord>
  80 {
  81     using std::less<Bind2DNSRecord>::operator();
  82     // use operator<
  83     bool operator() (const DNSName& a, const Bind2DNSRecord& b) const
  84     {return a.canonCompare(b.qname);}
  85     bool operator() (const Bind2DNSRecord& a, const DNSName& b) const
  86     {return a.qname.canonCompare(b);}
  87     bool operator() (const Bind2DNSRecord& a, const Bind2DNSRecord& b) const
  88     {return a.qname.canonCompare(b.qname);}
  89 };
  90
  91 struct NSEC3Tag{};
  92 struct UnorderedNameTag{};
  93
  94 typedef multi_index_container<
  95   Bind2DNSRecord,
  96   indexed_by  <
  97                 ordered_non_unique<identity<Bind2DNSRecord>, Bind2DNSCompare >,
  98                 hashed_non_unique<tag<UnorderedNameTag>, member<Bind2DNSRecord, DNSName, &Bind2DNSRecord::qname> >,
  99                 ordered_non_unique<tag<NSEC3Tag>, member<Bind2DNSRecord, std::string, &Bind2DNSRecord::nsec3hash> >
 100               >
 101 > recordstorage_t;
 102
 103 template <typename T>
 104 class LookButDontTouch //  : public boost::noncopyable
 105 {
 106 public:
 107   LookButDontTouch()
 108   {
 109   }
 110   LookButDontTouch(shared_ptr<T> records) : d_records(records)
 111   {
 112   }
 113
 114   shared_ptr<const T> get()
 115   {
 116     shared_ptr<const T> ret;
 117     {
 118       std::lock_guard<std::mutex> lock(s_lock);
 119       ret = d_records;
 120     }
 121     return ret;
 122   }
 123
 124   size_t getEntriesCount() const
 125   {
 126     std::lock_guard<std::mutex> lock(s_lock);
 127     return d_records->size();
 128   }
 129
 130 private:
 131   static std::mutex s_lock;
 132   shared_ptr<T> d_records;
 133 };
 134
 135
 136 /** Class which describes all metadata of a domain for storage by the Bind2Backend, and also contains a pointer to a vector of Bind2DNSRecord's */
 137 class BB2DomainInfo
 138 {
 139 public:
 140   BB2DomainInfo();
 141   void setCtime();
 142   bool current();
 143   //! configure how often this domain should be checked for changes (on disk)
 144   void setCheckInterval(time_t seconds);
 145   time_t getCheckInterval() const
 146   {
 147     return d_checkinterval;
 148   }
 149
 150   DNSName d_name;   //!< actual name of the domain
 151   DomainInfo::DomainKind d_kind; //!< the kind of domain
 152   string d_filename; //!< full absolute filename of the zone on disk
 153   string d_status; //!< message describing status of a domain, for human consumption
 154   vector<ComboAddress> d_masters;     //!< IP address of the master of this domain
 155   set<string> d_also_notify; //!< IP list of hosts to also notify
 156   LookButDontTouch<recordstorage_t> d_records;  //!< the actual records belonging to this domain
 157   time_t d_ctime{0};  //!< last known ctime of the file on disk
 158   time_t d_lastcheck{0}; //!< last time domain was checked for freshness
 159   uint32_t d_lastnotified{0}; //!< Last serial number we notified our slaves of
 160   unsigned int d_id;  //!< internal id of the domain
 161   mutable bool d_checknow; //!< if this domain has been flagged for a check
 162   bool d_loaded;  //!< if a domain is loaded
 163   bool d_wasRejectedLastReload{false}; //!< if the domain was rejected during Bind2Backend::queueReloadAndStore
 164
 165 private:
 166   time_t getCtime();
 167   time_t d_checkinterval;
 168 };
 169
 170 class SSQLite3;
 171 class NSEC3PARAMRecordContent;
 172
 173 struct NameTag
 174 {};
 175
 176 class Bind2Backend : public DNSBackend
 177 {
 178 public:
 179   Bind2Backend(const string &suffix="", bool loadZones=true);
 180   ~Bind2Backend();
 181   void getUnfreshSlaveInfos(vector<DomainInfo> *unfreshDomains) override;
 182   void getUpdatedMasters(vector<DomainInfo> *changedDomains) override;
 183   bool getDomainInfo(const DNSName &domain, DomainInfo &di, bool getSerial=true ) override;
 184   time_t getCtime(const string &fname);
 185    // DNSSEC
 186   bool getBeforeAndAfterNamesAbsolute(uint32_t id, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after) override;
 187   void lookup(const QType &, const DNSName &qdomain, int zoneId, DNSPacket *p=nullptr) override;
 188   bool list(const DNSName &target, int id, bool include_disabled=false) override;
 189   bool get(DNSResourceRecord &) override;
 190   void getAllDomains(vector<DomainInfo> *domains, bool include_disabled=false) override;
 191
 192   static DNSBackend *maker();
 193   static pthread_mutex_t s_startup_lock;
 194
 195   void setFresh(uint32_t domain_id) override;
 196   void setNotified(uint32_t id, uint32_t serial) override;
 197   bool startTransaction(const DNSName &qname, int id) override;
 198   bool feedRecord(const DNSResourceRecord &rr, const DNSName &ordername, bool ordernameIsNSEC3=false) override;
 199   bool commitTransaction() override;
 200   bool abortTransaction() override;
 201   void alsoNotifies(const DNSName &domain, set<string> *ips) override;
 202   bool searchRecords(const string &pattern, int maxResults, vector<DNSResourceRecord>& result) override;
 203
 204 // the DNSSEC related (getDomainMetadata has broader uses too)
 205   bool getAllDomainMetadata(const DNSName& name, std::map<std::string, std::vector<std::string> >& meta) override;
 206   bool getDomainMetadata(const DNSName& name, const std::string& kind, std::vector<std::string>& meta) override;
 207   bool setDomainMetadata(const DNSName& name, const std::string& kind, const std::vector<std::string>& meta) override;
 208   bool getDomainKeys(const DNSName& name, std::vector<KeyData>& keys) override;
 209   bool removeDomainKey(const DNSName& name, unsigned int id) override;
 210   bool addDomainKey(const DNSName& name, const KeyData& key, int64_t& id) override;
 211   bool activateDomainKey(const DNSName& name, unsigned int id) override;
 212   bool deactivateDomainKey(const DNSName& name, unsigned int id) override;
 213   bool publishDomainKey(const DNSName& name, unsigned int id) override;
 214   bool unpublishDomainKey(const DNSName& name, unsigned int id) override;
 215   bool getTSIGKey(const DNSName& name, DNSName* algorithm, string* content) override;
 216   bool setTSIGKey(const DNSName& name, const DNSName& algorithm, const string& content) override;
 217   bool deleteTSIGKey(const DNSName& name) override;
 218   bool getTSIGKeys(std::vector< struct TSIGKey > &keys) override;
 219   bool doesDNSSEC() override;
 220   // end of DNSSEC
 221
 222   typedef multi_index_container < BB2DomainInfo ,
 223                                   indexed_by < ordered_unique<member<BB2DomainInfo, unsigned int, &BB2DomainInfo::d_id> >,
 224                                                ordered_unique<tag<NameTag>, member<BB2DomainInfo, DNSName, &BB2DomainInfo::d_name> >
 225                                                > > state_t;
 226   static state_t s_state;
 227   static pthread_rwlock_t s_state_lock;
 228
 229   void parseZoneFile(BB2DomainInfo *bbd);
 230   void rediscover(string *status=nullptr) override;
 231
 232
 233   // for supermaster support
 234   bool superMasterBackend(const string &ip, const DNSName &domain, const vector<DNSResourceRecord>&nsset, string *nameserver, string *account, DNSBackend **db) override;
 235   static pthread_mutex_t s_supermaster_config_lock;
 236   bool createSlaveDomain(const string &ip, const DNSName &domain, const string &nameserver, const string &account) override;
 237
 238 private:
 239   void setupDNSSEC();
 240   void setupStatements();
 241   void freeStatements();
 242   static bool safeGetBBDomainInfo(int id, BB2DomainInfo* bbd);
 243   static void safePutBBDomainInfo(const BB2DomainInfo& bbd);
 244   static bool safeGetBBDomainInfo(const DNSName& name, BB2DomainInfo* bbd);
 245   static bool safeRemoveBBDomainInfo(const DNSName& name);
 246   shared_ptr<SSQLite3> d_dnssecdb;
 247   bool getNSEC3PARAM(const DNSName& name, NSEC3PARAMRecordContent* ns3p);
 248   class handle
 249   {
 250   public:
 251     bool get(DNSResourceRecord &);
 252     void reset();
 253
 254     handle();
 255
 256     shared_ptr<const recordstorage_t > d_records;
 257     recordstorage_t::index<UnorderedNameTag>::type::const_iterator d_iter, d_end_iter;
 258
 259     recordstorage_t::const_iterator d_qname_iter, d_qname_end;
 260
 261     DNSName qname;
 262     DNSName domain;
 263
 264     int id;
 265     QType qtype;
 266     bool d_list;
 267     bool mustlog;
 268
 269   private:
 270     bool get_normal(DNSResourceRecord &);
 271     bool get_list(DNSResourceRecord &);
 272
 273     void operator=(const handle& ); // don't go copying this
 274     handle(const handle &);
 275   };
 276
 277   unique_ptr<SSqlStatement> d_getAllDomainMetadataQuery_stmt;
 278   unique_ptr<SSqlStatement> d_getDomainMetadataQuery_stmt;
 279   unique_ptr<SSqlStatement> d_deleteDomainMetadataQuery_stmt;
 280   unique_ptr<SSqlStatement> d_insertDomainMetadataQuery_stmt;
 281   unique_ptr<SSqlStatement> d_getDomainKeysQuery_stmt;
 282   unique_ptr<SSqlStatement> d_deleteDomainKeyQuery_stmt;
 283   unique_ptr<SSqlStatement> d_insertDomainKeyQuery_stmt;
 284   unique_ptr<SSqlStatement> d_GetLastInsertedKeyIdQuery_stmt;
 285   unique_ptr<SSqlStatement> d_activateDomainKeyQuery_stmt;
 286   unique_ptr<SSqlStatement> d_deactivateDomainKeyQuery_stmt;
 287   unique_ptr<SSqlStatement> d_publishDomainKeyQuery_stmt;
 288   unique_ptr<SSqlStatement> d_unpublishDomainKeyQuery_stmt;
 289   unique_ptr<SSqlStatement> d_getTSIGKeyQuery_stmt;
 290   unique_ptr<SSqlStatement> d_setTSIGKeyQuery_stmt;
 291   unique_ptr<SSqlStatement> d_deleteTSIGKeyQuery_stmt;
 292   unique_ptr<SSqlStatement> d_getTSIGKeysQuery_stmt;
 293
 294   string d_transaction_tmpname;
 295   string d_logprefix;
 296   set<string> alsoNotify; //!< this is used to store the also-notify list of interested peers.
 297   std::unique_ptr<ofstream> d_of;
 298   handle d_handle;
 299   static string s_binddirectory;                              //!< this is used to store the 'directory' setting of the bind configuration
 300   static int s_first;                                  //!< this is raised on construction to prevent multiple instances of us being generated
 301   int d_transaction_id;
 302   static bool s_ignore_broken_records;
 303   bool d_hybrid;
 304
 305   BB2DomainInfo createDomainEntry(const DNSName& domain, const string &filename); //!< does not insert in s_state
 306
 307   void queueReloadAndStore(unsigned int id);
 308   static bool findBeforeAndAfterUnhashed(std::shared_ptr<const recordstorage_t>& records, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after);
 309   static void insertRecord(std::shared_ptr<recordstorage_t>& records, const DNSName& zoneName, const DNSName &qname, const QType &qtype, const string &content, int ttl, const std::string& hashed=string(), bool *auth=nullptr);
 310   void reload() override;
 311   static string DLDomStatusHandler(const vector<string>&parts, Utility::pid_t ppid);
 312   static string DLDomExtendedStatusHandler(const vector<string>&parts, Utility::pid_t ppid);
 313   static string DLListRejectsHandler(const vector<string>&parts, Utility::pid_t ppid);
 314   static string DLReloadNowHandler(const vector<string>&parts, Utility::pid_t ppid);
 315   static string DLAddDomainHandler(const vector<string>&parts, Utility::pid_t ppid);
 316   static void fixupOrderAndAuth(std::shared_ptr<recordstorage_t>& records, const DNSName& zoneName, bool nsec3zone, NSEC3PARAMRecordContent ns3pr);
 317   static void doEmptyNonTerminals(std::shared_ptr<recordstorage_t>& records, const DNSName& zoneName, bool nsec3zone, NSEC3PARAMRecordContent ns3pr);
 318   void loadConfig(string *status=nullptr);
 319 };
 320
 321 #endif /* PDNS_BINDBACKEND_HH */