net/tools/quic/quic_server.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/quic_server.h"
   6
   7 #include <errno.h>
   8 #include <features.h>
   9 #include <netinet/in.h>
  10 #include <string.h>
  11 #include <sys/epoll.h>
  12 #include <sys/socket.h>
  13
  14 #include "net/base/ip_endpoint.h"
  15 #include "net/quic/congestion_control/tcp_receiver.h"
  16 #include "net/quic/crypto/crypto_handshake.h"
  17 #include "net/quic/crypto/quic_random.h"
  18 #include "net/quic/quic_clock.h"
  19 #include "net/quic/quic_crypto_stream.h"
  20 #include "net/quic/quic_data_reader.h"
  21 #include "net/quic/quic_protocol.h"
  22 #include "net/tools/quic/quic_dispatcher.h"
  23 #include "net/tools/quic/quic_in_memory_cache.h"
  24 #include "net/tools/quic/quic_socket_utils.h"
  25
  26 #define MMSG_MORE 0
  27
  28 #ifndef SO_RXQ_OVFL
  29 #define SO_RXQ_OVFL 40
  30 #endif
  31
  32 namespace net {
  33 namespace tools {
  34
  35 namespace {
  36
  37 const int kEpollFlags = EPOLLIN | EPOLLOUT | EPOLLET;
  38 const char kSourceAddressTokenSecret[] = "secret";
  39 const uint32 kServerInitialFlowControlWindow = 100 * net::kMaxPacketSize;
  40
  41 }  // namespace
  42
  43 QuicServer::QuicServer()
  44     : port_(0),
  45       fd_(-1),
  46       packets_dropped_(0),
  47       overflow_supported_(false),
  48       use_recvmmsg_(false),
  49       crypto_config_(kSourceAddressTokenSecret, QuicRandom::GetInstance()),
  50       supported_versions_(QuicSupportedVersions()) {
  51   // Use hardcoded crypto parameters for now.
  52   config_.SetDefaults();
  53   Initialize();
  54 }
  55
  56 QuicServer::QuicServer(const QuicConfig& config,
  57                        const QuicVersionVector& supported_versions)
  58     : port_(0),
  59       fd_(-1),
  60       packets_dropped_(0),
  61       overflow_supported_(false),
  62       use_recvmmsg_(false),
  63       config_(config),
  64       crypto_config_(kSourceAddressTokenSecret, QuicRandom::GetInstance()),
  65       supported_versions_(supported_versions) {
  66   Initialize();
  67 }
  68
  69 void QuicServer::Initialize() {
  70 #if MMSG_MORE
  71   use_recvmmsg_ = true;
  72 #endif
  73   epoll_server_.set_timeout_in_us(50 * 1000);
  74   // Initialize the in memory cache now.
  75   QuicInMemoryCache::GetInstance();
  76
  77   QuicEpollClock clock(&epoll_server_);
  78
  79   scoped_ptr<CryptoHandshakeMessage> scfg(
  80       crypto_config_.AddDefaultConfig(
  81           QuicRandom::GetInstance(), &clock,
  82           QuicCryptoServerConfig::ConfigOptions()));
  83
  84   // Set flow control options in the config.
  85   config_.SetInitialCongestionWindowToSend(kServerInitialFlowControlWindow);
  86 }
  87
  88 QuicServer::~QuicServer() {
  89 }
  90
  91 bool QuicServer::Listen(const IPEndPoint& address) {
  92   port_ = address.port();
  93   int address_family = address.GetSockAddrFamily();
  94   fd_ = socket(address_family, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
  95   if (fd_ < 0) {
  96     LOG(ERROR) << "CreateSocket() failed: " << strerror(errno);
  97     return false;
  98   }
  99
 100   // Enable the socket option that allows the local address to be
 101   // returned if the socket is bound to more than one address.
 102   int rc = QuicSocketUtils::SetGetAddressInfo(fd_, address_family);
 103
 104   if (rc < 0) {
 105     LOG(ERROR) << "IP detection not supported" << strerror(errno);
 106     return false;
 107   }
 108
 109   int get_overflow = 1;
 110   rc = setsockopt(
 111       fd_, SOL_SOCKET, SO_RXQ_OVFL, &get_overflow, sizeof(get_overflow));
 112
 113   if (rc < 0) {
 114     DLOG(WARNING) << "Socket overflow detection not supported";
 115   } else {
 116     overflow_supported_ = true;
 117   }
 118
 119   // These send and receive buffer sizes are sized for a single connection,
 120   // because the default usage of QuicServer is as a test server with one or
 121   // two clients.  Adjust higher for use with many clients.
 122   if (!QuicSocketUtils::SetReceiveBufferSize(fd_,
 123                                              TcpReceiver::kReceiveWindowTCP)) {
 124     return false;
 125   }
 126
 127   if (!QuicSocketUtils::SetSendBufferSize(fd_,
 128                                           TcpReceiver::kReceiveWindowTCP)) {
 129     return false;
 130   }
 131
 132   sockaddr_storage raw_addr;
 133   socklen_t raw_addr_len = sizeof(raw_addr);
 134   CHECK(address.ToSockAddr(reinterpret_cast<sockaddr*>(&raw_addr),
 135                            &raw_addr_len));
 136   rc = bind(fd_,
 137             reinterpret_cast<const sockaddr*>(&raw_addr),
 138             sizeof(raw_addr));
 139   if (rc < 0) {
 140     LOG(ERROR) << "Bind failed: " << strerror(errno);
 141     return false;
 142   }
 143
 144   DVLOG(1) << "Listening on " << address.ToString();
 145   if (port_ == 0) {
 146     SockaddrStorage storage;
 147     IPEndPoint server_address;
 148     if (getsockname(fd_, storage.addr, &storage.addr_len) != 0 ||
 149         !server_address.FromSockAddr(storage.addr, storage.addr_len)) {
 150       LOG(ERROR) << "Unable to get self address.  Error: " << strerror(errno);
 151       return false;
 152     }
 153     port_ = server_address.port();
 154     DVLOG(1) << "Kernel assigned port is " << port_;
 155   }
 156
 157   epoll_server_.RegisterFD(fd_, this, kEpollFlags);
 158   dispatcher_.reset(CreateQuicDispatcher());
 159   dispatcher_->Initialize(fd_);
 160
 161   return true;
 162 }
 163
 164 QuicDispatcher* QuicServer::CreateQuicDispatcher() {
 165   return new QuicDispatcher(
 166       config_,
 167       crypto_config_,
 168       supported_versions_,
 169       new QuicDispatcher::DefaultPacketWriterFactory(),
 170       &epoll_server_);
 171 }
 172
 173 void QuicServer::WaitForEvents() {
 174   epoll_server_.WaitForEventsAndExecuteCallbacks();
 175 }
 176
 177 void QuicServer::Shutdown() {
 178   // Before we shut down the epoll server, give all active sessions a chance to
 179   // notify clients that they're closing.
 180   dispatcher_->Shutdown();
 181
 182   close(fd_);
 183   fd_ = -1;
 184 }
 185
 186 void QuicServer::OnEvent(int fd, EpollEvent* event) {
 187   DCHECK_EQ(fd, fd_);
 188   event->out_ready_mask = 0;
 189
 190   if (event->in_events & EPOLLIN) {
 191     DVLOG(1) << "EPOLLIN";
 192     bool read = true;
 193     while (read) {
 194         read = ReadAndDispatchSinglePacket(
 195             fd_, port_, dispatcher_.get(),
 196             overflow_supported_ ? &packets_dropped_ : NULL);
 197     }
 198   }
 199   if (event->in_events & EPOLLOUT) {
 200     dispatcher_->OnCanWrite();
 201     if (dispatcher_->HasPendingWrites()) {
 202       event->out_ready_mask |= EPOLLOUT;
 203     }
 204   }
 205   if (event->in_events & EPOLLERR) {
 206   }
 207 }
 208
 209 /* static */
 210 bool QuicServer::ReadAndDispatchSinglePacket(int fd,
 211                                              int port,
 212                                              ProcessPacketInterface* processor,
 213                                              uint32* packets_dropped) {
 214   // Allocate some extra space so we can send an error if the client goes over
 215   // the limit.
 216   char buf[2 * kMaxPacketSize];
 217
 218   IPEndPoint client_address;
 219   IPAddressNumber server_ip;
 220   int bytes_read =
 221       QuicSocketUtils::ReadPacket(fd, buf, arraysize(buf),
 222                                   packets_dropped,
 223                                   &server_ip, &client_address);
 224
 225   if (bytes_read < 0) {
 226     return false;  // We failed to read.
 227   }
 228
 229   QuicEncryptedPacket packet(buf, bytes_read, false);
 230
 231   IPEndPoint server_address(server_ip, port);
 232   processor->ProcessPacket(server_address, client_address, packet);
 233
 234   return true;
 235 }
 236
 237 }  // namespace tools
 238 }  // namespace net