Send the ClientHello handshake message. Fix a bug in

net/quic/quic_crypto_client_stream.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_crypto_client_stream.h"
 
 #include "net/quic/crypto/crypto_protocol.h"
+#include "net/quic/crypto/quic_random.h"
+#include "net/quic/quic_clock.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/quic_session.h"
+
+using base::StringPiece;
 
 namespace net {
 
 QuicCryptoClientStream::QuicCryptoClientStream(QuicSession* session)
     : QuicCryptoStream(session) {
 }
 
 
 void QuicCryptoClientStream::OnHandshakeMessage(
     const CryptoHandshakeMessage& message) {
   // Do not process handshake messages after the handshake is complete.
   if (handshake_complete()) {
     CloseConnection(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE);
     return;
   }
 
   if (message.tag != kSHLO) {
     CloseConnection(QUIC_INVALID_CRYPTO_MESSAGE_TYPE);
     return;
   }
 
   // TODO(rch): correctly validate the message
   SetHandshakeComplete(QUIC_NO_ERROR);
   return;
 }
 
+bool QuicCryptoClientStream::CryptoConnect() {
+  CryptoHandshakeMessage message;
+  if (!FillClientHelloMessage(&message)) {
+    return false;
+  }
+  SendHandshakeMessage(message);
+  return true;
+}
+
+// Generates the connection nonce.
+void QuicCryptoClientStream::GenerateNonce() {
+  // a 4-byte timestamp + 28 random bytes.
+  nonce_.reserve(kNonceSize);
+  nonce_.resize(kNonceSize);
+  QuicTime::Delta now =
+      session()->connection()->clock()->NowAsDeltaSinceUnixEpoch();
+  uint32 gmt_unix_time = now.ToSeconds();
+  const size_t time_size = sizeof(gmt_unix_time);
+  memcpy(&nonce_[0], &gmt_unix_time, time_size);
+  QuicRandom::GetInstance()->RandBytes(&nonce_[time_size],
+                                       kNonceSize - time_size);
+}
+
+bool QuicCryptoClientStream::FillClientHelloMessage(
+    CryptoHandshakeMessage* message) {
+  message->tag = kCHLO;
+
+  StringPiece value;
+
+  // Version must be 0.
+  version_ = 0;
+  value.set(&version_, sizeof(version_));
+  message->tag_value_map[kVERS] = value.as_string();
+
+  // Key exchange methods.
+  key_exchange_.resize(2);
+  key_exchange_[0] = kC255;
+  key_exchange_[1] = kP256;
+  value.set(&key_exchange_[0],
+            key_exchange_.size() * sizeof(key_exchange_[0]));
+  message->tag_value_map[kKEXS] = value.as_string();
+
+  // Authenticated encryption algorithms.
+  aead_.resize(2);
+  aead_[0] = kAESG;
+  aead_[1] = kAESH;
+  value.set(&aead_[0], aead_.size() * sizeof(aead_[0]));
+  message->tag_value_map[kAEAD] = value.as_string();
+
+  // Congestion control feedback types.
+  congestion_control_.resize(2);
+  congestion_control_[0] = kQBIC;
+  congestion_control_[1] = kINAR;
+  value.set(&congestion_control_[0],
+            congestion_control_.size() * sizeof(congestion_control_[0]));
+  message->tag_value_map[kCGST] = value.as_string();
+
+  // Idle connection state lifetime.
+  idle_connection_state_lifetime_ = 300;  // 300 seconds.
+  value.set(&idle_connection_state_lifetime_,
+            sizeof(idle_connection_state_lifetime_));
+  message->tag_value_map[kICSL] = value.as_string();
+
+  // Keepalive timeout.
+  keepalive_timeout_ = 0;  // Don't send keepalive probes.
+  value.set(&keepalive_timeout_, sizeof(keepalive_timeout_));
+  message->tag_value_map[kKATO] = value.as_string();
+
+  // Connection nonce.
+  GenerateNonce();
+  if (nonce_.empty()) {
+    return false;
+  }
+  message->tag_value_map[kNONC] = nonce_;
+
+  // Server name indication.
+  // TODO(wtc): if server_hostname_ is a DNS name, store it in
+  // message->tag_value_map[kSNI].
+
+  return true;
+}
+
 }  // namespace net