Changeset 1232

Timestamp:

07/13/08 22:21:54 (20 months ago)

Author:

ahu

Message:

implement EDNS NSID call (RFC 5001), plus an experimental EDNS option ('ping')

Location:

trunk/pdns/pdns

Files:

• common_startup.cc (modified) (3 diffs)
• dnspacket.cc (modified) (9 diffs)
• dnspacket.hh (modified) (2 diffs)
• dnsparser.cc (modified) (3 diffs)
• dnsparser.hh (modified) (1 diff)
• dnsrecords.cc (modified) (2 diffs)
• dnsrecords.hh (modified) (2 diffs)
• dnswriter.cc (modified) (3 diffs)
• dnswriter.hh (modified) (1 diff)
• packethandler.cc (modified) (2 diffs)
• pdns_recursor.cc (modified) (2 diffs)
• receiver.cc (modified) (2 diffs)

trunk/pdns/pdns/common_startup.cc

@@ -105 +105 @@
   ::arg().set("query-cache-ttl","Seconds to store packets in the PacketCache")="20";
   ::arg().set("soa-minimum-ttl","Default SOA mininum ttl")="3600";
-
+  ::arg().set("server-id", "Returned when queried for 'server.id' TXT or NSID, defaults to hostname")="";
   ::arg().set("soa-refresh-default","Default SOA refresh")="10800";
   ::arg().set("soa-retry-default","Default SOA retry")="3600";
@@ -123 +123 @@
   ::arg().set("max-cache-entries", "Maximum number of cache entries")="1000000";
 }
-
-
 
 void declareStats(void)
@@ -242 +240 @@
     S.ringAccount("remotes",P->getRemote());
 
-    if((P->d.opcode != Opcode::Notify) && PC.get(P,&cached)) { // short circuit - does the PacketCache recognize this question?
+    if((P->d.opcode != Opcode::Notify) && P->couldBeCached() && PC.get(P,&cached)) { // short circuit - does the PacketCache recognize this question?
       cached.setRemote(&P->remote);  // inlined
       cached.setSocket(P->getSocket());                               // inlined

trunk/pdns/pdns/dnspacket.cc

@@ -39 +39 @@
 #include "dnswriter.hh"
 #include "dnsparser.hh"
+#include "dnsrecords.hh"
 
 DNSPacket::DNSPacket() 
@@ -45 +46 @@
   d_compress=true;
   d_tcp=false;
+  d_wantsnsid=false;
 }
 
@@ -89 +91 @@
   qdomain=orig.qdomain;
   d_maxreplylen = orig.d_maxreplylen;
+  d_ednsping = orig.d_ednsping;
+  d_wantsnsid = orig.d_wantsnsid;
   rrs=orig.rrs;
 
@@ -264 +268 @@
 }
 
+bool DNSPacket::couldBeCached()
+{
+  return d_ednsping.empty() && !d_wantsnsid;
+}
+
 /** Must be called before attempting to access getData(). This function stuffs all resource
  *  records found in rrs into the data buffer. It also frees resource records queued for us.
@@ -305 +314 @@
   pw.getHeader()->rd=d.rd;
 
-  if(!rrs.empty()) {
+  DNSPacketWriter::optvect_t opts;
+  if(d_wantsnsid) {
+    opts.push_back(make_pair(3, ::arg()["server-id"]));
+  }
+
+  if(!d_ednsping.empty()) {
+    opts.push_back(make_pair(4, d_ednsping));
+  }
+
+  if(!rrs.empty() || !opts.empty()) {
     try {
       for(pos=rrs.begin(); pos < rrs.end(); ++pos) {
@@ -321 +339 @@
         drc->toPacket(pw);
       }
+      if(!opts.empty())
+        pw.addOpt(2800, 0, 0, opts);
+
       pw.commit();
     }
@@ -384 +405 @@
   r->qtype = qtype;
   r->d_maxreplylen = d_maxreplylen;
+  r->d_ednsping = d_ednsping;
+  r->d_wantsnsid = d_wantsnsid;
   return r;
 }
@@ -403 +426 @@
 {
   stringbuffer.assign(mesg,length); 
-
+  
   len=length;
   if(length < 12) { 
@@ -410 +433 @@
     return -1;
   }
+
   MOADNSParser mdp(stringbuffer);
-  MOADNSParser::EDNSOpts edo;
-  if(mdp.getEDNSOpts(&edo)) {
+  EDNSOpts edo;
+
+  // ANY OPTION WHICH *MIGHT* BE SET DOWN BELOW SHOULD BE CLEARED FIRST!
+
+  d_wantsnsid=false;
+  d_ednsping.clear();
+
+  if(getEDNSOpts(mdp, &edo)) {
     d_maxreplylen=edo.d_packetsize;
-  }
-  else
+
+    for(vector<pair<uint16_t, string> >::const_iterator iter = edo.d_options.begin();
+        iter != edo.d_options.end(); 
+        ++iter) {
+      if(iter->first == 3) {// 'EDNS NSID'
+        d_wantsnsid=1;
+      }
+      else if(iter->first == 4) {// 'EDNS PING'
+        d_ednsping = iter->second;
+      }
+      else
+        ; // cerr<<"Have an option #"<<iter->first<<endl;
+    }
+  }
+  else  {
     d_maxreplylen=512;
+  }
 
   memcpy((void *)&d,(const void *)stringbuffer.c_str(),12);

trunk/pdns/pdns/dnspacket.hh

@@ -140 +140 @@
   void commitD(); //!< copies 'd' into the stringbuffer
   int getMaxReplyLen(); //!< retrieve the maximum length of the packet we should send in response
+
+  bool couldBeCached(); //!< returns 0 if this query should bypass the packet cache
+
   //////// DATA !
 
@@ -163 +166 @@
   string stringbuffer; // this is where everything lives 4
   int d_maxreplylen;
+  string d_ednsping;
+  bool d_wantsnsid;
   vector<DNSResourceRecord> rrs; // 4
 };

trunk/pdns/pdns/dnsparser.cc

@@ -133 +133 @@
                                                PacketReader& pr)
 {
-  typemap_t::const_iterator i=getTypemap().find(make_pair(dr.d_class, dr.d_type));
+  uint16_t searchclass = (dr.d_type == QType::OPT) ? 1 : dr.d_class; // class is invalid for OPT
+
+  typemap_t::const_iterator i=getTypemap().find(make_pair(searchclass, dr.d_type));
   if(i==getTypemap().end() || !i->second) {
     return new UnknownRecordContent(dr, pr);
@@ -258 +260 @@
 }
 
-bool MOADNSParser::getEDNSOpts(EDNSOpts* eo)
-{
-  if(d_header.arcount && !d_answers.empty() && d_answers.back().first.d_type == QType::OPT) {
-    eo->d_packetsize=d_answers.back().first.d_class;
-
-    EDNS0Record stuff;
-    uint32_t ttl=ntohl(d_answers.back().first.d_ttl);
-    memcpy(&stuff, &ttl, sizeof(stuff));
-
-    eo->d_extRCode=stuff.extRCode;
-    eo->d_version=stuff.version;
-    eo->d_Z=stuff.Z;
-
-    return true;
-  }
-  else
-    return false;
-}
 
 void PacketReader::getDnsrecordheader(struct dnsrecordheader &ah)
@@ -448 +432 @@
 void PacketReader::xfrBlob(string& blob)
 {
-  blob.assign(&d_content.at(d_pos), &d_content.at(d_startrecordpos + d_recordlen - 1 ) + 1);
+  if(d_recordlen)
+    blob.assign(&d_content.at(d_pos), &d_content.at(d_startrecordpos + d_recordlen - 1 ) + 1);
+  else
+    blob.clear();
 
   d_pos = d_startrecordpos + d_recordlen;

trunk/pdns/pdns/dnsparser.hh

@@ -299 +299 @@
   }
 
-  struct EDNSOpts
-  {
-    uint16_t d_packetsize;
-    uint8_t d_extRCode, d_version;
-    uint16_t d_Z;
-  };
-
-  //! Convenience function that fills out EDNS0 options, and returns true if there are any
-  bool getEDNSOpts(EDNSOpts* eo);
-
+  
 private:
   void getDnsrecordheader(struct dnsrecordheader &ah);

trunk/pdns/pdns/dnsrecords.cc

@@ -188 +188 @@
 
 
-boilerplate_conv(OPT, ns_t_opt,
-                 conv.xfrText(d_data)
+boilerplate_conv(OPT, ns_t_opt, 
+                   conv.xfrBlob(d_data)
                  );
 
+void OPTRecordContent::getData(vector<pair<uint16_t, string> >& options)
+{
+  string::size_type pos=0;
+  uint16_t code, len;
+  while(d_data.size() >= 4 + pos) {
+    code = 0xff * d_data[pos] + d_data[pos+1];
+    len = 0xff * d_data[pos+2] + d_data[pos+3];
+    pos+=4;
+
+    if(pos + len > d_data.size())
+      break;
+
+    string field(d_data.c_str() + pos, len);
+    pos+=len;
+
+    options.push_back(make_pair(code, field));
+  }
+}
 
 boilerplate_conv(TSIG, ns_t_tsig, 
@@ -321 +339 @@
                  )
 
+
+bool getEDNSOpts(const MOADNSParser& mdp, EDNSOpts* eo)
+{
+  if(mdp.d_header.arcount && !mdp.d_answers.empty() && 
+     mdp.d_answers.back().first.d_type == QType::OPT) {
+    eo->d_packetsize=mdp.d_answers.back().first.d_class;
+    
+    EDNS0Record stuff;
+    uint32_t ttl=ntohl(mdp.d_answers.back().first.d_ttl);
+    memcpy(&stuff, &ttl, sizeof(stuff));
+
+    eo->d_extRCode=stuff.extRCode;
+    eo->d_version=stuff.version;
+    eo->d_Z=stuff.Z;
+    
+    OPTRecordContent* orc = 
+      dynamic_cast<OPTRecordContent*>(mdp.d_answers.back().first.d_content.get());
+
+    orc->getData(eo->d_options);
+
+    return true;
+  }
+  else
+    return false;
+}
+
+
 void reportBasicTypes()
 {

trunk/pdns/pdns/dnsrecords.hh

@@ -198 +198 @@
 public:
   includeboilerplate(OPT)
-
+  void getData(vector<pair<uint16_t, string> > &opts);
 private:
   string d_data;
@@ -423 +423 @@
 }                                                                 \
 
+struct EDNSOpts
+{
+  uint16_t d_packetsize;
+  uint8_t d_extRCode, d_version;
+  uint16_t d_Z;
+  vector<pair<uint16_t, string> > d_options;
+};
+//! Convenience function that fills out EDNS0 options, and returns true if there are any
+
+class MOADNSParser;
+bool getEDNSOpts(const MOADNSParser& mdp, EDNSOpts* eo);
+
 void reportBasicTypes();
 void reportOtherTypes();

trunk/pdns/pdns/dnswriter.cc

@@ -82 +82 @@
 }
 
-void DNSPacketWriter::addOpt(int udpsize, int extRCode, int Z)
+void DNSPacketWriter::addOpt(int udpsize, int extRCode, int Z, const vector<pair<uint16_t,string> >& options)
 {
   uint32_t ttl=0;
@@ -91 +91 @@
   stuff.version=0;
   stuff.Z=htons(Z);
-  
+
   memcpy(&ttl, &stuff, sizeof(stuff));
 
@@ -97 +97 @@
   
   startRecord("", ns_t_opt, ttl, udpsize, ADDITIONAL);
+  for(optvect_t::const_iterator iter = options.begin(); iter != options.end(); ++iter) {
+    xfr16BitInt(iter->first);
+    xfr16BitInt(iter->second.length());
+    xfrBlob(iter->second);
+  } 
 }
 

trunk/pdns/pdns/dnswriter.hh

@@ -54 +54 @@
 
   /** Shorthand way to add an Opt-record, for example for EDNS0 purposes */
-  void addOpt(int udpsize, int extRCode, int Z);
+  typedef vector<pair<uint16_t,std::string> > optvect_t;
+  void addOpt(int udpsize, int extRCode, int Z, const optvect_t& options=optvect_t());
 
   /** 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.

trunk/pdns/pdns/packethandler.cc

@@ -797 +797 @@
     }
     
+    if(!noCache)
+      noCache = !p->couldBeCached();
+
     string::size_type pos;
     
@@ -925 +928 @@
 
     r->wrapup(); // needed for inserting in cache
-    if(!noCache)
+    if(!noCache) {
       PC.insert(p,r); // in the packet cache
+    }
   }
   catch(DBException &e) {

trunk/pdns/pdns/pdns_recursor.cc

@@ -512 +512 @@
   try {
     uint16_t maxudpsize=512;
-    MOADNSParser::EDNSOpts edo;
-    if(dc->d_mdp.getEDNSOpts(&edo)) {
+    EDNSOpts edo;
+    if(getEDNSOpts(dc->d_mdp, &edo)) {
       maxudpsize=edo.d_packetsize;
     }
@@ -1996 +1996 @@
     ::arg().set("max-cache-entries", "If set, maximum number of entries in the main cache")="0";
     ::arg().set("max-negative-ttl", "maximum number of seconds to keep a negative cached entry in memory")="3600";
-    ::arg().set("server-id", "Returned when queried for 'server.id' TXT, defaults to hostname")="";
+    ::arg().set("server-id", "Returned when queried for 'server.id' TXT or NSID, defaults to hostname")="";
     ::arg().set("remotes-ringbuffer-entries", "maximum number of packets to store statistics for")="0";
     ::arg().set("version-string", "string reported on version.pdns or version.bind")="PowerDNS Recursor "VERSION" $Id$";

trunk/pdns/pdns/receiver.cc

@@ -464 +464 @@
       exit(99);
     }
-
-
     
     if(::arg().mustDo("help")) {
@@ -499 +497 @@
       if(!isGuarded(argv))
         daemonize();
+    }
+
+    if(::arg()["server-id"].empty()) {
+      char tmp[128];
+      gethostname(tmp, sizeof(tmp)-1);
+      ::arg().set("server-id")=tmp;
     }