pdns/dnsbulktest.cc

   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 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include <boost/accumulators/accumulators.hpp>
  26 #include <boost/array.hpp>
  27 #include <boost/accumulators/statistics.hpp>
  28 #include <boost/program_options.hpp>
  29 #include "inflighter.cc"
  30 #include <deque>
  31 #include "namespaces.hh"
  32 #include "dnsparser.hh"
  33 #include "sstuff.hh"
  34 #include "misc.hh"
  35 #include "dnswriter.hh"
  36 #include "dnsrecords.hh"
  37
  38 using namespace boost::accumulators;
  39 namespace po = boost::program_options;
  40
  41 po::variables_map g_vm;
  42
  43 StatBag S;
  44
  45 bool g_quiet=false;
  46 bool g_envoutput=false;
  47
  48 struct DNSResult
  49 {
  50   vector<ComboAddress> ips;
  51   int rcode;
  52   bool seenauthsoa;
  53 };
  54
  55 struct TypedQuery
  56 {
  57   TypedQuery(const string& name_, uint16_t type_) : name(name_), type(type_){}
  58   DNSName name;
  59   uint16_t type;
  60 };
  61
  62 struct SendReceive
  63 {
  64   typedef int Identifier;
  65   typedef DNSResult Answer; // ip
  66   int d_socket;
  67   deque<uint16_t> d_idqueue;
  68
  69   typedef accumulator_set<
  70         double
  71       , stats<boost::accumulators::tag::extended_p_square,
  72               boost::accumulators::tag::median(with_p_square_quantile),
  73               boost::accumulators::tag::mean(immediate)
  74               >
  75     > acc_t;
  76   acc_t* d_acc;
  77
  78   boost::array<double, 11> d_probs;
  79
  80   SendReceive(const std::string& remoteAddr, uint16_t port)
  81   {
  82     boost::array<double, 11> tmp ={{0.001,0.01, 0.025, 0.1, 0.25,0.5,0.75,0.9,0.975, 0.99,0.9999}};
  83     d_probs = tmp;
  84     d_acc = new acc_t(boost::accumulators::tag::extended_p_square::probabilities=d_probs);
  85     //
  86     //d_acc = acc_t
  87     d_socket = socket(AF_INET, SOCK_DGRAM, 0);
  88     int val=1;
  89     setsockopt(d_socket, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
  90
  91     ComboAddress remote(remoteAddr, port);
  92     connect(d_socket, (struct sockaddr*)&remote, remote.getSocklen());
  93     d_oks = d_errors = d_nodatas = d_nxdomains = d_unknowns = 0;
  94     d_receiveds = d_receiveerrors = d_senderrors = 0;
  95     for(unsigned int id =0 ; id < std::numeric_limits<uint16_t>::max(); ++id)
  96       d_idqueue.push_back(id);
  97   }
  98
  99   ~SendReceive()
 100   {
 101     close(d_socket);
 102   }
 103
 104   Identifier send(TypedQuery& domain)
 105   {
 106     //cerr<<"Sending query for '"<<domain<<"'"<<endl;
 107
 108     // send it, copy code from 'sdig'
 109     vector<uint8_t> packet;
 110
 111     DNSPacketWriter pw(packet, domain.name, domain.type);
 112
 113     if(d_idqueue.empty()) {
 114       cerr<<"Exhausted ids!"<<endl;
 115       exit(1);
 116     }
 117     pw.getHeader()->id = d_idqueue.front();
 118     d_idqueue.pop_front();
 119     pw.getHeader()->rd = 1;
 120     pw.getHeader()->qr = 0;
 121
 122     if(::send(d_socket, &*packet.begin(), packet.size(), 0) < 0)
 123       d_senderrors++;
 124
 125     if(!g_quiet)
 126       cout<<"Sent out query for '"<<domain.name<<"' with id "<<pw.getHeader()->id<<endl;
 127     return pw.getHeader()->id;
 128   }
 129
 130   bool receive(Identifier& id, DNSResult& dr)
 131   {
 132     if(waitForData(d_socket, 0, 500000) > 0) {
 133       char buf[512];
 134
 135       int len = recv(d_socket, buf, sizeof(buf), 0);
 136       if(len < 0) {
 137         d_receiveerrors++;
 138         return 0;
 139       }
 140       else {
 141         d_receiveds++;
 142       }
 143       // parse packet, set 'id', fill out 'ip'
 144
 145       MOADNSParser mdp(false, string(buf, len));
 146       if(!g_quiet) {
 147         cout<<"Reply to question for qname='"<<mdp.d_qname<<"', qtype="<<DNSRecordContent::NumberToType(mdp.d_qtype)<<endl;
 148         cout<<"Rcode: "<<mdp.d_header.rcode<<", RD: "<<mdp.d_header.rd<<", QR: "<<mdp.d_header.qr;
 149         cout<<", TC: "<<mdp.d_header.tc<<", AA: "<<mdp.d_header.aa<<", opcode: "<<mdp.d_header.opcode<<endl;
 150       }
 151       dr.rcode = mdp.d_header.rcode;
 152       for(MOADNSParser::answers_t::const_iterator i=mdp.d_answers.begin(); i!=mdp.d_answers.end(); ++i) {
 153         if(i->first.d_place == 1 && i->first.d_type == mdp.d_qtype)
 154           dr.ips.push_back(ComboAddress(i->first.d_content->getZoneRepresentation()));
 155         if(i->first.d_place == 2 && i->first.d_type == QType::SOA) {
 156           dr.seenauthsoa = 1;
 157         }
 158         if(!g_quiet)
 159         {
 160           cout<<i->first.d_place-1<<"\t"<<i->first.d_name<<"\tIN\t"<<DNSRecordContent::NumberToType(i->first.d_type);
 161           cout<<"\t"<<i->first.d_ttl<<"\t"<< i->first.d_content->getZoneRepresentation()<<"\n";
 162         }
 163       }
 164
 165       id = mdp.d_header.id;
 166       d_idqueue.push_back(id);
 167
 168       return 1;
 169     }
 170     return 0;
 171   }
 172
 173   void deliverTimeout(const Identifier& id)
 174   {
 175     if(!g_quiet) {
 176       cout<<"Timeout for id "<<id<<endl;
 177     }
 178     d_idqueue.push_back(id);
 179   }
 180
 181   void deliverAnswer(TypedQuery& domain, const DNSResult& dr, unsigned int usec)
 182   {
 183     (*d_acc)(usec/1000.0);
 184 //    if(usec > 1000000)
 185   //    cerr<<"Slow: "<<domain<<" ("<<usec/1000.0<<" msec)\n";
 186     if(!g_quiet) {
 187       cout<<domain.name<<"|"<<DNSRecordContent::NumberToType(domain.type)<<": ("<<usec/1000.0<<"msec) rcode: "<<dr.rcode;
 188       for(const ComboAddress& ca :  dr.ips) {
 189         cout<<", "<<ca.toString();
 190       }
 191       cout<<endl;
 192     }
 193     if(dr.rcode == RCode::NXDomain) {
 194       d_nxdomains++;
 195     }
 196     else if(dr.rcode) {
 197       d_errors++;
 198     }
 199     else if(dr.ips.empty() && dr.seenauthsoa)
 200       d_nodatas++;
 201     else if(!dr.ips.empty())
 202       d_oks++;
 203     else {
 204       if(!g_quiet) cout<<"UNKNOWN!! ^^"<<endl;
 205       d_unknowns++;
 206     }
 207   }
 208   unsigned int d_errors, d_nxdomains, d_nodatas, d_oks, d_unknowns;
 209   unsigned int d_receiveds, d_receiveerrors, d_senderrors;
 210 };
 211
 212 void usage(po::options_description &desc) {
 213   cerr << "Usage: dnsbulktest [OPTION].. IPADDRESS PORTNUMBER [LIMIT]"<<endl;
 214   cerr << desc << "\n";
 215 }
 216
 217 int main(int argc, char** argv)
 218 try
 219 {
 220   po::options_description desc("Allowed options");
 221   desc.add_options()
 222     ("help,h", "produce help message")
 223     ("quiet,q", "be quiet about individual queries")
 224     ("type,t",  po::value<string>()->default_value("A"), "What type to query for")
 225     ("envoutput,e", "write report in shell environment format")
 226     ("version", "show the version number")
 227   ;
 228
 229   po::options_description alloptions;
 230   po::options_description hidden("hidden options");
 231   hidden.add_options()
 232     ("ip-address", po::value<string>(), "ip-address")
 233     ("portnumber", po::value<uint16_t>(), "portnumber")
 234     ("limit", po::value<uint32_t>()->default_value(0), "limit");
 235
 236   alloptions.add(desc).add(hidden);
 237   po::positional_options_description p;
 238   p.add("ip-address", 1);
 239   p.add("portnumber", 1);
 240   p.add("limit", 1);
 241
 242   po::store(po::command_line_parser(argc, argv).options(alloptions).positional(p).run(), g_vm);
 243   po::notify(g_vm);
 244
 245   if (g_vm.count("help")) {
 246     usage(desc);
 247     return EXIT_SUCCESS;
 248   }
 249
 250   if (g_vm.count("version")) {
 251     cerr<<"dnsbulktest "<<VERSION<<endl;
 252     return EXIT_SUCCESS;
 253   }
 254
 255   if(!g_vm.count("portnumber")) {
 256     cerr<<"Fatal, need to specify ip-address and portnumber"<<endl;
 257     usage(desc);
 258     return EXIT_FAILURE;
 259   }
 260
 261   g_quiet = g_vm.count("quiet") > 0;
 262   g_envoutput = g_vm.count("envoutput") > 0;
 263   uint16_t qtype;
 264   reportAllTypes();
 265   try {
 266     qtype = DNSRecordContent::TypeToNumber(g_vm["type"].as<string>());
 267   }
 268   catch(std::exception& e) {
 269     cerr << e.what() << endl;
 270     return EXIT_FAILURE;
 271   }
 272
 273   SendReceive sr(g_vm["ip-address"].as<string>(), g_vm["portnumber"].as<uint16_t>());
 274   unsigned int limit = g_vm["limit"].as<unsigned int>();
 275
 276   vector<TypedQuery> domains;
 277
 278   Inflighter<vector<TypedQuery>, SendReceive> inflighter(domains, sr);
 279   inflighter.d_maxInFlight = 1000;
 280   inflighter.d_timeoutSeconds = 3;
 281   inflighter.d_burst = 100;
 282   string line;
 283
 284   pair<string, string> split;
 285   string::size_type pos;
 286   while(stringfgets(stdin, line)) {
 287     if(limit && domains.size() >= limit)
 288       break;
 289
 290     trim_right(line);
 291     if(line.empty() || line[0] == '#')
 292       continue;
 293     split=splitField(line,',');
 294     if (split.second.empty())
 295       split=splitField(line,'\t');
 296     if(!split.second.find('.')) // skip 'Hidden profile' in quantcast list.
 297       continue;
 298     pos=split.second.find('/');
 299     if(pos != string::npos) // alexa has whole urls in the list now.
 300       split.second.resize(pos);
 301     if(find_if(split.second.begin(), split.second.end(), isalpha) == split.second.end())
 302     {
 303       continue; // this was an IP address
 304     }
 305     domains.push_back(TypedQuery(split.second, qtype));
 306     domains.push_back(TypedQuery("www."+split.second, qtype));
 307   }
 308   cerr<<"Read "<<domains.size()<<" domains!"<<endl;
 309   random_shuffle(domains.begin(), domains.end());
 310
 311   boost::format datafmt("%s %|20t|%+15s  %|40t|%s %|60t|%+15s\n");
 312
 313   for(;;) {
 314     try {
 315       inflighter.run();
 316       break;
 317     }
 318     catch(std::exception& e) {
 319       cerr<<"Caught exception: "<<e.what()<<endl;
 320     }
 321   }
 322
 323   cerr<< datafmt % "Sending" % "" % "Receiving" % "";
 324   cerr<< datafmt % "  Queued " % domains.size() % "  Received" % sr.d_receiveds;
 325   cerr<< datafmt % "  Error -/-" % sr.d_senderrors %  "  Timeouts" % inflighter.getTimeouts();
 326   cerr<< datafmt % " " % "" %  "  Unexpected" % inflighter.getUnexpecteds();
 327
 328   cerr<< datafmt % " Sent" % (domains.size() - sr.d_senderrors) %  " Total" % (sr.d_receiveds + inflighter.getTimeouts() + inflighter.getUnexpecteds());
 329
 330   cerr<<endl;
 331   cerr<< datafmt % "DNS Status" % ""       % "" % "";
 332   cerr<< datafmt % "  OK" % sr.d_oks       % "" % "";
 333   cerr<< datafmt % "  Error" % sr.d_errors       % "" % "";
 334   cerr<< datafmt % "  No Data" % sr.d_nodatas       % "" % "";
 335   cerr<< datafmt % "  NXDOMAIN" % sr.d_nxdomains      % "" % "";
 336   cerr<< datafmt % "  Unknowns" % sr.d_unknowns      % "" % "";
 337   cerr<< datafmt % "Answers" % (sr.d_oks      +      sr.d_errors      +      sr.d_nodatas      + sr.d_nxdomains           +      sr.d_unknowns) % "" % "";
 338   cerr<< datafmt % "  Timeouts " % (inflighter.getTimeouts()) % "" % "";
 339   cerr<< datafmt % "Total " % (sr.d_oks      +      sr.d_errors      +      sr.d_nodatas      + sr.d_nxdomains           +      sr.d_unknowns + inflighter.getTimeouts()) % "" % "";
 340
 341   cerr<<"\n";
 342   cerr<< "Mean response time: "<<mean(*sr.d_acc) << " msec"<<", median: "<<median(*sr.d_acc)<< " msec\n";
 343
 344   boost::format statfmt("Time < %6.03f msec %|30t|%6.03f%% cumulative\n");
 345
 346   for (unsigned int i = 0; i < sr.d_probs.size(); ++i) {
 347         cerr << statfmt % extended_p_square(*sr.d_acc)[i] % (100*sr.d_probs[i]);
 348     }
 349
 350   if(g_envoutput) {
 351     cout<<"DBT_QUEUED="<<domains.size()<<endl;
 352     cout<<"DBT_SENDERRORS="<<sr.d_senderrors<<endl;
 353     cout<<"DBT_RECEIVED="<<sr.d_receiveds<<endl;
 354     cout<<"DBT_TIMEOUTS="<<inflighter.getTimeouts()<<endl;
 355     cout<<"DBT_UNEXPECTEDS="<<inflighter.getUnexpecteds()<<endl;
 356     cout<<"DBT_OKPERCENTAGE="<<((float)sr.d_oks/domains.size()*100)<<endl;
 357     cout<<"DBT_OKPERCENTAGEINT="<<(int)((float)sr.d_oks/domains.size()*100)<<endl;
 358   }
 359 }
 360 catch(PDNSException& pe)
 361 {
 362   cerr<<"Fatal error: "<<pe.reason<<endl;
 363   exit(EXIT_FAILURE);
 364 }