1 // Copyright (c) 2019 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 #include "quiche/quic/qbone/qbone_server_session.h"
6
7 #include <string>
8 #include <utility>
9
10 #include "absl/strings/string_view.h"
11 #include "quiche/quic/core/quic_connection_id.h"
12 #include "quiche/quic/core/quic_types.h"
13 #include "quiche/quic/core/quic_utils.h"
14 #include "quiche/quic/qbone/qbone_constants.h"
15 #include "quiche/common/platform/api/quiche_command_line_flags.h"
16
17 namespace quic {
18
CanAcceptClientHello(const CryptoHandshakeMessage & chlo,const QuicSocketAddress & client_address,const QuicSocketAddress & peer_address,const QuicSocketAddress & self_address,std::string * error_details) const19 bool QboneCryptoServerStreamHelper::CanAcceptClientHello(
20 const CryptoHandshakeMessage& chlo, const QuicSocketAddress& client_address,
21 const QuicSocketAddress& peer_address,
22 const QuicSocketAddress& self_address, std::string* error_details) const {
23 absl::string_view alpn;
24 chlo.GetStringPiece(quic::kALPN, &alpn);
25 if (alpn != QboneConstants::kQboneAlpn) {
26 *error_details = "ALPN-indicated protocol is not qbone";
27 return false;
28 }
29 return true;
30 }
31
QboneServerSession(const quic::ParsedQuicVersionVector & supported_versions,QuicConnection * connection,Visitor * owner,const QuicConfig & config,const QuicCryptoServerConfig * quic_crypto_server_config,QuicCompressedCertsCache * compressed_certs_cache,QbonePacketWriter * writer,QuicIpAddress self_ip,QuicIpAddress client_ip,size_t client_ip_subnet_length,QboneServerControlStream::Handler * handler)32 QboneServerSession::QboneServerSession(
33 const quic::ParsedQuicVersionVector& supported_versions,
34 QuicConnection* connection, Visitor* owner, const QuicConfig& config,
35 const QuicCryptoServerConfig* quic_crypto_server_config,
36 QuicCompressedCertsCache* compressed_certs_cache, QbonePacketWriter* writer,
37 QuicIpAddress self_ip, QuicIpAddress client_ip,
38 size_t client_ip_subnet_length, QboneServerControlStream::Handler* handler)
39 : QboneSessionBase(connection, owner, config, supported_versions, writer),
40 processor_(self_ip, client_ip, client_ip_subnet_length, this, this),
41 quic_crypto_server_config_(quic_crypto_server_config),
42 compressed_certs_cache_(compressed_certs_cache),
43 handler_(handler) {}
44
~QboneServerSession()45 QboneServerSession::~QboneServerSession() {}
46
CreateCryptoStream()47 std::unique_ptr<QuicCryptoStream> QboneServerSession::CreateCryptoStream() {
48 return CreateCryptoServerStream(quic_crypto_server_config_,
49 compressed_certs_cache_, this,
50 &stream_helper_);
51 }
52
CreateControlStream()53 void QboneServerSession::CreateControlStream() {
54 if (control_stream_ != nullptr) {
55 return;
56 }
57 // Register the reserved control stream.
58 auto control_stream =
59 std::make_unique<QboneServerControlStream>(this, handler_);
60 control_stream_ = control_stream.get();
61 ActivateStream(std::move(control_stream));
62 }
63
CreateControlStreamFromPendingStream(PendingStream * pending)64 QuicStream* QboneServerSession::CreateControlStreamFromPendingStream(
65 PendingStream* pending) {
66 QUICHE_DCHECK(control_stream_ == nullptr);
67 // Register the reserved control stream.
68 auto control_stream =
69 std::make_unique<QboneServerControlStream>(pending, this, handler_);
70 control_stream_ = control_stream.get();
71 ActivateStream(std::move(control_stream));
72 return control_stream_;
73 }
74
SetDefaultEncryptionLevel(quic::EncryptionLevel level)75 void QboneServerSession::SetDefaultEncryptionLevel(
76 quic::EncryptionLevel level) {
77 QboneSessionBase::SetDefaultEncryptionLevel(level);
78 if (level == quic::ENCRYPTION_FORWARD_SECURE) {
79 CreateControlStream();
80 }
81 }
82
SendClientRequest(const QboneClientRequest & request)83 bool QboneServerSession::SendClientRequest(const QboneClientRequest& request) {
84 if (!control_stream_) {
85 QUIC_BUG(quic_bug_11026_1)
86 << "Cannot send client request before control stream is created.";
87 return false;
88 }
89 return control_stream_->SendRequest(request);
90 }
91
ProcessPacketFromNetwork(absl::string_view packet)92 void QboneServerSession::ProcessPacketFromNetwork(absl::string_view packet) {
93 std::string buffer = std::string(packet);
94 processor_.ProcessPacket(&buffer,
95 QbonePacketProcessor::Direction::FROM_NETWORK);
96 }
97
ProcessPacketFromPeer(absl::string_view packet)98 void QboneServerSession::ProcessPacketFromPeer(absl::string_view packet) {
99 std::string buffer = std::string(packet);
100 processor_.ProcessPacket(&buffer,
101 QbonePacketProcessor::Direction::FROM_OFF_NETWORK);
102 }
103
SendPacketToClient(absl::string_view packet)104 void QboneServerSession::SendPacketToClient(absl::string_view packet) {
105 SendPacketToPeer(packet);
106 }
107
SendPacketToNetwork(absl::string_view packet)108 void QboneServerSession::SendPacketToNetwork(absl::string_view packet) {
109 QUICHE_DCHECK(writer_ != nullptr);
110 writer_->WritePacketToNetwork(packet.data(), packet.size());
111 }
112
113 } // namespace quic
114