Land Recent QUIC Changes

net/tools/quic/quic_server.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/tools/quic/quic_server.h"
 
 #include <errno.h>
 #include <features.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/epoll.h>
 #include <sys/socket.h>
 
 #include "net/base/ip_endpoint.h"
+#include "net/quic/crypto/crypto_handshake.h"
+#include "net/quic/crypto/quic_random.h"
+#include "net/quic/quic_clock.h"
+#include "net/quic/quic_crypto_stream.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_protocol.h"
 #include "net/tools/quic/quic_in_memory_cache.h"
 #include "net/tools/quic/quic_socket_utils.h"
 
 #define MMSG_MORE 0
 
 #ifndef SO_RXQ_OVFL
 #define SO_RXQ_OVFL 40
 #endif
 
 const int kEpollFlags = EPOLLIN | EPOLLOUT | EPOLLET;
 const int kNumPacketsPerReadCall = 5;  // Arbitrary
+static const char kSourceAddressTokenSecret[] = "secret";
 
 namespace net {
 namespace tools {
 
 QuicServer::QuicServer()
     : port_(0),
       packets_dropped_(0),
       overflow_supported_(false),
-      use_recvmmsg_(false) {
+      use_recvmmsg_(false),
+      crypto_config_(kSourceAddressTokenSecret) {
   epoll_server_.set_timeout_in_us(50 * 1000);
   // Initialize the in memory cache now.
   QuicInMemoryCache::GetInstance();
+
+  // Use hardcoded crypto parameters for now.
+  config_.SetDefaults();
+  CryptoHandshakeMessage extra_tags;
+  config_.ToHandshakeMessage(&extra_tags);
+  QuicEpollClock clock(&epoll_server_);
+
+  scoped_ptr<CryptoHandshakeMessage> scfg(
+      crypto_config_.AddDefaultConfig(QuicRandom::GetInstance(), &clock,
+                                      extra_tags));
+  // If we were using the same config in many servers then we would have to
+  // parse a QuicConfig from config_tags here.
+  if (!config_.SetFromHandshakeMessage(*scfg)) {
+    CHECK(false) << "Crypto config could not be parsed by QuicConfig.";
+  }
 }
 
 QuicServer::~QuicServer() {
 }
 
 bool QuicServer::Listen(const IPEndPoint& address) {
   port_ = address.port();
   int address_family = address.GetSockAddrFamily();
   fd_ = socket(address_family, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
   if (fd_ < 0) {
@@ skipping 52 matching lines @@
         !server_address.FromSockAddr(storage.addr, storage.addr_len)) {
       LOG(ERROR) << "Unable to get self address.  Error: " << strerror(errno);
       return false;
     }
     port_ = server_address.port();
     LOG(INFO) << "Kernel assigned port is " << port_;
   }
 
   epoll_server_.RegisterFD(fd_, this, kEpollFlags);
 
-  dispatcher_.reset(new QuicDispatcher(fd_, &epoll_server_));
+  dispatcher_.reset(new QuicDispatcher(config_, crypto_config_, fd_,
+                                       &epoll_server_));
 
   return true;
 }
 
 void QuicServer::WaitForEvents() {
   epoll_server_.WaitForEventsAndExecuteCallbacks();
 }
 
 void QuicServer::Shutdown() {
   // Before we shut down the epoll server, give all active sessions a chance to
@@ skipping 53 matching lines @@
   }
 
   IPEndPoint server_address(server_ip, port);
   dispatcher->ProcessPacket(server_address, client_address, guid, packet);
 
   return true;
 }
 
 }  // namespace tools
 }  // namespace net