net/tools/quic/quic_client_bin.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // A binary wrapper for QuicClient.
   6 // Connects to a host using QUIC, sends a request to the provided URL, and
   7 // displays the response.
   8 //
   9 // Some usage examples:
  10 //
  11 //   TODO(rtenneti): make --host optional by getting IP Address of URL's host.
  12 //
  13 //   Get IP address of the www.google.com
  14 //   IP=`dig www.google.com +short | head -1`
  15 //
  16 // Standard request/response:
  17 //   quic_client http://www.google.com  --host=${IP}
  18 //   quic_client http://www.google.com --quiet  --host=${IP}
  19 //   quic_client https://www.google.com --port=443  --host=${IP}
  20 //
  21 // Use a specific version:
  22 //   quic_client http://www.google.com --version=23  --host=${IP}
  23 //
  24 // Send a POST instead of a GET:
  25 //   quic_client http://www.google.com --body="this is a POST body" --host=${IP}
  26 //
  27 // Append additional headers to the request:
  28 //   quic_client http://www.google.com  --host=${IP}
  29 //               --headers="Header-A: 1234; Header-B: 5678"
  30 //
  31 // Connect to a host different to the URL being requested:
  32 //   Get IP address of the www.google.com
  33 //   IP=`dig www.google.com +short | head -1`
  34 //   quic_client mail.google.com --host=${IP}
  35 //
  36 // Try to connect to a host which does not speak QUIC:
  37 //   Get IP address of the www.example.com
  38 //   IP=`dig www.example.com +short | head -1`
  39 //   quic_client http://www.example.com --host=${IP}
  40
  41 #include <iostream>
  42
  43 #include "base/at_exit.h"
  44 #include "base/command_line.h"
  45 #include "base/logging.h"
  46 #include "base/strings/string_number_conversions.h"
  47 #include "base/strings/string_split.h"
  48 #include "base/strings/string_util.h"
  49 #include "net/base/ip_endpoint.h"
  50 #include "net/base/net_errors.h"
  51 #include "net/base/privacy_mode.h"
  52 #include "net/cert/cert_verifier.h"
  53 #include "net/http/transport_security_state.h"
  54 #include "net/log/net_log.h"
  55 #include "net/quic/crypto/proof_verifier_chromium.h"
  56 #include "net/quic/quic_protocol.h"
  57 #include "net/quic/quic_server_id.h"
  58 #include "net/quic/quic_utils.h"
  59 #include "net/tools/epoll_server/epoll_server.h"
  60 #include "net/tools/quic/quic_client.h"
  61 #include "net/tools/quic/spdy_balsa_utils.h"
  62 #include "net/tools/quic/synchronous_host_resolver.h"
  63 #include "url/gurl.h"
  64
  65 using base::StringPiece;
  66 using net::CertVerifier;
  67 using net::ProofVerifierChromium;
  68 using net::TransportSecurityState;
  69 using std::cout;
  70 using std::cerr;
  71 using std::map;
  72 using std::string;
  73 using std::vector;
  74 using std::endl;
  75
  76 // The IP or hostname the quic client will connect to.
  77 string FLAGS_host = "";
  78 // The port to connect to.
  79 int32 FLAGS_port = 80;
  80 // If set, send a POST with this body.
  81 string FLAGS_body = "";
  82 // A semicolon separated list of key:value pairs to add to request headers.
  83 string FLAGS_headers = "";
  84 // Set to true for a quieter output experience.
  85 bool FLAGS_quiet = false;
  86 // QUIC version to speak, e.g. 21. If not set, then all available versions are
  87 // offered in the handshake.
  88 int32 FLAGS_quic_version = -1;
  89 // If true, a version mismatch in the handshake is not considered a failure.
  90 // Useful for probing a server to determine if it speaks any version of QUIC.
  91 bool FLAGS_version_mismatch_ok = false;
  92 // If true, an HTTP response code of 3xx is considered to be a successful
  93 // response, otherwise a failure.
  94 bool FLAGS_redirect_is_success = true;
  95 // Initial MTU of the connection.
  96 int32 FLAGS_initial_mtu = 0;
  97
  98 int main(int argc, char *argv[]) {
  99   base::CommandLine::Init(argc, argv);
 100   base::CommandLine* line = base::CommandLine::ForCurrentProcess();
 101   const base::CommandLine::StringVector& urls = line->GetArgs();
 102
 103   logging::LoggingSettings settings;
 104   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 105   CHECK(logging::InitLogging(settings));
 106
 107   if (line->HasSwitch("h") || line->HasSwitch("help") || urls.empty()) {
 108     const char* help_str =
 109         "Usage: quic_client [options] <url>\n"
 110         "\n"
 111         "<url> with scheme must be provided (e.g. http://www.google.com)\n\n"
 112         "Options:\n"
 113         "-h, --help                  show this help message and exit\n"
 114         "--host=<host>               specify the IP address of the hostname to "
 115         "connect to\n"
 116         "--port=<port>               specify the port to connect to\n"
 117         "--body=<body>               specify the body to post\n"
 118         "--headers=<headers>         specify a semicolon separated list of "
 119         "key:value pairs to add to request headers\n"
 120         "--quiet                     specify for a quieter output experience\n"
 121         "--quic-version=<quic version> specify QUIC version to speak\n"
 122         "--version_mismatch_ok       if specified a version mismatch in the "
 123         "handshake is not considered a failure\n"
 124         "--redirect_is_success       if specified an HTTP response code of 3xx "
 125         "is considered to be a successful response, otherwise a failure\n"
 126         "--initial_mtu=<initial_mtu> specify the initial MTU of the connection"
 127         "\n";
 128     cout << help_str;
 129     exit(0);
 130   }
 131   if (line->HasSwitch("host")) {
 132     FLAGS_host = line->GetSwitchValueASCII("host");
 133   }
 134   if (line->HasSwitch("port")) {
 135     if (!base::StringToInt(line->GetSwitchValueASCII("port"), &FLAGS_port)) {
 136       std::cerr << "--port must be an integer\n";
 137       return 1;
 138     }
 139   }
 140   if (line->HasSwitch("body")) {
 141     FLAGS_body = line->GetSwitchValueASCII("body");
 142   }
 143   if (line->HasSwitch("headers")) {
 144     FLAGS_headers = line->GetSwitchValueASCII("headers");
 145   }
 146   if (line->HasSwitch("quiet")) {
 147     FLAGS_quiet = true;
 148   }
 149   if (line->HasSwitch("quic-version")) {
 150     int quic_version;
 151     if (base::StringToInt(line->GetSwitchValueASCII("quic-version"),
 152                           &quic_version)) {
 153       FLAGS_quic_version = quic_version;
 154     }
 155   }
 156   if (line->HasSwitch("version_mismatch_ok")) {
 157     FLAGS_version_mismatch_ok = true;
 158   }
 159   if (line->HasSwitch("redirect_is_success")) {
 160     FLAGS_redirect_is_success = true;
 161   }
 162   if (line->HasSwitch("initial_mtu")) {
 163     if (!base::StringToInt(line->GetSwitchValueASCII("initial_mtu"),
 164                            &FLAGS_initial_mtu)) {
 165       std::cerr << "--initial_mtu must be an integer\n";
 166       return 1;
 167     }
 168   }
 169
 170   VLOG(1) << "server host: " << FLAGS_host << " port: " << FLAGS_port
 171           << " body: " << FLAGS_body << " headers: " << FLAGS_headers
 172           << " quiet: " << FLAGS_quiet
 173           << " quic-version: " << FLAGS_quic_version
 174           << " version_mismatch_ok: " << FLAGS_version_mismatch_ok
 175           << " redirect_is_success: " << FLAGS_redirect_is_success
 176           << " initial_mtu: " << FLAGS_initial_mtu;
 177
 178   base::AtExitManager exit_manager;
 179
 180   // Determine IP address to connect to from supplied hostname.
 181   net::IPAddressNumber ip_addr;
 182
 183   // TODO(rtenneti): GURL's doesn't support default_protocol argument, thus
 184   // protocol is required in the URL.
 185   GURL url(urls[0]);
 186   string host = FLAGS_host;
 187   if (host.empty()) {
 188     host = url.host();
 189   }
 190   if (!net::ParseIPLiteralToNumber(host, &ip_addr)) {
 191     net::AddressList addresses;
 192     int rv = net::tools::SynchronousHostResolver::Resolve(host, &addresses);
 193     if (rv != net::OK) {
 194       LOG(ERROR) << "Unable to resolve '" << host << "' : "
 195                  << net::ErrorToShortString(rv);
 196       return 1;
 197     }
 198     ip_addr = addresses[0].address();
 199   }
 200
 201   string host_port = net::IPAddressToStringWithPort(ip_addr, FLAGS_port);
 202   VLOG(1) << "Resolved " << host << " to " << host_port << endl;
 203
 204   // Build the client, and try to connect.
 205   bool is_https = (FLAGS_port == 443);
 206   net::EpollServer epoll_server;
 207   net::QuicServerId server_id(url.host(), FLAGS_port, is_https,
 208                               net::PRIVACY_MODE_DISABLED);
 209   net::QuicVersionVector versions = net::QuicSupportedVersions();
 210   if (FLAGS_quic_version != -1) {
 211     versions.clear();
 212     versions.push_back(static_cast<net::QuicVersion>(FLAGS_quic_version));
 213   }
 214   net::tools::QuicClient client(net::IPEndPoint(ip_addr, FLAGS_port), server_id,
 215                                 versions, &epoll_server);
 216   scoped_ptr<CertVerifier> cert_verifier;
 217   scoped_ptr<TransportSecurityState> transport_security_state;
 218   client.set_initial_max_packet_length(
 219       FLAGS_initial_mtu != 0 ? FLAGS_initial_mtu : net::kDefaultMaxPacketSize);
 220   if (is_https) {
 221     // For secure QUIC we need to verify the cert chain.
 222     cert_verifier.reset(CertVerifier::CreateDefault());
 223     transport_security_state.reset(new TransportSecurityState);
 224     client.SetProofVerifier(new ProofVerifierChromium(
 225         cert_verifier.get(), transport_security_state.get()));
 226   }
 227   if (!client.Initialize()) {
 228     cerr << "Failed to initialize client." << endl;
 229     return 1;
 230   }
 231   if (!client.Connect()) {
 232     net::QuicErrorCode error = client.session()->error();
 233     if (FLAGS_version_mismatch_ok && error == net::QUIC_INVALID_VERSION) {
 234       cout << "Server talks QUIC, but none of the versions supported by "
 235            << "this client: " << QuicVersionVectorToString(versions) << endl;
 236       // Version mismatch is not deemed a failure.
 237       return 0;
 238     }
 239     cerr << "Failed to connect to " << host_port
 240          << ". Error: " << net::QuicUtils::ErrorToString(error) << endl;
 241     return 1;
 242   }
 243   cout << "Connected to " << host_port << endl;
 244
 245   // Construct a GET or POST request for supplied URL.
 246   net::BalsaHeaders headers;
 247   headers.SetRequestFirstlineFromStringPieces(
 248       FLAGS_body.empty() ? "GET" : "POST", url.spec(), "HTTP/1.1");
 249
 250   // Append any additional headers supplied on the command line.
 251   for (const std::string& header :
 252        base::SplitString(FLAGS_headers, ";", base::KEEP_WHITESPACE,
 253                          base::SPLIT_WANT_NONEMPTY)) {
 254     string sp;
 255     base::TrimWhitespaceASCII(header, base::TRIM_ALL, &sp);
 256     if (sp.empty()) {
 257       continue;
 258     }
 259     vector<string> kv =
 260         base::SplitString(sp, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 261     CHECK_EQ(2u, kv.size());
 262     string key;
 263     base::TrimWhitespaceASCII(kv[0], base::TRIM_ALL, &key);
 264     string value;
 265     base::TrimWhitespaceASCII(kv[1], base::TRIM_ALL, &value);
 266     headers.AppendHeader(key, value);
 267   }
 268
 269   // Make sure to store the response, for later output.
 270   client.set_store_response(true);
 271
 272   // Send the request.
 273   map<string, string> header_block =
 274       net::tools::SpdyBalsaUtils::RequestHeadersToSpdyHeaders(
 275           headers, client.session()->connection()->version());
 276   client.SendRequestAndWaitForResponse(headers, FLAGS_body, /*fin=*/true);
 277
 278   // Print request and response details.
 279   if (!FLAGS_quiet) {
 280     cout << "Request:" << endl;
 281     cout << "headers:" << endl;
 282     for (const std::pair<string, string>& kv : header_block) {
 283       cout << " " << kv.first << ": " << kv.second << endl;
 284     }
 285     cout << "body: " << FLAGS_body << endl;
 286     cout << endl;
 287     cout << "Response:" << endl;
 288     cout << "headers: " << client.latest_response_headers() << endl;
 289     cout << "body: " << client.latest_response_body() << endl;
 290   }
 291
 292   size_t response_code = client.latest_response_code();
 293   if (response_code >= 200 && response_code < 300) {
 294     cout << "Request succeeded (" << response_code << ")." << endl;
 295     return 0;
 296   } else if (response_code >= 300 && response_code < 400) {
 297     if (FLAGS_redirect_is_success) {
 298       cout << "Request succeeded (redirect " << response_code << ")." << endl;
 299       return 0;
 300     } else {
 301       cout << "Request failed (redirect " << response_code << ")." << endl;
 302       return 1;
 303     }
 304   } else {
 305     cerr << "Request failed (" << response_code << ")." << endl;
 306     return 1;
 307   }
 308 }