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