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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
// Copyright 2014 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.
#include "net/quic/quic_server_session.h"
#include "base/logging.h"
#include "net/quic/crypto/source_address_token.h"
#include "net/quic/quic_connection.h"
#include "net/quic/quic_flags.h"
#include "net/quic/quic_spdy_server_stream.h"
#include "net/quic/reliable_quic_stream.h"
namespace net {
QuicServerSession::QuicServerSession(const QuicConfig& config,
QuicConnection* connection,
QuicServerSessionVisitor* visitor)
: QuicSession(connection, config),
visitor_(visitor),
bandwidth_estimate_sent_to_client_(QuicBandwidth::Zero()),
last_server_config_update_time_(QuicTime::Zero()) {}
QuicServerSession::~QuicServerSession() {}
void QuicServerSession::InitializeSession(
const QuicCryptoServerConfig& crypto_config) {
QuicSession::InitializeSession();
crypto_stream_.reset(CreateQuicCryptoServerStream(crypto_config));
}
QuicCryptoServerStream* QuicServerSession::CreateQuicCryptoServerStream(
const QuicCryptoServerConfig& crypto_config) {
return new QuicCryptoServerStream(crypto_config, this);
}
void QuicServerSession::OnConfigNegotiated() {
QuicSession::OnConfigNegotiated();
if (!FLAGS_enable_quic_fec ||
!config()->HasReceivedConnectionOptions() ||
!ContainsQuicTag(config()->ReceivedConnectionOptions(), kFHDR)) {
return;
}
// kFHDR config maps to FEC protection always for headers stream.
// TODO(jri): Add crypto stream in addition to headers for kHDR.
headers_stream_->set_fec_policy(FEC_PROTECT_ALWAYS);
}
void QuicServerSession::OnConnectionClosed(QuicErrorCode error,
bool from_peer) {
QuicSession::OnConnectionClosed(error, from_peer);
// In the unlikely event we get a connection close while doing an asynchronous
// crypto event, make sure we cancel the callback.
if (crypto_stream_.get() != nullptr) {
crypto_stream_->CancelOutstandingCallbacks();
}
visitor_->OnConnectionClosed(connection()->connection_id(), error);
}
void QuicServerSession::OnWriteBlocked() {
QuicSession::OnWriteBlocked();
visitor_->OnWriteBlocked(connection());
}
void QuicServerSession::OnCongestionWindowChange(QuicTime now) {
if (connection()->version() <= QUIC_VERSION_21) {
return;
}
// If not enough time has passed since the last time we sent an update to the
// client, then return early.
const QuicSentPacketManager& sent_packet_manager =
connection()->sent_packet_manager();
int64 srtt_ms =
sent_packet_manager.GetRttStats()->SmoothedRtt().ToMilliseconds();
int64 now_ms = now.Subtract(last_server_config_update_time_).ToMilliseconds();
if (now_ms < (kMinIntervalBetweenServerConfigUpdatesRTTs * srtt_ms) ||
now_ms < kMinIntervalBetweenServerConfigUpdatesMs) {
return;
}
// If the bandwidth recorder does not have a valid estimate, return early.
const QuicSustainedBandwidthRecorder& bandwidth_recorder =
sent_packet_manager.SustainedBandwidthRecorder();
if (!bandwidth_recorder.HasEstimate()) {
return;
}
// The bandwidth recorder has recorded at least one sustained bandwidth
// estimate. Check that it's substantially different from the last one that
// we sent to the client, and if so, send the new one.
QuicBandwidth new_bandwidth_estimate = bandwidth_recorder.BandwidthEstimate();
int64 bandwidth_delta =
std::abs(new_bandwidth_estimate.ToBitsPerSecond() -
bandwidth_estimate_sent_to_client_.ToBitsPerSecond());
// Define "substantial" difference as a 50% increase or decrease from the
// last estimate.
bool substantial_difference =
bandwidth_delta >
0.5 * bandwidth_estimate_sent_to_client_.ToBitsPerSecond();
if (!substantial_difference) {
return;
}
bandwidth_estimate_sent_to_client_ = new_bandwidth_estimate;
DVLOG(1) << "Server: sending new bandwidth estimate (KBytes/s): "
<< bandwidth_estimate_sent_to_client_.ToKBytesPerSecond();
// Include max bandwidth in the update.
QuicBandwidth max_bandwidth_estimate =
bandwidth_recorder.MaxBandwidthEstimate();
int32 max_bandwidth_timestamp = bandwidth_recorder.MaxBandwidthTimestamp();
// Fill the proto before passing it to the crypto stream to send.
CachedNetworkParameters cached_network_params;
cached_network_params.set_bandwidth_estimate_bytes_per_second(
bandwidth_estimate_sent_to_client_.ToBytesPerSecond());
cached_network_params.set_max_bandwidth_estimate_bytes_per_second(
max_bandwidth_estimate.ToBytesPerSecond());
cached_network_params.set_max_bandwidth_timestamp_seconds(
max_bandwidth_timestamp);
cached_network_params.set_min_rtt_ms(
sent_packet_manager.GetRttStats()->MinRtt().ToMilliseconds());
cached_network_params.set_previous_connection_state(
bandwidth_recorder.EstimateRecordedDuringSlowStart()
? CachedNetworkParameters::SLOW_START
: CachedNetworkParameters::CONGESTION_AVOIDANCE);
cached_network_params.set_timestamp(
connection()->clock()->WallNow().ToUNIXSeconds());
if (!serving_region_.empty()) {
cached_network_params.set_serving_region(serving_region_);
}
crypto_stream_->SendServerConfigUpdate(&cached_network_params);
last_server_config_update_time_ = now;
}
bool QuicServerSession::ShouldCreateIncomingDataStream(QuicStreamId id) {
if (id % 2 == 0) {
DVLOG(1) << "Invalid incoming even stream_id:" << id;
connection()->SendConnectionClose(QUIC_INVALID_STREAM_ID);
return false;
}
if (GetNumOpenStreams() >= get_max_open_streams()) {
DVLOG(1) << "Failed to create a new incoming stream with id:" << id
<< " Already " << GetNumOpenStreams() << " streams open (max "
<< get_max_open_streams() << ").";
connection()->SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS);
return false;
}
return true;
}
QuicDataStream* QuicServerSession::CreateIncomingDataStream(
QuicStreamId id) {
if (!ShouldCreateIncomingDataStream(id)) {
return nullptr;
}
return new QuicSpdyServerStream(id, this);
}
QuicDataStream* QuicServerSession::CreateOutgoingDataStream() {
DLOG(ERROR) << "Server push not yet supported";
return nullptr;
}
QuicCryptoServerStream* QuicServerSession::GetCryptoStream() {
return crypto_stream_.get();
}
} // namespace net
|
