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.
5 #include "net/tools/quic/quic_dispatcher.h"
9 #include "base/debug/stack_trace.h"
10 #include "base/logging.h"
11 #include "base/stl_util.h"
12 #include "net/quic/quic_blocked_writer_interface.h"
13 #include "net/quic/quic_flags.h"
14 #include "net/quic/quic_utils.h"
15 #include "net/tools/epoll_server/epoll_server.h"
16 #include "net/tools/quic/quic_default_packet_writer.h"
17 #include "net/tools/quic/quic_epoll_connection_helper.h"
18 #include "net/tools/quic/quic_per_connection_packet_writer.h"
19 #include "net/tools/quic/quic_socket_utils.h"
20 #include "net/tools/quic/quic_time_wait_list_manager.h"
26 using base::StringPiece;
29 class DeleteSessionsAlarm : public EpollAlarm {
31 explicit DeleteSessionsAlarm(QuicDispatcher* dispatcher)
32 : dispatcher_(dispatcher) {
35 int64 OnAlarm() override {
36 EpollAlarm::OnAlarm();
37 dispatcher_->DeleteSessions();
42 QuicDispatcher* dispatcher_;
45 class QuicDispatcher::QuicFramerVisitor : public QuicFramerVisitorInterface {
47 explicit QuicFramerVisitor(QuicDispatcher* dispatcher)
48 : dispatcher_(dispatcher),
51 // QuicFramerVisitorInterface implementation
52 void OnPacket() override {}
53 bool OnUnauthenticatedPublicHeader(
54 const QuicPacketPublicHeader& header) override {
55 connection_id_ = header.connection_id;
56 return dispatcher_->OnUnauthenticatedPublicHeader(header);
58 bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override {
59 dispatcher_->OnUnauthenticatedHeader(header);
62 void OnError(QuicFramer* framer) override {
63 DVLOG(1) << QuicUtils::ErrorToString(framer->error());
66 bool OnProtocolVersionMismatch(QuicVersion /*received_version*/) override {
67 if (dispatcher_->time_wait_list_manager()->IsConnectionIdInTimeWait(
69 // Keep processing after protocol mismatch - this will be dealt with by
70 // the TimeWaitListManager.
73 DLOG(DFATAL) << "Version mismatch, connection ID (" << connection_id_
74 << ") not in time wait list.";
79 // The following methods should never get called because we always return
80 // false from OnUnauthenticatedHeader(). As a result, we never process the
81 // payload of the packet.
82 void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {
85 void OnVersionNegotiationPacket(
86 const QuicVersionNegotiationPacket& /*packet*/) override {
89 void OnDecryptedPacket(EncryptionLevel level) override { DCHECK(false); }
90 bool OnPacketHeader(const QuicPacketHeader& /*header*/) override {
94 void OnRevivedPacket() override { DCHECK(false); }
95 void OnFecProtectedPayload(StringPiece /*payload*/) override {
98 bool OnStreamFrame(const QuicStreamFrame& /*frame*/) override {
102 bool OnAckFrame(const QuicAckFrame& /*frame*/) override {
106 bool OnCongestionFeedbackFrame(
107 const QuicCongestionFeedbackFrame& /*frame*/) override {
111 bool OnStopWaitingFrame(const QuicStopWaitingFrame& /*frame*/) override {
115 bool OnPingFrame(const QuicPingFrame& /*frame*/) override {
119 bool OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) override {
123 bool OnConnectionCloseFrame(
124 const QuicConnectionCloseFrame& /*frame*/) override {
128 bool OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) override {
132 bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/) override {
136 bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
140 void OnFecData(const QuicFecData& /*fec*/) override { DCHECK(false); }
141 void OnPacketComplete() override { DCHECK(false); }
144 QuicDispatcher* dispatcher_;
146 // Latched in OnUnauthenticatedPublicHeader for use later.
147 QuicConnectionId connection_id_;
150 QuicPacketWriter* QuicDispatcher::DefaultPacketWriterFactory::Create(
151 QuicPacketWriter* writer,
152 QuicConnection* connection) {
153 return new QuicPerConnectionPacketWriter(writer, connection);
156 QuicDispatcher::PacketWriterFactoryAdapter::PacketWriterFactoryAdapter(
157 QuicDispatcher* dispatcher)
158 : dispatcher_(dispatcher) {}
160 QuicDispatcher::PacketWriterFactoryAdapter::~PacketWriterFactoryAdapter() {}
162 QuicPacketWriter* QuicDispatcher::PacketWriterFactoryAdapter::Create(
163 QuicConnection* connection) const {
164 return dispatcher_->packet_writer_factory_->Create(
165 dispatcher_->writer_.get(),
169 QuicDispatcher::QuicDispatcher(const QuicConfig& config,
170 const QuicCryptoServerConfig& crypto_config,
171 const QuicVersionVector& supported_versions,
172 PacketWriterFactory* packet_writer_factory,
173 EpollServer* epoll_server)
175 crypto_config_(crypto_config),
176 delete_sessions_alarm_(new DeleteSessionsAlarm(this)),
177 epoll_server_(epoll_server),
178 helper_(new QuicEpollConnectionHelper(epoll_server_)),
179 packet_writer_factory_(packet_writer_factory),
180 connection_writer_factory_(this),
181 supported_versions_(supported_versions),
182 current_packet_(nullptr),
183 framer_(supported_versions, /*unused*/ QuicTime::Zero(), true),
184 framer_visitor_(new QuicFramerVisitor(this)) {
185 framer_.set_visitor(framer_visitor_.get());
188 QuicDispatcher::~QuicDispatcher() {
189 STLDeleteValues(&session_map_);
190 STLDeleteElements(&closed_session_list_);
193 void QuicDispatcher::Initialize(int fd) {
194 DCHECK(writer_ == nullptr);
195 writer_.reset(CreateWriter(fd));
196 time_wait_list_manager_.reset(CreateQuicTimeWaitListManager());
199 void QuicDispatcher::ProcessPacket(const IPEndPoint& server_address,
200 const IPEndPoint& client_address,
201 const QuicEncryptedPacket& packet) {
202 current_server_address_ = server_address;
203 current_client_address_ = client_address;
204 current_packet_ = &packet;
205 // ProcessPacket will cause the packet to be dispatched in
206 // OnUnauthenticatedPublicHeader, or sent to the time wait list manager
207 // in OnAuthenticatedHeader.
208 framer_.ProcessPacket(packet);
209 // TODO(rjshade): Return a status describing if/why a packet was dropped,
210 // and log somehow. Maybe expose as a varz.
213 bool QuicDispatcher::OnUnauthenticatedPublicHeader(
214 const QuicPacketPublicHeader& header) {
215 QuicSession* session = nullptr;
217 QuicConnectionId connection_id = header.connection_id;
218 SessionMap::iterator it = session_map_.find(connection_id);
219 if (it == session_map_.end()) {
220 if (header.reset_flag) {
223 if (time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id)) {
224 return HandlePacketForTimeWait(header);
227 // Ensure the packet has a version negotiation bit set before creating a new
228 // session for it. All initial packets for a new connection are required to
229 // have the flag set. Otherwise it may be a stray packet.
230 if (header.version_flag) {
231 session = CreateQuicSession(connection_id, current_server_address_,
232 current_client_address_);
235 if (session == nullptr) {
236 DVLOG(1) << "Failed to create session for " << connection_id;
237 // Add this connection_id fo the time-wait state, to safely reject future
240 if (header.version_flag &&
241 !framer_.IsSupportedVersion(header.versions.front())) {
242 // TODO(ianswett): Produce a no-version version negotiation packet.
246 // Use the version in the packet if possible, otherwise assume the latest.
247 QuicVersion version = header.version_flag ? header.versions.front() :
248 supported_versions_.front();
249 time_wait_list_manager_->AddConnectionIdToTimeWait(connection_id, version,
251 DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
252 return HandlePacketForTimeWait(header);
254 DVLOG(1) << "Created new session for " << connection_id;
255 session_map_.insert(make_pair(connection_id, session));
257 session = it->second;
260 session->connection()->ProcessUdpPacket(
261 current_server_address_, current_client_address_, *current_packet_);
263 // Do not parse the packet further. The session will process it completely.
267 void QuicDispatcher::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
268 DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(
269 header.public_header.connection_id));
270 time_wait_list_manager_->ProcessPacket(current_server_address_,
271 current_client_address_,
272 header.public_header.connection_id,
273 header.packet_sequence_number,
277 void QuicDispatcher::CleanUpSession(SessionMap::iterator it) {
278 QuicConnection* connection = it->second->connection();
279 QuicEncryptedPacket* connection_close_packet =
280 connection->ReleaseConnectionClosePacket();
281 write_blocked_list_.erase(connection);
282 time_wait_list_manager_->AddConnectionIdToTimeWait(it->first,
283 connection->version(),
284 connection_close_packet);
285 session_map_.erase(it);
288 void QuicDispatcher::DeleteSessions() {
289 STLDeleteElements(&closed_session_list_);
292 void QuicDispatcher::OnCanWrite() {
293 // We got an EPOLLOUT: the socket should not be blocked.
294 writer_->SetWritable();
296 // Give all the blocked writers one chance to write, until we're blocked again
297 // or there's no work left.
298 while (!write_blocked_list_.empty() && !writer_->IsWriteBlocked()) {
299 QuicBlockedWriterInterface* blocked_writer =
300 write_blocked_list_.begin()->first;
301 write_blocked_list_.erase(write_blocked_list_.begin());
302 blocked_writer->OnCanWrite();
306 bool QuicDispatcher::HasPendingWrites() const {
307 return !write_blocked_list_.empty();
310 void QuicDispatcher::Shutdown() {
311 while (!session_map_.empty()) {
312 QuicSession* session = session_map_.begin()->second;
313 session->connection()->SendConnectionClose(QUIC_PEER_GOING_AWAY);
314 // Validate that the session removes itself from the session map on close.
315 DCHECK(session_map_.empty() || session_map_.begin()->second != session);
320 void QuicDispatcher::OnConnectionClosed(QuicConnectionId connection_id,
321 QuicErrorCode error) {
322 SessionMap::iterator it = session_map_.find(connection_id);
323 if (it == session_map_.end()) {
324 LOG(DFATAL) << "ConnectionId " << connection_id
325 << " does not exist in the session map. "
326 << "Error: " << QuicUtils::ErrorToString(error);
327 LOG(DFATAL) << base::debug::StackTrace().ToString();
331 DLOG_IF(INFO, error != QUIC_NO_ERROR) << "Closing connection ("
333 << ") due to error: "
334 << QuicUtils::ErrorToString(error);
336 if (closed_session_list_.empty()) {
337 epoll_server_->RegisterAlarmApproximateDelta(
338 0, delete_sessions_alarm_.get());
340 closed_session_list_.push_back(it->second);
344 void QuicDispatcher::OnWriteBlocked(
345 QuicBlockedWriterInterface* blocked_writer) {
346 if (!writer_->IsWriteBlocked()) {
348 "QuicDispatcher::OnWriteBlocked called when the writer is not blocked.";
349 // Return without adding the connection to the blocked list, to avoid
350 // infinite loops in OnCanWrite.
353 write_blocked_list_.insert(make_pair(blocked_writer, true));
356 QuicPacketWriter* QuicDispatcher::CreateWriter(int fd) {
357 return new QuicDefaultPacketWriter(fd);
360 QuicSession* QuicDispatcher::CreateQuicSession(
361 QuicConnectionId connection_id,
362 const IPEndPoint& server_address,
363 const IPEndPoint& client_address) {
364 QuicServerSession* session = new QuicServerSession(
366 CreateQuicConnection(connection_id, server_address, client_address),
368 crypto_config_.HasProofSource());
369 session->InitializeSession(crypto_config_);
373 QuicConnection* QuicDispatcher::CreateQuicConnection(
374 QuicConnectionId connection_id,
375 const IPEndPoint& server_address,
376 const IPEndPoint& client_address) {
377 return new QuicConnection(connection_id,
380 connection_writer_factory_,
381 /* owns_writer= */ true,
382 /* is_server= */ true,
383 supported_versions_);
386 QuicTimeWaitListManager* QuicDispatcher::CreateQuicTimeWaitListManager() {
387 return new QuicTimeWaitListManager(
388 writer_.get(), this, epoll_server(), supported_versions());
391 bool QuicDispatcher::HandlePacketForTimeWait(
392 const QuicPacketPublicHeader& header) {
393 if (header.reset_flag) {
394 // Public reset packets do not have sequence numbers, so ignore the packet.
398 // Switch the framer to the correct version, so that the sequence number can
399 // be parsed correctly.
400 framer_.set_version(time_wait_list_manager_->GetQuicVersionFromConnectionId(
401 header.connection_id));
403 // Continue parsing the packet to extract the sequence number. Then
404 // send it to the time wait manager in OnUnathenticatedHeader.