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 19 namespace net { 20 21 namespace tools { 22 23 namespace test { 24 class QuicServerPeer; 25 } // namespace test 26 27 class ProcessPacketInterface; 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 OnRegistration(EpollServer * eps,int fd,int event_mask)48 virtual void OnRegistration(EpollServer* eps, 49 int fd, 50 int event_mask) OVERRIDE {} OnModification(int fd,int event_mask)51 virtual void OnModification(int fd, int event_mask) OVERRIDE {} 52 virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE; OnUnregistration(int fd,bool replaced)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 ProcessPacketInterface* processor, 63 uint32* packets_dropped); 64 OnShutdown(EpollServer * eps,int fd)65 virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE {} 66 SetStrikeRegisterNoStartupPeriod()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|. SetProofSource(ProofSource * source)73 void SetProofSource(ProofSource* source) { 74 crypto_config_.SetProofSource(source); 75 } 76 overflow_supported()77 bool overflow_supported() { return overflow_supported_; } 78 packets_dropped()79 uint32 packets_dropped() { return packets_dropped_; } 80 port()81 int port() { return port_; } 82 83 protected: 84 virtual QuicDispatcher* CreateQuicDispatcher(); 85 config()86 const QuicConfig& config() const { return config_; } crypto_config()87 const QuicCryptoServerConfig& crypto_config() const { 88 return crypto_config_; 89 } supported_versions()90 const QuicVersionVector& supported_versions() const { 91 return supported_versions_; 92 } epoll_server()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