net/tools/quic/test_tools/quic_test_client.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 #include "net/tools/quic/test_tools/quic_test_client.h"
   6
   7 #include "base/time/time.h"
   8 #include "net/base/completion_callback.h"
   9 #include "net/base/net_errors.h"
  10 #include "net/cert/cert_verify_result.h"
  11 #include "net/cert/x509_certificate.h"
  12 #include "net/quic/crypto/proof_verifier.h"
  13 #include "net/quic/quic_server_id.h"
  14 #include "net/quic/test_tools/quic_connection_peer.h"
  15 #include "net/quic/test_tools/quic_session_peer.h"
  16 #include "net/quic/test_tools/quic_test_utils.h"
  17 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
  18 #include "net/tools/balsa/balsa_headers.h"
  19 #include "net/tools/quic/quic_epoll_connection_helper.h"
  20 #include "net/tools/quic/quic_packet_writer_wrapper.h"
  21 #include "net/tools/quic/quic_spdy_client_stream.h"
  22 #include "net/tools/quic/test_tools/http_message.h"
  23 #include "net/tools/quic/test_tools/quic_client_peer.h"
  24 #include "url/gurl.h"
  25
  26 using base::StringPiece;
  27 using net::QuicServerId;
  28 using net::test::QuicConnectionPeer;
  29 using net::test::QuicSessionPeer;
  30 using net::test::ReliableQuicStreamPeer;
  31 using std::string;
  32 using std::vector;
  33
  34 namespace net {
  35 namespace tools {
  36 namespace test {
  37 namespace {
  38
  39 // RecordingProofVerifier accepts any certificate chain and records the common
  40 // name of the leaf.
  41 class RecordingProofVerifier : public ProofVerifier {
  42  public:
  43   // ProofVerifier interface.
  44   QuicAsyncStatus VerifyProof(const string& hostname,
  45                               const string& server_config,
  46                               const vector<string>& certs,
  47                               const string& signature,
  48                               const ProofVerifyContext* context,
  49                               string* error_details,
  50                               scoped_ptr<ProofVerifyDetails>* details,
  51                               ProofVerifierCallback* callback) override {
  52     common_name_.clear();
  53     if (certs.empty()) {
  54       return QUIC_FAILURE;
  55     }
  56
  57     // Convert certs to X509Certificate.
  58     vector<StringPiece> cert_pieces(certs.size());
  59     for (unsigned i = 0; i < certs.size(); i++) {
  60       cert_pieces[i] = StringPiece(certs[i]);
  61     }
  62     scoped_refptr<net::X509Certificate> cert =
  63         net::X509Certificate::CreateFromDERCertChain(cert_pieces);
  64     if (!cert.get()) {
  65       return QUIC_FAILURE;
  66     }
  67
  68     common_name_ = cert->subject().GetDisplayName();
  69     return QUIC_SUCCESS;
  70   }
  71
  72   const string& common_name() const { return common_name_; }
  73
  74  private:
  75   string common_name_;
  76 };
  77
  78 }  // anonymous namespace
  79
  80 BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers,
  81                            bool secure) {
  82   StringPiece uri = const_headers->request_uri();
  83   if (uri.empty()) {
  84     return nullptr;
  85   }
  86   if (const_headers->request_method() == "CONNECT") {
  87     return nullptr;
  88   }
  89   BalsaHeaders* headers = new BalsaHeaders;
  90   headers->CopyFrom(*const_headers);
  91   if (!uri.starts_with("https://") &&
  92       !uri.starts_with("http://")) {
  93     // If we have a relative URL, set some defaults.
  94     string full_uri = secure ? "https://www.google.com" :
  95                                "http://www.google.com";
  96     full_uri.append(uri.as_string());
  97     headers->SetRequestUri(full_uri);
  98   }
  99   return headers;
 100 }
 101
 102 MockableQuicClient::MockableQuicClient(
 103     IPEndPoint server_address,
 104     const QuicServerId& server_id,
 105     const QuicVersionVector& supported_versions,
 106     EpollServer* epoll_server)
 107     : QuicClient(server_address,
 108                  server_id,
 109                  supported_versions,
 110                  false,
 111                  epoll_server),
 112       override_connection_id_(0),
 113       test_writer_(nullptr) {}
 114
 115 MockableQuicClient::MockableQuicClient(
 116     IPEndPoint server_address,
 117     const QuicServerId& server_id,
 118     const QuicConfig& config,
 119     const QuicVersionVector& supported_versions,
 120     EpollServer* epoll_server)
 121     : QuicClient(server_address,
 122                  server_id,
 123                  supported_versions,
 124                  false,
 125                  config,
 126                  epoll_server),
 127       override_connection_id_(0),
 128       test_writer_(nullptr) {}
 129
 130 MockableQuicClient::~MockableQuicClient() {
 131   if (connected()) {
 132     Disconnect();
 133   }
 134 }
 135
 136 QuicPacketWriter* MockableQuicClient::CreateQuicPacketWriter() {
 137   QuicPacketWriter* writer = QuicClient::CreateQuicPacketWriter();
 138   if (!test_writer_) {
 139     return writer;
 140   }
 141   test_writer_->set_writer(writer);
 142   return test_writer_;
 143 }
 144
 145 QuicConnectionId MockableQuicClient::GenerateConnectionId() {
 146   return override_connection_id_ ? override_connection_id_
 147       : QuicClient::GenerateConnectionId();
 148 }
 149
 150 // Takes ownership of writer.
 151 void MockableQuicClient::UseWriter(QuicPacketWriterWrapper* writer) {
 152   CHECK(test_writer_ == nullptr);
 153   test_writer_ = writer;
 154 }
 155
 156 void MockableQuicClient::UseConnectionId(QuicConnectionId connection_id) {
 157   override_connection_id_ = connection_id;
 158 }
 159
 160 QuicTestClient::QuicTestClient(IPEndPoint server_address,
 161                                const string& server_hostname,
 162                                bool secure,
 163                                const QuicVersionVector& supported_versions)
 164     : client_(new MockableQuicClient(server_address,
 165                                      QuicServerId(server_hostname,
 166                                                   server_address.port(),
 167                                                   secure,
 168                                                   PRIVACY_MODE_DISABLED),
 169                                      supported_versions,
 170                                      &epoll_server_)) {
 171   Initialize(secure);
 172 }
 173
 174 QuicTestClient::QuicTestClient(
 175     IPEndPoint server_address,
 176     const string& server_hostname,
 177     bool secure,
 178     const QuicConfig& config,
 179     const QuicVersionVector& supported_versions)
 180     : client_(
 181           new MockableQuicClient(server_address,
 182                                  QuicServerId(server_hostname,
 183                                               server_address.port(),
 184                                               secure,
 185                                               PRIVACY_MODE_DISABLED),
 186                                  config,
 187                                  supported_versions,
 188                                  &epoll_server_)) {
 189   Initialize(secure);
 190 }
 191
 192 QuicTestClient::QuicTestClient() {
 193 }
 194
 195 QuicTestClient::~QuicTestClient() {
 196   if (stream_) {
 197     stream_->set_visitor(nullptr);
 198   }
 199 }
 200
 201 void QuicTestClient::Initialize(bool secure) {
 202   priority_ = 3;
 203   connect_attempted_ = false;
 204   secure_ = secure;
 205   auto_reconnect_ = false;
 206   buffer_body_ = true;
 207   fec_policy_ = FEC_PROTECT_OPTIONAL;
 208   proof_verifier_ = nullptr;
 209   ClearPerRequestState();
 210   ExpectCertificates(secure_);
 211   // As chrome will generally do this, we want it to be the default when it's
 212   // not overridden.
 213   if (!client_->config()->HasSetBytesForConnectionIdToSend()) {
 214     client_->config()->SetBytesForConnectionIdToSend(0);
 215   }
 216 }
 217
 218 void QuicTestClient::ExpectCertificates(bool on) {
 219   if (on) {
 220     proof_verifier_ = new RecordingProofVerifier;
 221     client_->SetProofVerifier(proof_verifier_);
 222   } else {
 223     proof_verifier_ = nullptr;
 224     client_->SetProofVerifier(nullptr);
 225   }
 226 }
 227
 228 void QuicTestClient::SetUserAgentID(const string& user_agent_id) {
 229   client_->SetUserAgentID(user_agent_id);
 230 }
 231
 232 ssize_t QuicTestClient::SendRequest(const string& uri) {
 233   HTTPMessage message(HttpConstants::HTTP_1_1,
 234                       HttpConstants::GET,
 235                       uri);
 236   return SendMessage(message);
 237 }
 238
 239 ssize_t QuicTestClient::SendMessage(const HTTPMessage& message) {
 240   stream_ = nullptr;  // Always force creation of a stream for SendMessage.
 241
 242   // If we're not connected, try to find an sni hostname.
 243   if (!connected()) {
 244     GURL url(message.headers()->request_uri().as_string());
 245     if (!url.host().empty()) {
 246       client_->set_server_id(
 247           QuicServerId(url.host(),
 248                        url.EffectiveIntPort(),
 249                        url.SchemeIs("https"),
 250                        PRIVACY_MODE_DISABLED));
 251     }
 252   }
 253
 254   QuicSpdyClientStream* stream = GetOrCreateStream();
 255   if (!stream) { return 0; }
 256
 257   scoped_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers(),
 258                                           secure_));
 259   ssize_t ret = GetOrCreateStream()->SendRequest(
 260       munged_headers.get() ? *munged_headers.get() : *message.headers(),
 261       message.body(),
 262       message.has_complete_message());
 263   WaitForWriteToFlush();
 264   return ret;
 265 }
 266
 267 ssize_t QuicTestClient::SendData(string data, bool last_data) {
 268   QuicSpdyClientStream* stream = GetOrCreateStream();
 269   if (!stream) { return 0; }
 270   GetOrCreateStream()->SendBody(data, last_data);
 271   WaitForWriteToFlush();
 272   return data.length();
 273 }
 274
 275 bool QuicTestClient::response_complete() const {
 276   return response_complete_;
 277 }
 278
 279 int QuicTestClient::response_header_size() const {
 280   return response_header_size_;
 281 }
 282
 283 int64 QuicTestClient::response_body_size() const {
 284   return response_body_size_;
 285 }
 286
 287 bool QuicTestClient::buffer_body() const {
 288   return buffer_body_;
 289 }
 290
 291 void QuicTestClient::set_buffer_body(bool buffer_body) {
 292   buffer_body_ = buffer_body;
 293 }
 294
 295 bool QuicTestClient::ServerInLameDuckMode() const {
 296   return false;
 297 }
 298
 299 const string& QuicTestClient::response_body() {
 300   return response_;
 301 }
 302
 303 string QuicTestClient::SendCustomSynchronousRequest(
 304     const HTTPMessage& message) {
 305   SendMessage(message);
 306   WaitForResponse();
 307   return response_;
 308 }
 309
 310 string QuicTestClient::SendSynchronousRequest(const string& uri) {
 311   if (SendRequest(uri) == 0) {
 312     DLOG(ERROR) << "Failed the request for uri:" << uri;
 313     return "";
 314   }
 315   WaitForResponse();
 316   return response_;
 317 }
 318
 319 QuicSpdyClientStream* QuicTestClient::GetOrCreateStream() {
 320   if (!connect_attempted_ || auto_reconnect_) {
 321     if (!connected()) {
 322       Connect();
 323     }
 324     if (!connected()) {
 325       return nullptr;
 326     }
 327   }
 328   if (!stream_) {
 329     stream_ = client_->CreateReliableClientStream();
 330     if (stream_ == nullptr) {
 331       return nullptr;
 332     }
 333     stream_->set_visitor(this);
 334     reinterpret_cast<QuicSpdyClientStream*>(stream_)->set_priority(priority_);
 335     // Set FEC policy on stream.
 336     ReliableQuicStreamPeer::SetFecPolicy(stream_, fec_policy_);
 337   }
 338
 339   return stream_;
 340 }
 341
 342 QuicErrorCode QuicTestClient::connection_error() {
 343   return client()->session()->error();
 344 }
 345
 346 MockableQuicClient* QuicTestClient::client() { return client_.get(); }
 347
 348 const string& QuicTestClient::cert_common_name() const {
 349   return reinterpret_cast<RecordingProofVerifier*>(proof_verifier_)
 350       ->common_name();
 351 }
 352
 353 QuicTagValueMap QuicTestClient::GetServerConfig() const {
 354   QuicCryptoClientConfig* config =
 355       QuicClientPeer::GetCryptoConfig(client_.get());
 356   QuicCryptoClientConfig::CachedState* state =
 357       config->LookupOrCreate(client_->server_id());
 358   const CryptoHandshakeMessage* handshake_msg = state->GetServerConfig();
 359   if (handshake_msg != nullptr) {
 360     return handshake_msg->tag_value_map();
 361   } else {
 362     return QuicTagValueMap();
 363   }
 364 }
 365
 366 bool QuicTestClient::connected() const {
 367   return client_->connected();
 368 }
 369
 370 void QuicTestClient::Connect() {
 371   DCHECK(!connected());
 372   if (!connect_attempted_) {
 373     client_->Initialize();
 374   }
 375   client_->Connect();
 376   connect_attempted_ = true;
 377 }
 378
 379 void QuicTestClient::ResetConnection() {
 380   Disconnect();
 381   Connect();
 382 }
 383
 384 void QuicTestClient::Disconnect() {
 385   client_->Disconnect();
 386   connect_attempted_ = false;
 387 }
 388
 389 IPEndPoint QuicTestClient::LocalSocketAddress() const {
 390   return client_->client_address();
 391 }
 392
 393 void QuicTestClient::ClearPerRequestState() {
 394   stream_error_ = QUIC_STREAM_NO_ERROR;
 395   stream_ = nullptr;
 396   response_ = "";
 397   response_complete_ = false;
 398   response_headers_complete_ = false;
 399   headers_.Clear();
 400   bytes_read_ = 0;
 401   bytes_written_ = 0;
 402   response_header_size_ = 0;
 403   response_body_size_ = 0;
 404 }
 405
 406 void QuicTestClient::WaitForResponseForMs(int timeout_ms) {
 407   int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond;
 408   int64 old_timeout_us = epoll_server()->timeout_in_us();
 409   if (timeout_us > 0) {
 410     epoll_server()->set_timeout_in_us(timeout_us);
 411   }
 412   const QuicClock* clock =
 413       QuicConnectionPeer::GetHelper(client()->session()->connection())->
 414           GetClock();
 415   QuicTime end_waiting_time = clock->Now().Add(
 416       QuicTime::Delta::FromMicroseconds(timeout_us));
 417   while (stream_ != nullptr &&
 418          !client_->session()->IsClosedStream(stream_->id()) &&
 419          (timeout_us < 0 || clock->Now() < end_waiting_time)) {
 420     client_->WaitForEvents();
 421   }
 422   if (timeout_us > 0) {
 423     epoll_server()->set_timeout_in_us(old_timeout_us);
 424   }
 425 }
 426
 427 void QuicTestClient::WaitForInitialResponseForMs(int timeout_ms) {
 428   int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond;
 429   int64 old_timeout_us = epoll_server()->timeout_in_us();
 430   if (timeout_us > 0) {
 431     epoll_server()->set_timeout_in_us(timeout_us);
 432   }
 433   const QuicClock* clock =
 434       QuicConnectionPeer::GetHelper(client()->session()->connection())->
 435           GetClock();
 436   QuicTime end_waiting_time = clock->Now().Add(
 437       QuicTime::Delta::FromMicroseconds(timeout_us));
 438   while (stream_ != nullptr &&
 439          !client_->session()->IsClosedStream(stream_->id()) &&
 440          stream_->stream_bytes_read() == 0 &&
 441          (timeout_us < 0 || clock->Now() < end_waiting_time)) {
 442     client_->WaitForEvents();
 443   }
 444   if (timeout_us > 0) {
 445     epoll_server()->set_timeout_in_us(old_timeout_us);
 446   }
 447 }
 448
 449 ssize_t QuicTestClient::Send(const void *buffer, size_t size) {
 450   return SendData(string(static_cast<const char*>(buffer), size), false);
 451 }
 452
 453 bool QuicTestClient::response_headers_complete() const {
 454   if (stream_ != nullptr) {
 455     return stream_->headers_decompressed();
 456   } else {
 457     return response_headers_complete_;
 458   }
 459 }
 460
 461 const BalsaHeaders* QuicTestClient::response_headers() const {
 462   if (stream_ != nullptr) {
 463     return &stream_->headers();
 464   } else {
 465     return &headers_;
 466   }
 467 }
 468
 469 int64 QuicTestClient::response_size() const {
 470   return bytes_read_;
 471 }
 472
 473 size_t QuicTestClient::bytes_read() const {
 474   return bytes_read_;
 475 }
 476
 477 size_t QuicTestClient::bytes_written() const {
 478   return bytes_written_;
 479 }
 480
 481 void QuicTestClient::OnClose(QuicDataStream* stream) {
 482   if (stream_ != stream) {
 483     return;
 484   }
 485   if (buffer_body()) {
 486     // TODO(fnk): The stream still buffers the whole thing. Fix that.
 487     response_ = stream_->data();
 488   }
 489   response_complete_ = true;
 490   response_headers_complete_ = stream_->headers_decompressed();
 491   headers_.CopyFrom(stream_->headers());
 492   stream_error_ = stream_->stream_error();
 493   bytes_read_ = stream_->stream_bytes_read() + stream_->header_bytes_read();
 494   bytes_written_ =
 495       stream_->stream_bytes_written() + stream_->header_bytes_written();
 496   response_header_size_ = headers_.GetSizeForWriteBuffer();
 497   response_body_size_ = stream_->data().size();
 498   stream_ = nullptr;
 499 }
 500
 501 void QuicTestClient::UseWriter(QuicPacketWriterWrapper* writer) {
 502   client_->UseWriter(writer);
 503 }
 504
 505 void QuicTestClient::UseConnectionId(QuicConnectionId connection_id) {
 506   DCHECK(!connected());
 507   client_->UseConnectionId(connection_id);
 508 }
 509
 510 ssize_t QuicTestClient::SendAndWaitForResponse(const void *buffer,
 511                                                size_t size) {
 512   LOG(DFATAL) << "Not implemented";
 513   return 0;
 514 }
 515
 516 void QuicTestClient::Bind(IPEndPoint* local_address) {
 517   DLOG(WARNING) << "Bind will be done during connect";
 518 }
 519
 520 string QuicTestClient::SerializeMessage(const HTTPMessage& message) {
 521   LOG(DFATAL) << "Not implemented";
 522   return "";
 523 }
 524
 525 IPAddressNumber QuicTestClient::bind_to_address() const {
 526   return client_->bind_to_address();
 527 }
 528
 529 void QuicTestClient::set_bind_to_address(IPAddressNumber address) {
 530   client_->set_bind_to_address(address);
 531 }
 532
 533 const IPEndPoint& QuicTestClient::address() const {
 534   LOG(DFATAL) << "Not implemented";
 535   return client_->server_address();
 536 }
 537
 538 size_t QuicTestClient::requests_sent() const {
 539   LOG(DFATAL) << "Not implemented";
 540   return 0;
 541 }
 542
 543 void QuicTestClient::WaitForWriteToFlush() {
 544   while (connected() && client()->session()->HasDataToWrite()) {
 545     client_->WaitForEvents();
 546   }
 547 }
 548
 549 void QuicTestClient::SetFecPolicy(FecPolicy fec_policy) {
 550   fec_policy_ = fec_policy;
 551   // Set policy for headers and crypto streams.
 552   ReliableQuicStreamPeer::SetFecPolicy(
 553       QuicSessionPeer::GetHeadersStream(client()->session()), fec_policy);
 554   ReliableQuicStreamPeer::SetFecPolicy(client()->session()->GetCryptoStream(),
 555                                        fec_policy);
 556 }
 557
 558 }  // namespace test
 559 }  // namespace tools
 560 }  // namespace net