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.
4
5 #include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h"
6
7 #include <memory>
8 #include <utility>
9
10 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
11 #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
12 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
13 #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
14
15 namespace quic {
16 namespace test {
17
18 class SimpleFramerVisitor : public QuicFramerVisitorInterface {
19 public:
SimpleFramerVisitor()20 SimpleFramerVisitor() : error_(QUIC_NO_ERROR) {}
21 SimpleFramerVisitor(const SimpleFramerVisitor&) = delete;
22 SimpleFramerVisitor& operator=(const SimpleFramerVisitor&) = delete;
23
~SimpleFramerVisitor()24 ~SimpleFramerVisitor() override {}
25
OnError(QuicFramer * framer)26 void OnError(QuicFramer* framer) override { error_ = framer->error(); }
27
OnProtocolVersionMismatch(ParsedQuicVersion)28 bool OnProtocolVersionMismatch(ParsedQuicVersion /*version*/) override {
29 return false;
30 }
31
OnPacket()32 void OnPacket() override {}
OnPublicResetPacket(const QuicPublicResetPacket & packet)33 void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
34 public_reset_packet_ = std::make_unique<QuicPublicResetPacket>((packet));
35 }
OnVersionNegotiationPacket(const QuicVersionNegotiationPacket & packet)36 void OnVersionNegotiationPacket(
37 const QuicVersionNegotiationPacket& packet) override {
38 version_negotiation_packet_ =
39 std::make_unique<QuicVersionNegotiationPacket>((packet));
40 }
41
OnRetryPacket(QuicConnectionId,QuicConnectionId,quiche::QuicheStringPiece,quiche::QuicheStringPiece,quiche::QuicheStringPiece)42 void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
43 QuicConnectionId /*new_connection_id*/,
44 quiche::QuicheStringPiece /*retry_token*/,
45 quiche::QuicheStringPiece /*retry_integrity_tag*/,
46 quiche::QuicheStringPiece /*retry_without_tag*/) override {
47 }
48
OnUnauthenticatedPublicHeader(const QuicPacketHeader &)49 bool OnUnauthenticatedPublicHeader(
50 const QuicPacketHeader& /*header*/) override {
51 return true;
52 }
OnUnauthenticatedHeader(const QuicPacketHeader &)53 bool OnUnauthenticatedHeader(const QuicPacketHeader& /*header*/) override {
54 return true;
55 }
OnDecryptedPacket(EncryptionLevel level)56 void OnDecryptedPacket(EncryptionLevel level) override {
57 last_decrypted_level_ = level;
58 }
OnPacketHeader(const QuicPacketHeader & header)59 bool OnPacketHeader(const QuicPacketHeader& header) override {
60 has_header_ = true;
61 header_ = header;
62 return true;
63 }
64
OnCoalescedPacket(const QuicEncryptedPacket & packet)65 void OnCoalescedPacket(const QuicEncryptedPacket& packet) override {
66 coalesced_packet_ = packet.Clone();
67 }
68
OnUndecryptablePacket(const QuicEncryptedPacket &,EncryptionLevel,bool)69 void OnUndecryptablePacket(const QuicEncryptedPacket& /*packet*/,
70 EncryptionLevel /*decryption_level*/,
71 bool /*has_decryption_key*/) override {}
72
OnStreamFrame(const QuicStreamFrame & frame)73 bool OnStreamFrame(const QuicStreamFrame& frame) override {
74 // Save a copy of the data so it is valid after the packet is processed.
75 std::string* string_data =
76 new std::string(frame.data_buffer, frame.data_length);
77 stream_data_.push_back(QuicWrapUnique(string_data));
78 // TODO(ianswett): A pointer isn't necessary with emplace_back.
79 stream_frames_.push_back(std::make_unique<QuicStreamFrame>(
80 frame.stream_id, frame.fin, frame.offset,
81 quiche::QuicheStringPiece(*string_data)));
82 return true;
83 }
84
OnCryptoFrame(const QuicCryptoFrame & frame)85 bool OnCryptoFrame(const QuicCryptoFrame& frame) override {
86 // Save a copy of the data so it is valid after the packet is processed.
87 std::string* string_data =
88 new std::string(frame.data_buffer, frame.data_length);
89 crypto_data_.push_back(QuicWrapUnique(string_data));
90 crypto_frames_.push_back(std::make_unique<QuicCryptoFrame>(
91 frame.level, frame.offset, quiche::QuicheStringPiece(*string_data)));
92 return true;
93 }
94
OnAckFrameStart(QuicPacketNumber largest_acked,QuicTime::Delta ack_delay_time)95 bool OnAckFrameStart(QuicPacketNumber largest_acked,
96 QuicTime::Delta ack_delay_time) override {
97 QuicAckFrame ack_frame;
98 ack_frame.largest_acked = largest_acked;
99 ack_frame.ack_delay_time = ack_delay_time;
100 ack_frames_.push_back(ack_frame);
101 return true;
102 }
103
OnAckRange(QuicPacketNumber start,QuicPacketNumber end)104 bool OnAckRange(QuicPacketNumber start, QuicPacketNumber end) override {
105 DCHECK(!ack_frames_.empty());
106 ack_frames_[ack_frames_.size() - 1].packets.AddRange(start, end);
107 return true;
108 }
109
OnAckTimestamp(QuicPacketNumber,QuicTime)110 bool OnAckTimestamp(QuicPacketNumber /*packet_number*/,
111 QuicTime /*timestamp*/) override {
112 return true;
113 }
114
OnAckFrameEnd(QuicPacketNumber)115 bool OnAckFrameEnd(QuicPacketNumber /*start*/) override { return true; }
116
OnStopWaitingFrame(const QuicStopWaitingFrame & frame)117 bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
118 stop_waiting_frames_.push_back(frame);
119 return true;
120 }
121
OnPaddingFrame(const QuicPaddingFrame & frame)122 bool OnPaddingFrame(const QuicPaddingFrame& frame) override {
123 padding_frames_.push_back(frame);
124 return true;
125 }
126
OnPingFrame(const QuicPingFrame & frame)127 bool OnPingFrame(const QuicPingFrame& frame) override {
128 ping_frames_.push_back(frame);
129 return true;
130 }
131
OnRstStreamFrame(const QuicRstStreamFrame & frame)132 bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
133 rst_stream_frames_.push_back(frame);
134 return true;
135 }
136
OnConnectionCloseFrame(const QuicConnectionCloseFrame & frame)137 bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override {
138 connection_close_frames_.push_back(frame);
139 return true;
140 }
141
OnNewConnectionIdFrame(const QuicNewConnectionIdFrame & frame)142 bool OnNewConnectionIdFrame(const QuicNewConnectionIdFrame& frame) override {
143 new_connection_id_frames_.push_back(frame);
144 return true;
145 }
146
OnRetireConnectionIdFrame(const QuicRetireConnectionIdFrame & frame)147 bool OnRetireConnectionIdFrame(
148 const QuicRetireConnectionIdFrame& frame) override {
149 retire_connection_id_frames_.push_back(frame);
150 return true;
151 }
152
OnNewTokenFrame(const QuicNewTokenFrame & frame)153 bool OnNewTokenFrame(const QuicNewTokenFrame& frame) override {
154 new_token_frames_.push_back(frame);
155 return true;
156 }
157
OnStopSendingFrame(const QuicStopSendingFrame & frame)158 bool OnStopSendingFrame(const QuicStopSendingFrame& frame) override {
159 stop_sending_frames_.push_back(frame);
160 return true;
161 }
162
OnPathChallengeFrame(const QuicPathChallengeFrame & frame)163 bool OnPathChallengeFrame(const QuicPathChallengeFrame& frame) override {
164 path_challenge_frames_.push_back(frame);
165 return true;
166 }
167
OnPathResponseFrame(const QuicPathResponseFrame & frame)168 bool OnPathResponseFrame(const QuicPathResponseFrame& frame) override {
169 path_response_frames_.push_back(frame);
170 return true;
171 }
172
OnGoAwayFrame(const QuicGoAwayFrame & frame)173 bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override {
174 goaway_frames_.push_back(frame);
175 return true;
176 }
OnMaxStreamsFrame(const QuicMaxStreamsFrame & frame)177 bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) override {
178 max_streams_frames_.push_back(frame);
179 return true;
180 }
181
OnStreamsBlockedFrame(const QuicStreamsBlockedFrame & frame)182 bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) override {
183 streams_blocked_frames_.push_back(frame);
184 return true;
185 }
186
OnWindowUpdateFrame(const QuicWindowUpdateFrame & frame)187 bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override {
188 window_update_frames_.push_back(frame);
189 return true;
190 }
191
OnBlockedFrame(const QuicBlockedFrame & frame)192 bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
193 blocked_frames_.push_back(frame);
194 return true;
195 }
196
OnMessageFrame(const QuicMessageFrame & frame)197 bool OnMessageFrame(const QuicMessageFrame& frame) override {
198 message_frames_.emplace_back(frame.data, frame.message_length);
199 return true;
200 }
201
OnHandshakeDoneFrame(const QuicHandshakeDoneFrame & frame)202 bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override {
203 handshake_done_frames_.push_back(frame);
204 return true;
205 }
206
OnPacketComplete()207 void OnPacketComplete() override {}
208
IsValidStatelessResetToken(QuicUint128) const209 bool IsValidStatelessResetToken(QuicUint128 /*token*/) const override {
210 return false;
211 }
212
OnAuthenticatedIetfStatelessResetPacket(const QuicIetfStatelessResetPacket & packet)213 void OnAuthenticatedIetfStatelessResetPacket(
214 const QuicIetfStatelessResetPacket& packet) override {
215 stateless_reset_packet_ =
216 std::make_unique<QuicIetfStatelessResetPacket>(packet);
217 }
218
header() const219 const QuicPacketHeader& header() const { return header_; }
ack_frames() const220 const std::vector<QuicAckFrame>& ack_frames() const { return ack_frames_; }
connection_close_frames() const221 const std::vector<QuicConnectionCloseFrame>& connection_close_frames() const {
222 return connection_close_frames_;
223 }
224
goaway_frames() const225 const std::vector<QuicGoAwayFrame>& goaway_frames() const {
226 return goaway_frames_;
227 }
max_streams_frames() const228 const std::vector<QuicMaxStreamsFrame>& max_streams_frames() const {
229 return max_streams_frames_;
230 }
streams_blocked_frames() const231 const std::vector<QuicStreamsBlockedFrame>& streams_blocked_frames() const {
232 return streams_blocked_frames_;
233 }
rst_stream_frames() const234 const std::vector<QuicRstStreamFrame>& rst_stream_frames() const {
235 return rst_stream_frames_;
236 }
stream_frames() const237 const std::vector<std::unique_ptr<QuicStreamFrame>>& stream_frames() const {
238 return stream_frames_;
239 }
crypto_frames() const240 const std::vector<std::unique_ptr<QuicCryptoFrame>>& crypto_frames() const {
241 return crypto_frames_;
242 }
stop_waiting_frames() const243 const std::vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
244 return stop_waiting_frames_;
245 }
ping_frames() const246 const std::vector<QuicPingFrame>& ping_frames() const { return ping_frames_; }
message_frames() const247 const std::vector<QuicMessageFrame>& message_frames() const {
248 return message_frames_;
249 }
window_update_frames() const250 const std::vector<QuicWindowUpdateFrame>& window_update_frames() const {
251 return window_update_frames_;
252 }
padding_frames() const253 const std::vector<QuicPaddingFrame>& padding_frames() const {
254 return padding_frames_;
255 }
path_challenge_frames() const256 const std::vector<QuicPathChallengeFrame>& path_challenge_frames() const {
257 return path_challenge_frames_;
258 }
path_response_frames() const259 const std::vector<QuicPathResponseFrame>& path_response_frames() const {
260 return path_response_frames_;
261 }
version_negotiation_packet() const262 const QuicVersionNegotiationPacket* version_negotiation_packet() const {
263 return version_negotiation_packet_.get();
264 }
last_decrypted_level() const265 EncryptionLevel last_decrypted_level() const { return last_decrypted_level_; }
coalesced_packet() const266 const QuicEncryptedPacket* coalesced_packet() const {
267 return coalesced_packet_.get();
268 }
269
270 private:
271 QuicErrorCode error_;
272 bool has_header_;
273 QuicPacketHeader header_;
274 std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
275 std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
276 std::unique_ptr<QuicIetfStatelessResetPacket> stateless_reset_packet_;
277 std::vector<QuicAckFrame> ack_frames_;
278 std::vector<QuicStopWaitingFrame> stop_waiting_frames_;
279 std::vector<QuicPaddingFrame> padding_frames_;
280 std::vector<QuicPingFrame> ping_frames_;
281 std::vector<std::unique_ptr<QuicStreamFrame>> stream_frames_;
282 std::vector<std::unique_ptr<QuicCryptoFrame>> crypto_frames_;
283 std::vector<QuicRstStreamFrame> rst_stream_frames_;
284 std::vector<QuicGoAwayFrame> goaway_frames_;
285 std::vector<QuicStreamsBlockedFrame> streams_blocked_frames_;
286 std::vector<QuicMaxStreamsFrame> max_streams_frames_;
287 std::vector<QuicConnectionCloseFrame> connection_close_frames_;
288 std::vector<QuicStopSendingFrame> stop_sending_frames_;
289 std::vector<QuicPathChallengeFrame> path_challenge_frames_;
290 std::vector<QuicPathResponseFrame> path_response_frames_;
291 std::vector<QuicWindowUpdateFrame> window_update_frames_;
292 std::vector<QuicBlockedFrame> blocked_frames_;
293 std::vector<QuicNewConnectionIdFrame> new_connection_id_frames_;
294 std::vector<QuicRetireConnectionIdFrame> retire_connection_id_frames_;
295 std::vector<QuicNewTokenFrame> new_token_frames_;
296 std::vector<QuicMessageFrame> message_frames_;
297 std::vector<QuicHandshakeDoneFrame> handshake_done_frames_;
298 std::vector<std::unique_ptr<std::string>> stream_data_;
299 std::vector<std::unique_ptr<std::string>> crypto_data_;
300 EncryptionLevel last_decrypted_level_;
301 std::unique_ptr<QuicEncryptedPacket> coalesced_packet_;
302 };
303
SimpleQuicFramer()304 SimpleQuicFramer::SimpleQuicFramer()
305 : framer_(AllSupportedVersions(),
306 QuicTime::Zero(),
307 Perspective::IS_SERVER,
308 kQuicDefaultConnectionIdLength) {}
309
SimpleQuicFramer(const ParsedQuicVersionVector & supported_versions)310 SimpleQuicFramer::SimpleQuicFramer(
311 const ParsedQuicVersionVector& supported_versions)
312 : framer_(supported_versions,
313 QuicTime::Zero(),
314 Perspective::IS_SERVER,
315 kQuicDefaultConnectionIdLength) {}
316
SimpleQuicFramer(const ParsedQuicVersionVector & supported_versions,Perspective perspective)317 SimpleQuicFramer::SimpleQuicFramer(
318 const ParsedQuicVersionVector& supported_versions,
319 Perspective perspective)
320 : framer_(supported_versions,
321 QuicTime::Zero(),
322 perspective,
323 kQuicDefaultConnectionIdLength) {}
324
~SimpleQuicFramer()325 SimpleQuicFramer::~SimpleQuicFramer() {}
326
ProcessPacket(const QuicEncryptedPacket & packet)327 bool SimpleQuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
328 visitor_ = std::make_unique<SimpleFramerVisitor>();
329 framer_.set_visitor(visitor_.get());
330 return framer_.ProcessPacket(packet);
331 }
332
Reset()333 void SimpleQuicFramer::Reset() {
334 visitor_ = std::make_unique<SimpleFramerVisitor>();
335 }
336
header() const337 const QuicPacketHeader& SimpleQuicFramer::header() const {
338 return visitor_->header();
339 }
340
341 const QuicVersionNegotiationPacket*
version_negotiation_packet() const342 SimpleQuicFramer::version_negotiation_packet() const {
343 return visitor_->version_negotiation_packet();
344 }
345
last_decrypted_level() const346 EncryptionLevel SimpleQuicFramer::last_decrypted_level() const {
347 return visitor_->last_decrypted_level();
348 }
349
framer()350 QuicFramer* SimpleQuicFramer::framer() {
351 return &framer_;
352 }
353
num_frames() const354 size_t SimpleQuicFramer::num_frames() const {
355 return ack_frames().size() + goaway_frames().size() +
356 rst_stream_frames().size() + stop_waiting_frames().size() +
357 path_challenge_frames().size() + path_response_frames().size() +
358 stream_frames().size() + ping_frames().size() +
359 connection_close_frames().size() + padding_frames().size() +
360 crypto_frames().size();
361 }
362
ack_frames() const363 const std::vector<QuicAckFrame>& SimpleQuicFramer::ack_frames() const {
364 return visitor_->ack_frames();
365 }
366
stop_waiting_frames() const367 const std::vector<QuicStopWaitingFrame>& SimpleQuicFramer::stop_waiting_frames()
368 const {
369 return visitor_->stop_waiting_frames();
370 }
371
372 const std::vector<QuicPathChallengeFrame>&
path_challenge_frames() const373 SimpleQuicFramer::path_challenge_frames() const {
374 return visitor_->path_challenge_frames();
375 }
376 const std::vector<QuicPathResponseFrame>&
path_response_frames() const377 SimpleQuicFramer::path_response_frames() const {
378 return visitor_->path_response_frames();
379 }
380
ping_frames() const381 const std::vector<QuicPingFrame>& SimpleQuicFramer::ping_frames() const {
382 return visitor_->ping_frames();
383 }
384
message_frames() const385 const std::vector<QuicMessageFrame>& SimpleQuicFramer::message_frames() const {
386 return visitor_->message_frames();
387 }
388
389 const std::vector<QuicWindowUpdateFrame>&
window_update_frames() const390 SimpleQuicFramer::window_update_frames() const {
391 return visitor_->window_update_frames();
392 }
393
394 const std::vector<std::unique_ptr<QuicStreamFrame>>&
stream_frames() const395 SimpleQuicFramer::stream_frames() const {
396 return visitor_->stream_frames();
397 }
398
399 const std::vector<std::unique_ptr<QuicCryptoFrame>>&
crypto_frames() const400 SimpleQuicFramer::crypto_frames() const {
401 return visitor_->crypto_frames();
402 }
403
rst_stream_frames() const404 const std::vector<QuicRstStreamFrame>& SimpleQuicFramer::rst_stream_frames()
405 const {
406 return visitor_->rst_stream_frames();
407 }
408
goaway_frames() const409 const std::vector<QuicGoAwayFrame>& SimpleQuicFramer::goaway_frames() const {
410 return visitor_->goaway_frames();
411 }
412
413 const std::vector<QuicConnectionCloseFrame>&
connection_close_frames() const414 SimpleQuicFramer::connection_close_frames() const {
415 return visitor_->connection_close_frames();
416 }
417
padding_frames() const418 const std::vector<QuicPaddingFrame>& SimpleQuicFramer::padding_frames() const {
419 return visitor_->padding_frames();
420 }
421
coalesced_packet() const422 const QuicEncryptedPacket* SimpleQuicFramer::coalesced_packet() const {
423 return visitor_->coalesced_packet();
424 }
425
426 } // namespace test
427 } // namespace quic
428