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
|
// 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/memory/scoped_ptr.h"
#include "net/base/ip_endpoint.h"
#include "net/quic/crypto/crypto_server_config.h"
#include "net/quic/quic_config.h"
#include "net/quic/quic_framer.h"
#include "net/tools/flip_server/epoll_server.h"
#include "net/tools/quic/quic_dispatcher.h"
namespace net {
class QuicCryptoServerConfig;
namespace tools {
class QuicDispatcher;
class QuicServer : public EpollCallbackInterface {
public:
QuicServer();
explicit QuicServer(const QuicConfig& config);
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,
int* packets_dropped);
virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE {}
bool overflow_supported() { return overflow_supported_; }
int packets_dropped() { return packets_dropped_; }
int port() { return port_; }
private:
// 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.
int 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_;
DISALLOW_COPY_AND_ASSIGN(QuicServer);
};
} // namespace tools
} // namespace net
#endif // NET_TOOLS_QUIC_QUIC_SERVER_H_
|
