Home | History | Annotate | Download | only in quic 
      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 toy server, which listens on a specified address for QUIC traffic and
      6 // handles incoming responses.
      7 
      8 #ifndef NET_TOOLS_QUIC_QUIC_SERVER_H_
      9 #define NET_TOOLS_QUIC_QUIC_SERVER_H_
     10 
     11 #include "base/basictypes.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "net/base/ip_endpoint.h"
     14 #include "net/quic/crypto/quic_crypto_server_config.h"
     15 #include "net/quic/quic_config.h"
     16 #include "net/quic/quic_framer.h"
     17 #include "net/tools/epoll_server/epoll_server.h"
     18 #include "net/tools/quic/quic_dispatcher.h"
     19 
     20 namespace net {
     21 
     22 namespace tools {
     23 
     24 namespace test {
     25 class QuicServerPeer;
     26 }  // namespace test
     27 
     28 class QuicDispatcher;
     29 
     30 class QuicServer : public EpollCallbackInterface {
     31  public:
     32   QuicServer();
     33   QuicServer(const QuicConfig& config,
     34              const QuicVersionVector& supported_versions);
     35 
     36   virtual ~QuicServer();
     37 
     38   // Start listening on the specified address.
     39   bool Listen(const IPEndPoint& address);
     40 
     41   // Wait up to 50ms, and handle any events which occur.
     42   void WaitForEvents();
     43 
     44   // Server deletion is imminent.  Start cleaning up the epoll server.
     45   void Shutdown();
     46 
     47   // From EpollCallbackInterface
     48   virtual void OnRegistration(EpollServer* eps,
     49                               int fd,
     50                               int event_mask) OVERRIDE {}
     51   virtual void OnModification(int fd, int event_mask) OVERRIDE {}
     52   virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE;
     53   virtual void OnUnregistration(int fd, bool replaced) OVERRIDE {}
     54 
     55   // Reads a packet from the given fd, and then passes it off to
     56   // the QuicDispatcher.  Returns true if a packet is read, false
     57   // otherwise.
     58   // If packets_dropped is non-null, the socket is configured to track
     59   // dropped packets, and some packets are read, it will be set to the number of
     60   // dropped packets.
     61   static bool ReadAndDispatchSinglePacket(int fd, int port,
     62                                           QuicDispatcher* dispatcher,
     63                                           uint32* packets_dropped);
     64 
     65   virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE {}
     66 
     67   void SetStrikeRegisterNoStartupPeriod() {
     68     crypto_config_.set_strike_register_no_startup_period();
     69   }
     70 
     71   // SetProofSource sets the ProofSource that will be used to verify the
     72   // server's certificate, and takes ownership of |source|.
     73   void SetProofSource(ProofSource* source) {
     74     crypto_config_.SetProofSource(source);
     75   }
     76 
     77   bool overflow_supported() { return overflow_supported_; }
     78 
     79   uint32 packets_dropped() { return packets_dropped_; }
     80 
     81   int port() { return port_; }
     82 
     83  protected:
     84   virtual QuicDispatcher* CreateQuicDispatcher();
     85 
     86   const QuicConfig& config() const { return config_; }
     87   const QuicCryptoServerConfig& crypto_config() const {
     88     return crypto_config_;
     89   }
     90   const QuicVersionVector& supported_versions() const {
     91     return supported_versions_;
     92   }
     93   EpollServer* epoll_server() { return &epoll_server_; }
     94 
     95  private:
     96   friend class net::tools::test::QuicServerPeer;
     97 
     98   // Initialize the internal state of the server.
     99   void Initialize();
    100 
    101   // Accepts data from the framer and demuxes clients to sessions.
    102   scoped_ptr<QuicDispatcher> dispatcher_;
    103   // Frames incoming packets and hands them to the dispatcher.
    104   EpollServer epoll_server_;
    105 
    106   // The port the server is listening on.
    107   int port_;
    108 
    109   // Listening connection.  Also used for outbound client communication.
    110   int fd_;
    111 
    112   // If overflow_supported_ is true this will be the number of packets dropped
    113   // during the lifetime of the server.  This may overflow if enough packets
    114   // are dropped.
    115   uint32 packets_dropped_;
    116 
    117   // True if the kernel supports SO_RXQ_OVFL, the number of packets dropped
    118   // because the socket would otherwise overflow.
    119   bool overflow_supported_;
    120 
    121   // If true, use recvmmsg for reading.
    122   bool use_recvmmsg_;
    123 
    124   // config_ contains non-crypto parameters that are negotiated in the crypto
    125   // handshake.
    126   QuicConfig config_;
    127   // crypto_config_ contains crypto parameters for the handshake.
    128   QuicCryptoServerConfig crypto_config_;
    129 
    130   // This vector contains QUIC versions which we currently support.
    131   // This should be ordered such that the highest supported version is the first
    132   // element, with subsequent elements in descending order (versions can be
    133   // skipped as necessary).
    134   QuicVersionVector supported_versions_;
    135 
    136   // Size of flow control receive window to advertise to clients on new
    137   // connections.
    138   uint32 server_initial_flow_control_receive_window_;
    139 
    140   DISALLOW_COPY_AND_ASSIGN(QuicServer);
    141 };
    142 
    143 }  // namespace tools
    144 }  // namespace net
    145 
    146 #endif  // NET_TOOLS_QUIC_QUIC_SERVER_H_
    147