From: Aki Tuomi <cmouse@cmouse.fi>
Date: Sun, 18 Oct 2015 17:50:17 +0000 (+0300)
Subject: Use RecordPlace enum instead of separate Place enums
X-Git-Tag: dnsdist-1.0.0-alpha1~252^2~13^2
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=e693ff5a3c014d732d2fb94f1ffe799517f95a44;p=pdns

Use RecordPlace enum instead of separate Place enums
---

diff --git a/pdns/dbdnsseckeeper.cc b/pdns/dbdnsseckeeper.cc
index 1ea6e6172..23dd32f8e 100644
--- a/pdns/dbdnsseckeeper.cc
+++ b/pdns/dbdnsseckeeper.cc
@@ -422,12 +422,12 @@ bool DNSSECKeeper::secureZone(const DNSName& name, int algorithm, int size)
 
 bool DNSSECKeeper::getPreRRSIGs(UeberBackend& db, const DNSName& signer, const DNSName& qname,
         const DNSName& wildcardname, const QType& qtype,
-        DNSPacketWriter::Place signPlace, vector<DNSResourceRecord>& rrsigs, uint32_t signTTL)
+        DNSResourceRecord::Place signPlace, vector<DNSResourceRecord>& rrsigs, uint32_t signTTL)
 {
   vector<DNSResourceRecord> sigs;
   if(db.getDirectRRSIGs(signer, wildcardname.countLabels() ? wildcardname : qname, qtype, sigs)) {
     BOOST_FOREACH(DNSResourceRecord &rr, sigs) {
-      rr.d_place = (DNSResourceRecord::Place)signPlace;
+      rr.d_place = signPlace;
       rr.ttl = signTTL;
       rrsigs.push_back(rr);
     }
@@ -450,7 +450,7 @@ bool DNSSECKeeper::getPreRRSIGs(UeberBackend& db, const DNSName& signer, const D
                         // cerr<<"Got it"<<endl;
                         if (wildcardname.countLabels())
                                 rr.qname = qname;
-                        rr.d_place = static_cast<DNSResourceRecord::Place>(signPlace);
+                        rr.d_place = signPlace;
                         rr.ttl = signTTL;
                         rrsigs.push_back(rr);
                 }
diff --git a/pdns/dns.hh b/pdns/dns.hh
index aa645f42e..05e17d183 100644
--- a/pdns/dns.hh
+++ b/pdns/dns.hh
@@ -54,7 +54,6 @@ struct SOAData
   uint8_t scopeMask;
 };
 
-
 class RCode
 {
 public:
@@ -78,6 +77,7 @@ public:
   ~DNSResourceRecord(){};
 
   enum Place : uint8_t {QUESTION=0, ANSWER=1, AUTHORITY=2, ADDITIONAL=3}; //!< Type describing the positioning of a DNSResourceRecord within, say, a DNSPacket
+
   void setContent(const string& content);
   string getZoneRepresentation() const;
 
diff --git a/pdns/dnspacket.cc b/pdns/dnspacket.cc
index cf3e6480c..33fea5018 100644
--- a/pdns/dnspacket.cc
+++ b/pdns/dnspacket.cc
@@ -209,7 +209,7 @@ vector<DNSResourceRecord*> DNSPacket::getAPRecords()
       i!=d_rrs.end();
       ++i)
     {
-      if(i->d_place!=DNSResourceRecord::ADDITIONAL && 
+      if(i->d_place!=DNSResourceRecord::ADDITIONAL &&
          (i->qtype.getCode()==QType::MX ||
           i->qtype.getCode()==QType::NS ||
           i->qtype.getCode()==QType::SRV))
@@ -230,7 +230,7 @@ vector<DNSResourceRecord*> DNSPacket::getAnswerRecords()
       i!=d_rrs.end();
       ++i)
     {
-      if(i->d_place!=DNSResourceRecord::ADDITIONAL) 
+      if(i->d_place!=DNSResourceRecord::ADDITIONAL)
         arrs.push_back(&*i);
     }
   return arrs;
@@ -326,7 +326,7 @@ void DNSPacket::wrapup()
         if(pos->content.empty())  // empty contents confuse the MOADNS setup
           pos->content=".";
         
-        pw.startRecord(pos->qname, pos->qtype.getCode(), pos->ttl, pos->qclass, (DNSPacketWriter::Place)pos->d_place); 
+        pw.startRecord(pos->qname, pos->qtype.getCode(), pos->ttl, pos->qclass, pos->d_place);
         shared_ptr<DNSRecordContent> drc(DNSRecordContent::mastermake(pos->qtype.getCode(), pos->qclass, pos->content));
               drc->toPacket(pw);
         if(pw.size() + 20U > (d_tcp ? 65535 : getMaxReplyLen())) { // 20 = room for EDNS0
diff --git a/pdns/dnsparser.cc b/pdns/dnsparser.cc
index b2b67b4f5..af8aedbc5 100644
--- a/pdns/dnsparser.cc
+++ b/pdns/dnsparser.cc
@@ -180,7 +180,7 @@ DNSRecordContent* DNSRecordContent::mastermake(const DNSRecord &dr, PacketReader
   // For opcode UPDATE and where the DNSRecord is an answer record, we don't care about content, because this is
   // not used within the prerequisite section of RFC2136, so - we can simply use unknownrecordcontent.
   // For section 3.2.3, we do need content so we need to get it properly. But only for the correct Qclasses.
-  if (oc == Opcode::Update && dr.d_place == DNSRecord::Answer && dr.d_class != 1)
+  if (oc == Opcode::Update && dr.d_place == DNSResourceRecord::ANSWER && dr.d_class != 1)
     return new UnknownRecordContent(dr, pr);
 
   uint16_t searchclass = (dr.d_type == QType::OPT) ? 1 : dr.d_class; // class is invalid for OPT
@@ -268,11 +268,11 @@ void MOADNSParser::init(const char *packet, unsigned int len)
       DNSRecord dr;
       
       if(n < d_header.ancount)
-        dr.d_place=DNSRecord::Answer;
+        dr.d_place=DNSResourceRecord::ANSWER;
       else if(n < d_header.ancount + d_header.nscount)
-        dr.d_place=DNSRecord::Nameserver;
+        dr.d_place=DNSResourceRecord::AUTHORITY;
       else 
-        dr.d_place=DNSRecord::Additional;
+        dr.d_place=DNSResourceRecord::ADDITIONAL;
       
       unsigned int recordStartPos=pr.d_pos;
 
diff --git a/pdns/dnsparser.hh b/pdns/dnsparser.hh
index fa6664958..63318b901 100644
--- a/pdns/dnsparser.hh
+++ b/pdns/dnsparser.hh
@@ -273,7 +273,7 @@ struct DNSRecord
   uint16_t d_class;
   uint32_t d_ttl;
   uint16_t d_clen;
-  enum Place : uint8_t {Answer=1, Nameserver=2, Additional=3} d_place;
+  DNSResourceRecord::Place d_place;
 
   bool operator<(const DNSRecord& rhs) const
   {
diff --git a/pdns/dnsproxy.cc b/pdns/dnsproxy.cc
index 4d8858d44..166d0f58b 100644
--- a/pdns/dnsproxy.cc
+++ b/pdns/dnsproxy.cc
@@ -247,7 +247,7 @@ void DNSProxy::mainloop(void)
 	  //	  cerr<<"Got completion, "<<mdp.d_answers.size()<<" answers, rcode: "<<mdp.d_header.rcode<<endl;
 	  for(MOADNSParser::answers_t::const_iterator j=mdp.d_answers.begin(); j!=mdp.d_answers.end(); ++j) {        
 	    //	    cerr<<"comp: "<<(int)j->first.d_place-1<<" "<<j->first.d_label<<" " << DNSRecordContent::NumberToType(j->first.d_type)<<" "<<j->first.d_content->getZoneRepresentation()<<endl;
-	    if(j->first.d_place == DNSRecord::Answer || (j->first.d_place == DNSRecord::Nameserver && j->first.d_type == QType::SOA)) {
+	    if(j->first.d_place == DNSResourceRecord::ANSWER || (j->first.d_place == DNSResourceRecord::AUTHORITY && j->first.d_type == QType::SOA)) {
 	    
 	      DNSResourceRecord rr;
 
@@ -255,7 +255,7 @@ void DNSProxy::mainloop(void)
 		rr.qname=i->second.aname;
 		rr.qtype = j->first.d_type;
 		rr.ttl=j->first.d_ttl;
-		rr.d_place= (DNSResourceRecord::Place)j->first.d_place;
+		rr.d_place= j->first.d_place;
 		rr.content=j->first.d_content->getZoneRepresentation();
 		i->second.complete->addRecord(rr);
 	      }
diff --git a/pdns/dnsrecords.cc b/pdns/dnsrecords.cc
index 0f005dfab..7dd3442b4 100644
--- a/pdns/dnsrecords.cc
+++ b/pdns/dnsrecords.cc
@@ -74,7 +74,7 @@ DNSResourceRecord::DNSResourceRecord(const DNSRecord &p) {
   qclass = p.d_class;
   disabled=false;
   qname = p.d_name;
-  d_place = (DNSResourceRecord::Place)p.d_place;
+  d_place = p.d_place;
   // if(!qname.empty())
   //   boost::erase_tail(qname, 1); // strip .
 
@@ -85,7 +85,7 @@ DNSResourceRecord::DNSResourceRecord(const DNSRecord &p) {
   signttl = 0;
   domain_id = -1;
   qclass = p.d_class;
-  d_place = static_cast<DNSResourceRecord::Place>(p.d_place);
+  d_place = p.d_place;
   scopeMask = 0;
 }
 
@@ -495,7 +495,7 @@ bool getEDNSOpts(const MOADNSParser& mdp, EDNSOpts* eo)
 {
   if(mdp.d_header.arcount && !mdp.d_answers.empty()) {
     BOOST_FOREACH(const MOADNSParser::answers_t::value_type& val, mdp.d_answers) {
-      if(val.first.d_place == DNSRecord::Additional && val.first.d_type == QType::OPT) {
+      if(val.first.d_place == DNSResourceRecord::ADDITIONAL && val.first.d_type == QType::OPT) {
         eo->d_packetsize=val.first.d_class;
        
         EDNS0Record stuff;
diff --git a/pdns/dnsreplay.cc b/pdns/dnsreplay.cc
index 154fe8229..6fcafd1ec 100644
--- a/pdns/dnsreplay.cc
+++ b/pdns/dnsreplay.cc
@@ -259,7 +259,7 @@ void WeOrigSlowQueriesDelta(int& weOutstanding, int& origOutstanding, int& weSlo
 void compactAnswerSet(MOADNSParser::answers_t orig, set<DNSRecord>& compacted)
 {
   for(MOADNSParser::answers_t::const_iterator i=orig.begin(); i != orig.end(); ++i)
-    if(i->first.d_place==DNSRecord::Answer)
+    if(i->first.d_place==DNSResourceRecord::ANSWER)
       compacted.insert(i->first);
 }
 
diff --git a/pdns/dnssecinfra.cc b/pdns/dnssecinfra.cc
index 566bb604e..93aa2f947 100644
--- a/pdns/dnssecinfra.cc
+++ b/pdns/dnssecinfra.cc
@@ -624,7 +624,7 @@ void addTSIG(DNSPacketWriter& pw, TSIGRecordContent* trc, const DNSName& tsigkey
     trc->d_mac = calculateHMAC(tsigsecret, toSign, algo);
     //  d_trc->d_mac[0]++; // sabotage
   }
-  pw.startRecord(tsigkeyname, QType::TSIG, 0, QClass::ANY, DNSPacketWriter::ADDITIONAL, false);
+  pw.startRecord(tsigkeyname, QType::TSIG, 0, QClass::ANY, DNSResourceRecord::ADDITIONAL, false);
   trc->toPacket(pw);
   pw.commit();
 }
diff --git a/pdns/dnssecinfra.hh b/pdns/dnssecinfra.hh
index 5a31e3d22..649e07dc0 100644
--- a/pdns/dnssecinfra.hh
+++ b/pdns/dnssecinfra.hh
@@ -119,7 +119,7 @@ struct DNSSECPrivateKey;
 
 void fillOutRRSIG(DNSSECPrivateKey& dpk, const DNSName& signQName, RRSIGRecordContent& rrc, vector<shared_ptr<DNSRecordContent> >& toSign);
 uint32_t getStartOfWeek();
-void addSignature(DNSSECKeeper& dk, UeberBackend& db, const DNSName& signer, const DNSName signQName, const DNSName& wildcardname, uint16_t signQType, uint32_t signTTL, DNSPacketWriter::Place signPlace,
+void addSignature(DNSSECKeeper& dk, UeberBackend& db, const DNSName& signer, const DNSName signQName, const DNSName& wildcardname, uint16_t signQType, uint32_t signTTL, DNSResourceRecord::Place signPlace,
   vector<shared_ptr<DNSRecordContent> >& toSign, vector<DNSResourceRecord>& outsigned, uint32_t origTTL);
 int getRRSIGsForRRSET(DNSSECKeeper& dk, const DNSName& signer, const DNSName signQName, uint16_t signQType, uint32_t signTTL,
   vector<shared_ptr<DNSRecordContent> >& toSign, vector<RRSIGRecordContent> &rrc);
diff --git a/pdns/dnsseckeeper.hh b/pdns/dnsseckeeper.hh
index b5bb66c88..3f03006a4 100644
--- a/pdns/dnsseckeeper.hh
+++ b/pdns/dnsseckeeper.hh
@@ -86,7 +86,7 @@ public:
   bool unsetNSEC3PARAM(const DNSName& zname);
   void clearAllCaches();
   void clearCaches(const DNSName& name);
-  bool getPreRRSIGs(UeberBackend& db, const DNSName& signer, const DNSName& qname, const DNSName& wildcardname, const QType& qtype, DNSPacketWriter::Place, vector<DNSResourceRecord>& rrsigs, uint32_t signTTL);
+  bool getPreRRSIGs(UeberBackend& db, const DNSName& signer, const DNSName& qname, const DNSName& wildcardname, const QType& qtype, DNSResourceRecord::Place, vector<DNSResourceRecord>& rrsigs, uint32_t signTTL);
   bool isPresigned(const DNSName& zname);
   bool setPresigned(const DNSName& zname);
   bool unsetPresigned(const DNSName& zname);
diff --git a/pdns/dnssecsigner.cc b/pdns/dnssecsigner.cc
index 50398e692..61db72998 100644
--- a/pdns/dnssecsigner.cc
+++ b/pdns/dnssecsigner.cc
@@ -92,7 +92,7 @@ int getRRSIGsForRRSET(DNSSECKeeper& dk, const DNSName& signer, const DNSName sig
 
 // this is the entrypoint from DNSPacket
 void addSignature(DNSSECKeeper& dk, UeberBackend& db, const DNSName& signer, const DNSName signQName, const DNSName& wildcardname, uint16_t signQType,
-  uint32_t signTTL, DNSPacketWriter::Place signPlace, 
+  uint32_t signTTL, DNSResourceRecord::Place signPlace,
   vector<shared_ptr<DNSRecordContent> >& toSign, vector<DNSResourceRecord>& outsigned, uint32_t origTTL)
 {
   //cerr<<"Asked to sign '"<<signQName<<"'|"<<DNSRecordContent::NumberToType(signQType)<<", "<<toSign.size()<<" records\n";
@@ -117,7 +117,7 @@ void addSignature(DNSSECKeeper& dk, UeberBackend& db, const DNSName& signer, con
     else
       rr.ttl=signTTL;
     rr.auth=false;
-    rr.d_place = static_cast<DNSResourceRecord::Place> (signPlace);
+    rr.d_place = signPlace;
     BOOST_FOREACH(RRSIGRecordContent& rrc, rrcs) {
       rr.content = rrc.getZoneRepresentation();
       outsigned.push_back(rr);
@@ -210,7 +210,7 @@ void addRRSigs(DNSSECKeeper& dk, UeberBackend& db, const set<DNSName>& authSet,
   uint32_t signTTL=0;
   uint32_t origTTL=0;
   
-  DNSPacketWriter::Place signPlace=DNSPacketWriter::ANSWER;
+  DNSResourceRecord::Place signPlace=DNSResourceRecord::ANSWER;
   vector<shared_ptr<DNSRecordContent> > toSign;
 
   vector<DNSResourceRecord> signedRecords;
@@ -230,7 +230,7 @@ void addRRSigs(DNSSECKeeper& dk, UeberBackend& db, const set<DNSName>& authSet,
     else
       signTTL = pos->ttl;
     origTTL = pos->ttl;
-    signPlace = static_cast<DNSPacketWriter::Place>(pos->d_place);
+    signPlace = pos->d_place;
     if(pos->auth || pos->qtype.getCode() == QType::DS) {
       string content = pos->content;
       if(!pos->content.empty() && pos->qtype.getCode()==QType::TXT && pos->content[0]!='"') {
diff --git a/pdns/dnswriter.cc b/pdns/dnswriter.cc
index 2154cf5cc..eda9b87fc 100644
--- a/pdns/dnswriter.cc
+++ b/pdns/dnswriter.cc
@@ -55,7 +55,7 @@ DNSPacketWriter::DNSPacketWriter(vector<uint8_t>& content, const DNSName& qname,
   d_recordttl = 0;
   d_recordqtype = 0;
   d_recordqclass = QClass::IN;
-  d_recordplace = DNSPacketWriter::ANSWER;
+  d_recordplace = DNSResourceRecord::ANSWER;
 }
 
 dnsheader* DNSPacketWriter::getHeader()
@@ -63,7 +63,7 @@ dnsheader* DNSPacketWriter::getHeader()
   return (dnsheader*)&*d_content.begin();
 }
 
-void DNSPacketWriter::startRecord(const DNSName& name, uint16_t qtype, uint32_t ttl, uint16_t qclass, Place place, bool compress)
+void DNSPacketWriter::startRecord(const DNSName& name, uint16_t qtype, uint32_t ttl, uint16_t qclass, DNSResourceRecord::Place place, bool compress)
 {
   if(!d_record.empty())
     commit();
@@ -105,7 +105,7 @@ void DNSPacketWriter::addOpt(int udpsize, int extRCode, int Z, const vector<pair
 
   ttl=ntohl(ttl); // will be reversed later on
 
-  startRecord(DNSName(), QType::OPT, ttl, udpsize, ADDITIONAL, false);
+  startRecord(DNSName(), QType::OPT, ttl, udpsize, DNSResourceRecord::ADDITIONAL, false);
   for(optvect_t::const_iterator iter = options.begin(); iter != options.end(); ++iter) {
     xfr16BitInt(iter->first);
     xfr16BitInt(iter->second.length());
@@ -343,13 +343,16 @@ void DNSPacketWriter::commit()
 
   dnsheader* dh=reinterpret_cast<dnsheader*>( &*d_content.begin());
   switch(d_recordplace) {
-  case ANSWER:
+  case DNSResourceRecord::QUESTION:
+    dh->qdcount = htons(ntohs(dh->qdcount) + 1);
+    break;
+  case DNSResourceRecord::ANSWER:
     dh->ancount = htons(ntohs(dh->ancount) + 1);
     break;
-  case AUTHORITY:
+  case DNSResourceRecord::AUTHORITY:
     dh->nscount = htons(ntohs(dh->nscount) + 1);
     break;
-  case ADDITIONAL:
+  case DNSResourceRecord::ADDITIONAL:
     dh->arcount = htons(ntohs(dh->arcount) + 1);
     break;
   }
diff --git a/pdns/dnswriter.hh b/pdns/dnswriter.hh
index af50502e2..da40920e6 100644
--- a/pdns/dnswriter.hh
+++ b/pdns/dnswriter.hh
@@ -39,14 +39,13 @@ class DNSPacketWriter : public boost::noncopyable
 
 public:
   typedef vector<pair<DNSName, uint16_t> > lmap_t;
-  enum Place : uint8_t {ANSWER=1, AUTHORITY=2, ADDITIONAL=3}; 
 
   //! Start a DNS Packet in the vector passed, with question qname, qtype and qclass
   DNSPacketWriter(vector<uint8_t>& content, const DNSName& qname, uint16_t  qtype, uint16_t qclass=QClass::IN, uint8_t opcode=0);
 
   /** 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 -
       ANSWER, AUTHORITY, ADDITIONAL */
-  void startRecord(const DNSName& name, uint16_t qtype, uint32_t ttl=3600, uint16_t qclass=QClass::IN, Place place=ANSWER, bool compress=true);
+  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);
 
   /** Shorthand way to add an Opt-record, for example for EDNS0 purposes */
   typedef vector<pair<uint16_t,std::string> > optvect_t;
@@ -130,7 +129,7 @@ private:
   uint16_t d_recordqtype, d_recordqclass;
 
   uint16_t d_truncatemarker; // end of header, for truncate
-  Place d_recordplace;
+  DNSResourceRecord::Place d_recordplace;
   bool d_canonic, d_lowerCase;
 };
 
diff --git a/pdns/lua-auth.cc b/pdns/lua-auth.cc
index 8b51ff442..672161780 100644
--- a/pdns/lua-auth.cc
+++ b/pdns/lua-auth.cc
@@ -120,7 +120,7 @@ bool AuthLua::axfrfilter(const ComboAddress& remote, const DNSName& zone, const
     if(!getFromTable("place", tmpnum))
       rr.d_place = DNSResourceRecord::ANSWER;
     else
-      rr.d_place = (DNSResourceRecord::Place) tmpnum;
+      rr.d_place = static_cast<DNSResourceRecord::Place>(tmpnum);
 
     /* removes 'value'; keeps 'key' for next iteration */
     lua_pop(d_lua, 1); // table
diff --git a/pdns/lua-pdns.cc b/pdns/lua-pdns.cc
index 99f77504a..3916ed080 100644
--- a/pdns/lua-pdns.cc
+++ b/pdns/lua-pdns.cc
@@ -170,7 +170,7 @@ void popResourceRecordsTable(lua_State *lua, const DNSName &query, vector<DNSRec
   /* get the result */
   DNSRecord rr;
   rr.d_name = query;
-  rr.d_place = DNSRecord::Answer;
+  rr.d_place = DNSResourceRecord::ANSWER;
   rr.d_ttl = 3600;
 
   int tableLen = getLuaTableLength(lua, 2);
@@ -188,7 +188,7 @@ void popResourceRecordsTable(lua_State *lua, const DNSName &query, vector<DNSRec
     if(!getFromTable(lua, "qclass", tmpnum))
       rr.d_class = QClass::IN;
     else {
-      rr.d_class = tmpnum;
+      rr.d_class = static_cast<DNSResourceRecord::Place>(tmpnum);
     }
 
 
@@ -204,11 +204,11 @@ void popResourceRecordsTable(lua_State *lua, const DNSName &query, vector<DNSRec
       rr.d_name = query;
 
     if(!getFromTable(lua, "place", tmpnum))
-      rr.d_place = DNSRecord::Answer;
+      rr.d_place = DNSResourceRecord::ANSWER;
     else {
-      rr.d_place = (DNSRecord::Place) tmpnum;
-      if(rr.d_place > DNSRecord::Additional)
-        rr.d_place = DNSRecord::Additional;
+      rr.d_place = static_cast<DNSResourceRecord::Place>(tmpnum);
+      if(rr.d_place > DNSResourceRecord::ADDITIONAL)
+        rr.d_place = DNSResourceRecord::ADDITIONAL;
     }
 
 
diff --git a/pdns/lua-recursor.cc b/pdns/lua-recursor.cc
index 3c25a7f70..4f4c24f7b 100644
--- a/pdns/lua-recursor.cc
+++ b/pdns/lua-recursor.cc
@@ -115,7 +115,7 @@ int getFakeAAAARecords(const std::string& qname, const std::string& prefix, vect
 
   BOOST_FOREACH(DNSRecord& rr, ret)
   {
-    if(rr.d_type == QType::A && rr.d_place==DNSRecord::Answer) {
+    if(rr.d_type == QType::A && rr.d_place==DNSResourceRecord::ANSWER) {
       ComboAddress ipv4(std::dynamic_pointer_cast<ARecordContent>(rr.d_content)->getCA());
       uint32_t tmp;
       memcpy((void*)&tmp, &ipv4.sin4.sin_addr.s_addr, 4);
@@ -150,7 +150,7 @@ int getFakePTRRecords(const DNSName& qname, const std::string& prefix, vector<DN
   int rcode = directResolve(newquery, QType(QType::PTR), 1, ret);
   BOOST_FOREACH(DNSRecord& rr, ret)
   {
-    if(rr.d_type == QType::PTR && rr.d_place==DNSRecord::Answer) {
+    if(rr.d_type == QType::PTR && rr.d_place==DNSResourceRecord::ANSWER) {
       rr.d_name = qname;
     }
   }
diff --git a/pdns/misc.cc b/pdns/misc.cc
index 16dcab4bf..299010401 100644
--- a/pdns/misc.cc
+++ b/pdns/misc.cc
@@ -554,10 +554,10 @@ void shuffle(vector<DNSRecord>& rrs)
 {
   vector<DNSRecord>::iterator first, second;
   for(first=rrs.begin();first!=rrs.end();++first)
-    if(first->d_place==DNSRecord::Answer && first->d_type != QType::CNAME) // CNAME must come first
+    if(first->d_place==DNSResourceRecord::ANSWER && first->d_type != QType::CNAME) // CNAME must come first
       break;
   for(second=first;second!=rrs.end();++second)
-    if(second->d_place!=DNSRecord::Answer)
+    if(second->d_place!=DNSResourceRecord::ANSWER)
       break;
 
   if(second-first>1)
@@ -565,10 +565,10 @@ void shuffle(vector<DNSRecord>& rrs)
 
   // now shuffle the additional records
   for(first=second;first!=rrs.end();++first)
-    if(first->d_place==DNSRecord::Additional && first->d_type != QType::CNAME) // CNAME must come first
+    if(first->d_place==DNSResourceRecord::ADDITIONAL && first->d_type != QType::CNAME) // CNAME must come first
       break;
   for(second=first; second!=rrs.end(); ++second)
-    if(second->d_place!=DNSRecord::Additional)
+    if(second->d_place!=DNSResourceRecord::ADDITIONAL)
       break;
 
   if(second-first>1)
diff --git a/pdns/pdns_recursor.cc b/pdns/pdns_recursor.cc
index a0632736a..bb21965e0 100644
--- a/pdns/pdns_recursor.cc
+++ b/pdns/pdns_recursor.cc
@@ -622,7 +622,7 @@ void startDoResolve(void *p)
         if(res == RCode::NoError) {
 	        auto i=ret.cbegin();
                 for(; i!= ret.cend(); ++i)
-                  if(i->d_type == dc->d_mdp.d_qtype && i->d_place == DNSRecord::Answer)
+                  if(i->d_type == dc->d_mdp.d_qtype && i->d_place == DNSResourceRecord::ANSWER)
                           break;
                 if(i == ret.cend())
                   (*t_pdl)->nodata(dc->d_remote,local, dc->d_mdp.d_qname, QType(dc->d_mdp.d_qtype), ret, res, &variableAnswer);
@@ -664,12 +664,12 @@ void startDoResolve(void *p)
       if(ret.size()) {
         orderAndShuffle(ret);
         for(auto i=ret.cbegin(); i!=ret.cend(); ++i) {
-          pw.startRecord(i->d_name, i->d_type, i->d_ttl, i->d_class, (DNSPacketWriter::Place)i->d_place);
+          pw.startRecord(i->d_name, i->d_type, i->d_ttl, i->d_class, i->d_place);
           minTTL = min(minTTL, i->d_ttl);
 	  i->d_content->toPacket(pw);
           if(pw.size() > maxanswersize) {
             pw.rollback();
-            if(i->d_place==DNSRecord::Answer)  // only truncate if we actually omitted parts of the answer
+            if(i->d_place==DNSResourceRecord::ANSWER)  // only truncate if we actually omitted parts of the answer
             {
               pw.getHeader()->tc=1;
               pw.truncate();
diff --git a/pdns/recursor_cache.cc b/pdns/recursor_cache.cc
index 0fb1a2c49..6656f9ac5 100644
--- a/pdns/recursor_cache.cc
+++ b/pdns/recursor_cache.cc
@@ -61,7 +61,7 @@ int MemRecursorCache::get(time_t now, const DNSName &qname, const QType& qt, vec
 	    dr.d_class = 1;
 	    dr.d_content = *k; 
 	    dr.d_ttl = i->d_ttd;
-	    dr.d_place = DNSRecord::Answer;
+	    dr.d_place = DNSResourceRecord::ANSWER;
 	    res->push_back(dr);
 	  }
 	}
diff --git a/pdns/reczones.cc b/pdns/reczones.cc
index 08eec27c9..c3616650e 100644
--- a/pdns/reczones.cc
+++ b/pdns/reczones.cc
@@ -107,7 +107,7 @@ static void makeNameToIPZone(SyncRes::domainmap_t* newMap, const DNSName& hostna
 
   DNSRecord dr;
   dr.d_name=hostname;
-  dr.d_place=DNSRecord::Answer;
+  dr.d_place=DNSResourceRecord::ANSWER;
   dr.d_ttl=86400;
   dr.d_type=QType::SOA;
   dr.d_class = 1;
@@ -150,7 +150,7 @@ static void makeIPToNamesZone(SyncRes::domainmap_t* newMap, const vector<string>
   dr.d_name.appendRawLabel("in-addr");
   dr.d_name.appendRawLabel("arpa");
   dr.d_class = 1;
-  dr.d_place=DNSRecord::Answer;
+  dr.d_place=DNSResourceRecord::ANSWER;
   dr.d_ttl=86400;
   dr.d_type=QType::SOA;
   dr.d_content=std::shared_ptr<DNSRecordContent>(DNSRecordContent::mastermake(QType::SOA, 1, "localhost. root 1 604800 86400 2419200 604800"));
@@ -341,7 +341,7 @@ SyncRes::domainmap_t* parseAuthAndForwards()
         while(zpt.get(rr)) {
           try {
 	    dr=DNSRecord(rr);
-	    dr.d_place=DNSRecord::Answer;
+	    dr.d_place=DNSResourceRecord::ANSWER;
           }
           catch(std::exception &e) {
             delete newMap;
diff --git a/pdns/rfc2136handler.cc b/pdns/rfc2136handler.cc
index 093b8f46b..b442f9536 100644
--- a/pdns/rfc2136handler.cc
+++ b/pdns/rfc2136handler.cc
@@ -759,7 +759,7 @@ int PacketHandler::processUpdate(DNSPacket *p) {
     const DNSRecord *rr = &i->first;
     // Skip this check for other field types (like the TSIG -  which is in the additional section)
     // For a TSIG, the label is the dnskey, so it does not pass the endOn validation.
-    if (! (rr->d_place == DNSRecord::Answer || rr->d_place == DNSRecord::Nameserver))
+    if (! (rr->d_place == DNSResourceRecord::ANSWER || rr->d_place == DNSResourceRecord::AUTHORITY))
       continue;
 
     if (!rr->d_name.isPartOf(di.zone)) {
@@ -779,7 +779,7 @@ int PacketHandler::processUpdate(DNSPacket *p) {
   // 3.2.1 and 3.2.2 - Prerequisite check
   for(MOADNSParser::answers_t::const_iterator i=mdp.d_answers.begin(); i != mdp.d_answers.end(); ++i) {
     const DNSRecord *rr = &i->first;
-    if (rr->d_place == DNSRecord::Answer) {
+    if (rr->d_place == DNSResourceRecord::ANSWER) {
       int res = checkUpdatePrerequisites(rr, &di);
       if (res>0) {
         L<<Logger::Error<<msgPrefix<<"Failed PreRequisites check, returning "<<res<<endl;
@@ -796,7 +796,7 @@ int PacketHandler::processUpdate(DNSPacket *p) {
   RRsetMap_t preReqRRsets;
   for(MOADNSParser::answers_t::const_iterator i=mdp.d_answers.begin(); i != mdp.d_answers.end(); ++i) {
     const DNSRecord *rr = &i->first;
-    if (rr->d_place == DNSRecord::Answer) {
+    if (rr->d_place == DNSResourceRecord::ANSWER) {
       // Last line of 3.2.3
       if (rr->d_class != QClass::IN && rr->d_class != QClass::NONE && rr->d_class != QClass::ANY)
         return RCode::FormErr;
@@ -844,7 +844,7 @@ int PacketHandler::processUpdate(DNSPacket *p) {
     // 3.4.1 - Prescan section
     for(MOADNSParser::answers_t::const_iterator i=mdp.d_answers.begin(); i != mdp.d_answers.end(); ++i) {
       const DNSRecord *rr = &i->first;
-      if (rr->d_place == DNSRecord::Nameserver) {
+      if (rr->d_place == DNSResourceRecord::AUTHORITY) {
         int res = checkUpdatePrescan(rr);
         if (res>0) {
           L<<Logger::Error<<msgPrefix<<"Failed prescan check, returning "<<res<<endl;
@@ -866,7 +866,7 @@ int PacketHandler::processUpdate(DNSPacket *p) {
     vector<const DNSRecord *> nsRRtoDelete;
     for(MOADNSParser::answers_t::const_iterator i=mdp.d_answers.begin(); i != mdp.d_answers.end(); ++i) {
       const DNSRecord *rr = &i->first;
-      if (rr->d_place == DNSRecord::Nameserver) {
+      if (rr->d_place == DNSResourceRecord::AUTHORITY) {
         if (rr->d_class == QClass::NONE  && rr->d_type == QType::NS && rr->d_name == di.zone)
           nsRRtoDelete.push_back(rr);
         else
diff --git a/pdns/saxfr.cc b/pdns/saxfr.cc
index 768e0b513..5f048f2a0 100644
--- a/pdns/saxfr.cc
+++ b/pdns/saxfr.cc
@@ -137,7 +137,7 @@ try
       tkrc.d_key = output;
       tkrc.d_othersize = 0;
       pwtkey.getHeader()->id = dns_random(0xffff);
-      pwtkey.startRecord(gssctx.getLabel(), QType::TKEY, 3600, QClass::ANY, DNSPacketWriter::ADDITIONAL, false);
+      pwtkey.startRecord(gssctx.getLabel(), QType::TKEY, 3600, QClass::ANY, DNSResourceRecord::ADDITIONAL, false);
       tkrc.toPacket(pwtkey);
       pwtkey.commit();
       BOOST_FOREACH(const string& msg, gssctx.getErrorStrings()) {
diff --git a/pdns/speedtest.cc b/pdns/speedtest.cc
index 9b0c31396..6c9bc9f07 100644
--- a/pdns/speedtest.cc
+++ b/pdns/speedtest.cc
@@ -365,7 +365,7 @@ vector<uint8_t> makeRootReferral()
   
   for(char c='a';c<='m';++c) {
     *templ=c;
-    pw.startRecord(DNSName(), QType::NS, 3600, 1, DNSPacketWriter::AUTHORITY);
+    pw.startRecord(DNSName(), QType::NS, 3600, 1, DNSResourceRecord::AUTHORITY);
     DNSRecordContent* drc = DNSRecordContent::mastermake(QType::NS, 1, templ);
     drc->toPacket(pw);
     delete drc;
@@ -373,7 +373,7 @@ vector<uint8_t> makeRootReferral()
 
   for(char c='a';c<='m';++c) {
     *templ=c;
-    pw.startRecord(DNSName(), QType::A, 3600, 1, DNSPacketWriter::ADDITIONAL);
+    pw.startRecord(DNSName(), QType::A, 3600, 1, DNSResourceRecord::ADDITIONAL);
     DNSRecordContent* drc = DNSRecordContent::mastermake(QType::A, 1, ips[c-'a']);
     drc->toPacket(pw);
     delete drc;
@@ -388,23 +388,23 @@ vector<uint8_t> makeTypicalReferral()
   vector<uint8_t> packet;
   DNSPacketWriter pw(packet, DNSName("outpost.ds9a.nl"), QType::A);
 
-  pw.startRecord(DNSName("ds9a.nl"), QType::NS, 3600, 1, DNSPacketWriter::AUTHORITY);
+  pw.startRecord(DNSName("ds9a.nl"), QType::NS, 3600, 1, DNSResourceRecord::AUTHORITY);
   DNSRecordContent* drc = DNSRecordContent::mastermake(QType::NS, 1, "ns1.ds9a.nl");
   drc->toPacket(pw);
   delete drc;
 
-  pw.startRecord(DNSName("ds9a.nl"), QType::NS, 3600, 1, DNSPacketWriter::AUTHORITY);
+  pw.startRecord(DNSName("ds9a.nl"), QType::NS, 3600, 1, DNSResourceRecord::AUTHORITY);
   drc = DNSRecordContent::mastermake(QType::NS, 1, "ns2.ds9a.nl");
   drc->toPacket(pw);
   delete drc;
 
 
-  pw.startRecord(DNSName("ns1.ds9a.nl"), QType::A, 3600, 1, DNSPacketWriter::ADDITIONAL);
+  pw.startRecord(DNSName("ns1.ds9a.nl"), QType::A, 3600, 1, DNSResourceRecord::ADDITIONAL);
   drc = DNSRecordContent::mastermake(QType::A, 1, "1.2.3.4");
   drc->toPacket(pw);
   delete drc;
 
-  pw.startRecord(DNSName("ns2.ds9a.nl"), QType::A, 3600, 1, DNSPacketWriter::ADDITIONAL);
+  pw.startRecord(DNSName("ns2.ds9a.nl"), QType::A, 3600, 1, DNSResourceRecord::ADDITIONAL);
   drc = DNSRecordContent::mastermake(QType::A, 1, "4.3.2.1");
   drc->toPacket(pw);
   delete drc;
@@ -618,7 +618,7 @@ struct ParsePacketTest
       string auth(".");
  
       for(vector<DNSResourceRecord>::const_iterator i=lwr.d_result.begin();i!=lwr.d_result.end();++i) {
-        if(i->d_place==DNSResourceRecord::AUTHORITY && dottedEndsOn(qname,i->qname) && i->qtype.getCode()==QType::SOA && 
+        if(i->d_place==DNSResourceRecord::AUTHORITY && dottedEndsOn(qname,i->qname) && i->qtype.getCode()==QType::SOA &&
            lwr.d_rcode==RCode::NXDomain) {
           // LOG<<prefix<<qname<<": got negative caching indication for RECORD '"<<qname+"'"<<endl;
           ret.push_back(*i);
@@ -640,7 +640,7 @@ struct ParsePacketTest
           newtarget=i->content;
         }
         // for ANY answers we *must* have an authoritative answer
-        else if(i->d_place==DNSResourceRecord::ANSWER && pdns_iequals(i->qname, qname) && 
+        else if(i->d_place==DNSResourceRecord::ANSWER && pdns_iequals(i->qname, qname) &&
                 (
                  i->qtype==qtype || (lwr.d_aabit && (qtype==QType(QType::ANY) || magicAddrMatch(qtype, i->qtype) ) )
                 ) 
diff --git a/pdns/syncres.cc b/pdns/syncres.cc
index e967d76bd..571f85cb8 100644
--- a/pdns/syncres.cc
+++ b/pdns/syncres.cc
@@ -133,7 +133,7 @@ int SyncRes::beginResolve(const DNSName &qname, const QType &qtype, uint16_t qcl
     ret.clear();
     DNSRecord dr;
     dr.d_name=qname;
-    dr.d_place = DNSRecord::Answer;
+    dr.d_place = DNSResourceRecord::ANSWER;
     dr.d_type=qtype.getCode();
     dr.d_class=QClass::IN;
     dr.d_ttl=86400;
@@ -154,7 +154,7 @@ int SyncRes::beginResolve(const DNSName &qname, const QType &qtype, uint16_t qcl
     dr.d_type=qtype.getCode();
     dr.d_class=qclass;
     dr.d_ttl=86400;
-    dr.d_place = DNSRecord::Answer;
+    dr.d_place = DNSResourceRecord::ANSWER;
     if(qname==versionbind  || qname==versionpdns)
       dr.d_content=shared_ptr<DNSRecordContent>(DNSRecordContent::mastermake(QType::TXT, 3, "\""+::arg()["version-string"]+"\""));
     else
@@ -214,7 +214,7 @@ bool SyncRes::doOOBResolve(const DNSName &qname, const QType &qtype, vector<DNSR
     ziter=iter->second.d_records.find(boost::make_tuple(authdomain, QType::SOA));
     if(ziter!=iter->second.d_records.end()) {
       DNSRecord dr=*ziter;
-      dr.d_place=DNSRecord::Nameserver;
+      dr.d_place=DNSResourceRecord::AUTHORITY;
       ret.push_back(dr);
     }
     else
@@ -235,7 +235,7 @@ bool SyncRes::doOOBResolve(const DNSName &qname, const QType &qtype, vector<DNSR
       DNSRecord dr=*ziter;
       if(dr.d_type == qtype.getCode() || qtype.getCode() == QType::ANY) {
         dr.d_name = qname;
-        dr.d_place=DNSRecord::Answer;
+        dr.d_place=DNSResourceRecord::ANSWER;
         ret.push_back(dr);
       }
     }
@@ -253,7 +253,7 @@ bool SyncRes::doOOBResolve(const DNSName &qname, const QType &qtype, vector<DNSR
 
     for(ziter=range.first; ziter!=range.second; ++ziter) {
       DNSRecord dr=*ziter;
-      dr.d_place=DNSRecord::Nameserver;
+      dr.d_place=DNSResourceRecord::AUTHORITY;
       ret.push_back(dr);
     }
   }
@@ -262,7 +262,7 @@ bool SyncRes::doOOBResolve(const DNSName &qname, const QType &qtype, vector<DNSR
     ziter=iter->second.d_records.find(boost::make_tuple(authdomain, QType::SOA));
     if(ziter!=iter->second.d_records.end()) {
       DNSRecord dr=*ziter;
-      dr.d_place=DNSRecord::Nameserver;
+      dr.d_place=DNSResourceRecord::AUTHORITY;
       ret.push_back(dr);
     }
     else {
@@ -396,7 +396,7 @@ int SyncRes::doResolve(const DNSName &qname, const QType &qtype, vector<DNSRecor
           // filter out the good stuff from lwr.result()
 
 	  for(const auto& rec : lwr.d_records) {
-            if(rec.d_place == DNSRecord::Answer)
+            if(rec.d_place == DNSResourceRecord::ANSWER)
               ret.push_back(rec);
           }
           return res;
@@ -667,7 +667,7 @@ bool SyncRes::doCNAMECacheCheck(const DNSName &qname, const QType &qtype, vector
 	  dr.d_name=qname;
 	  dr.d_ttl=j->d_ttl - d_now.tv_sec;
 	  dr.d_content=signature;
-	  dr.d_place=DNSRecord::Answer;
+	  dr.d_place=DNSResourceRecord::ANSWER;
 	  dr.d_class=1;
 	  ret.push_back(dr);
 	}
@@ -767,7 +767,7 @@ bool SyncRes::doCacheCheck(const DNSName &qname, const QType &qtype, vector<DNSR
         DNSRecord dr=*j;
         ttl = (dr.d_ttl-=d_now.tv_sec);
         if(giveNegative) {
-          dr.d_place=DNSRecord::Nameserver;
+          dr.d_place=DNSResourceRecord::AUTHORITY;
           dr.d_ttl=sttl;
         }
         ret.push_back(dr);
@@ -786,7 +786,7 @@ bool SyncRes::doCacheCheck(const DNSName &qname, const QType &qtype, vector<DNSR
       dr.d_name=sqname;
       dr.d_ttl=ttl; 
       dr.d_content=signature;
-      dr.d_place=DNSRecord::Answer;
+      dr.d_place=DNSResourceRecord::ANSWER;
       dr.d_class=1;
       ret.push_back(dr);
     }
@@ -1126,7 +1126,7 @@ int SyncRes::doResolveAt(set<DNSName> nameservers, DNSName auth, bool flawedNSSe
 
 
         if(rec.d_name.isPartOf(auth)) {
-          if(lwr.d_aabit && lwr.d_rcode==RCode::NoError && rec.d_place==DNSRecord::Answer && ::arg().contains("delegation-only",auth.toString() /* ugh */)) {
+          if(lwr.d_aabit && lwr.d_rcode==RCode::NoError && rec.d_place==DNSResourceRecord::ANSWER && ::arg().contains("delegation-only",auth.toString() /* ugh */)) {
             LOG("NO! Is from delegation-only zone"<<endl);
             s_nodelegated++;
             return RCode::NXDomain;
@@ -1140,7 +1140,7 @@ int SyncRes::doResolveAt(set<DNSName> nameservers, DNSName auth, bool flawedNSSe
             rec.d_ttl=min(s_maxcachettl, rec.d_ttl);
 
             DNSRecord dr(rec);
-            dr.d_place=DNSRecord::Answer;
+            dr.d_place=DNSResourceRecord::ANSWER;
 
             dr.d_ttl += d_now.tv_sec;
 
@@ -1174,7 +1174,7 @@ int SyncRes::doResolveAt(set<DNSName> nameservers, DNSName auth, bool flawedNSSe
       DNSName newtarget;
 
       for(auto& rec : lwr.d_records) {
-        if(rec.d_place==DNSRecord::Nameserver && rec.d_type==QType::SOA && 
+        if(rec.d_place==DNSResourceRecord::AUTHORITY && rec.d_type==QType::SOA &&
            lwr.d_rcode==RCode::NXDomain && dottedEndsOn(qname,rec.d_name) && dottedEndsOn(rec.d_name, auth)) {
           LOG(prefix<<qname.toString()<<": got negative caching indication for name '"<<qname.toString()+"' (accept="<<dottedEndsOn(rec.d_name, auth)<<"), newtarget='"<<newtarget.toString()<<"'"<<endl);
 
@@ -1199,16 +1199,16 @@ int SyncRes::doResolveAt(set<DNSName> nameservers, DNSName auth, bool flawedNSSe
 
           negindic=true;
         }
-        else if(rec.d_place==DNSRecord::Answer && rec.d_name == qname && rec.d_type==QType::CNAME && (!(qtype==QType(QType::CNAME)))) {
+        else if(rec.d_place==DNSResourceRecord::ANSWER && rec.d_name == qname && rec.d_type==QType::CNAME && (!(qtype==QType(QType::CNAME)))) {
           ret.push_back(rec);
           newtarget=DNSName(rec.d_content->getZoneRepresentation());
         }
-	else if(d_doDNSSEC && (rec.d_type==QType::RRSIG || rec.d_type==QType::NSEC || rec.d_type==QType::NSEC3) && rec.d_place==DNSRecord::Answer){
+	else if(d_doDNSSEC && (rec.d_type==QType::RRSIG || rec.d_type==QType::NSEC || rec.d_type==QType::NSEC3) && rec.d_place==DNSResourceRecord::ANSWER){
 	  if(rec.d_type != QType::RRSIG || rec.d_name == qname)
 	    ret.push_back(rec); // enjoy your DNSSEC
 	}
         // for ANY answers we *must* have an authoritative answer, unless we are forwarding recursively
-        else if(rec.d_place==DNSRecord::Answer && rec.d_name == qname &&
+        else if(rec.d_place==DNSResourceRecord::ANSWER && rec.d_name == qname &&
                 (
                  rec.d_type==qtype.getCode() || (lwr.d_aabit && (qtype==QType(QType::ANY) || magicAddrMatch(qtype, QType(rec.d_type)) ) ) || sendRDQuery
                 )
@@ -1220,7 +1220,7 @@ int SyncRes::doResolveAt(set<DNSName> nameservers, DNSName auth, bool flawedNSSe
           done=true;
           ret.push_back(rec);
         }
-        else if(rec.d_place==DNSRecord::Nameserver && qname.isPartOf(rec.d_name) && rec.d_type==QType::NS) {
+        else if(rec.d_place==DNSResourceRecord::AUTHORITY && qname.isPartOf(rec.d_name) && rec.d_type==QType::NS) {
           if(moreSpecificThan(rec.d_name,auth)) {
             newauth=rec.d_name;
             LOG(prefix<<qname.toString()<<": got NS record '"<<rec.d_name.toString()<<"' -> '"<<rec.d_content->getZoneRepresentation()<<"'"<<endl);
@@ -1231,11 +1231,11 @@ int SyncRes::doResolveAt(set<DNSName> nameservers, DNSName auth, bool flawedNSSe
 	  }
           nsset.insert(DNSName(rec.d_content->getZoneRepresentation()));
         }
-        else if(rec.d_place==DNSRecord::Nameserver && dottedEndsOn(qname,rec.d_name) && rec.d_type==QType::DS) { 
+        else if(rec.d_place==DNSResourceRecord::AUTHORITY && dottedEndsOn(qname,rec.d_name) && rec.d_type==QType::DS) {
 	  LOG(prefix<<qname.toString()<<": got DS record '"<<rec.d_name.toString()<<"' -> '"<<rec.d_content->getZoneRepresentation()<<"'"<<endl);
 	  sawDS=true;
 	}
-        else if(!done && rec.d_place==DNSRecord::Nameserver && dottedEndsOn(qname,rec.d_name) && rec.d_type==QType::SOA && 
+        else if(!done && rec.d_place==DNSResourceRecord::AUTHORITY && dottedEndsOn(qname,rec.d_name) && rec.d_type==QType::SOA &&
            lwr.d_rcode==RCode::NoError) {
           LOG(prefix<<qname.toString()<<": got negative caching indication for '"<< (qname.toString()+"|"+qtype.getName()+"'") <<endl);
 
diff --git a/pdns/tcpreceiver.cc b/pdns/tcpreceiver.cc
index 3d95cf0e6..9496ba0d2 100644
--- a/pdns/tcpreceiver.cc
+++ b/pdns/tcpreceiver.cc
@@ -998,7 +998,7 @@ int TCPNameserver::doIXFR(shared_ptr<DNSPacket> q, int outsock)
   MOADNSParser mdp(q->getString());
   for(MOADNSParser::answers_t::const_iterator i=mdp.d_answers.begin(); i != mdp.d_answers.end(); ++i) {
     const DNSRecord *rr = &i->first;
-    if (rr->d_type == QType::SOA && rr->d_place == DNSRecord::Nameserver) {
+    if (rr->d_type == QType::SOA && rr->d_place == DNSResourceRecord::AUTHORITY) {
       vector<string>parts;
       stringtok(parts, rr->d_content->getZoneRepresentation());
       if (parts.size() >= 3) {
diff --git a/pdns/test-dnsrecords_cc.cc b/pdns/test-dnsrecords_cc.cc
index 49988ebb7..36f959d5d 100644
--- a/pdns/test-dnsrecords_cc.cc
+++ b/pdns/test-dnsrecords_cc.cc
@@ -298,7 +298,7 @@ BOOST_AUTO_TEST_CASE(test_opt_record_out) {
   vector<pair<uint16_t,string > > opts;
 
   DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
-  pw.startRecord(DNSName("www.powerdns.com"), QType::A, 16, 1, DNSPacketWriter::ANSWER);
+  pw.startRecord(DNSName("www.powerdns.com"), QType::A, 16, 1, DNSResourceRecord::ANSWER);
   pw.xfrIP(htonl(0x7f000001));
   opts.push_back(pair<uint16_t,string>(3, "powerdns"));
   pw.addOpt(1280, 0, 0, opts);
diff --git a/pdns/test-packetcache_cc.cc b/pdns/test-packetcache_cc.cc
index 5ff82ef1c..bbb3ab7fb 100644
--- a/pdns/test-packetcache_cc.cc
+++ b/pdns/test-packetcache_cc.cc
@@ -195,7 +195,7 @@ BOOST_AUTO_TEST_CASE(test_PacketCachePacket) {
 
     pak.clear();
     DNSPacketWriter pw2(pak, DNSName("www.powerdns.com"), QType::A);
-    pw2.startRecord(DNSName("www.powerdns.com"), QType::A, 16, 1, DNSPacketWriter::ANSWER);
+    pw2.startRecord(DNSName("www.powerdns.com"), QType::A, 16, 1, DNSResourceRecord::ANSWER);
     pw2.xfrIP(htonl(0x7f000001));
     pw2.commit();