blob: 3e445dc941dbdeb2a764988826a0ea37653e3b8b [file] [log] [blame]
// 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.
#include "absl/strings/string_view.h"
#include "quic/core/crypto/null_decrypter.h"
#include "quic/core/crypto/null_encrypter.h"
#include "quic/core/quic_connection.h"
#include "quic/core/quic_default_packet_writer.h"
#include "quic/core/quic_packets.h"
#include "quic/core/quic_stream_frame_data_producer.h"
#include "quic/core/quic_trace_visitor.h"
#include "quic/platform/api/quic_containers.h"
#include "quic/test_tools/simple_session_notifier.h"
#include "quic/test_tools/simulator/link.h"
#include "quic/test_tools/simulator/queue.h"
#include "quic/test_tools/simulator/quic_endpoint_base.h"
namespace quic {
namespace simulator {
// A QUIC connection endpoint. Wraps around QuicConnection. In order to
// initiate a transfer, the caller has to call AddBytesToTransfer(). The data
// transferred is always the same and is always transferred on a single stream.
// The endpoint receives all packets addressed to it, and verifies that the data
// received is what it's supposed to be.
class QuicEndpoint : public QuicEndpointBase,
public QuicConnectionVisitorInterface,
public SessionNotifierInterface {
QuicEndpoint(Simulator* simulator,
std::string name,
std::string peer_name,
Perspective perspective,
QuicConnectionId connection_id);
QuicByteCount bytes_to_transfer() const;
QuicByteCount bytes_transferred() const;
QuicByteCount bytes_received() const;
inline bool wrong_data_received() const { return wrong_data_received_; }
// Send |bytes| bytes. Initiates the transfer if one is not already in
// progress.
void AddBytesToTransfer(QuicByteCount bytes);
// Begin QuicConnectionVisitorInterface implementation.
void OnStreamFrame(const QuicStreamFrame& frame) override;
void OnCryptoFrame(const QuicCryptoFrame& frame) override;
void OnCanWrite() override;
bool SendProbingData() override;
bool ValidateStatelessReset(
const quic::QuicSocketAddress& /*self_address*/,
const quic::QuicSocketAddress& /*peer_address*/) override {
return true;
bool WillingAndAbleToWrite() const override;
bool ShouldKeepConnectionAlive() const override;
std::string GetStreamsInfoForLogging() const override { return ""; }
void OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/) override {}
void OnBlockedFrame(const QuicBlockedFrame& /*frame*/) override {}
void OnRstStream(const QuicRstStreamFrame& /*frame*/) override {}
void OnGoAway(const QuicGoAwayFrame& /*frame*/) override {}
void OnMessageReceived(absl::string_view /*message*/) override {}
void OnHandshakeDoneReceived() override {}
void OnNewTokenReceived(absl::string_view /*token*/) override {}
void OnConnectionClosed(const QuicConnectionCloseFrame& /*frame*/,
ConnectionCloseSource /*source*/) override {}
void OnWriteBlocked() override {}
void OnSuccessfulVersionNegotiation(
const ParsedQuicVersion& /*version*/) override {}
void OnPacketReceived(const QuicSocketAddress& /*self_address*/,
const QuicSocketAddress& /*peer_address*/,
bool /*is_connectivity_probe*/) override {}
void OnCongestionWindowChange(QuicTime /*now*/) override {}
void OnConnectionMigration(AddressChangeType /*type*/) override {}
void OnPathDegrading() override {}
void OnForwardProgressMadeAfterPathDegrading() override {}
void OnAckNeedsRetransmittableFrame() override {}
void SendAckFrequency(const QuicAckFrequencyFrame& /*frame*/) override {}
void SendNewConnectionId(const QuicNewConnectionIdFrame& /*frame*/) override {
void SendRetireConnectionId(uint64_t /*sequence_number*/) override {}
void OnServerConnectionIdIssued(
const QuicConnectionId& /*server_connection_id*/) override {}
void OnServerConnectionIdRetired(
const QuicConnectionId& /*server_connection_id*/) override {}
bool AllowSelfAddressChange() const override;
HandshakeState GetHandshakeState() const override;
bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& /*frame*/) override {
return true;
bool OnStreamsBlockedFrame(
const QuicStreamsBlockedFrame& /*frame*/) override {
return true;
void OnStopSendingFrame(const QuicStopSendingFrame& /*frame*/) override {}
void OnPacketDecrypted(EncryptionLevel /*level*/) override {}
void OnOneRttPacketAcknowledged() override {}
void OnHandshakePacketSent() override {}
void OnKeyUpdate(KeyUpdateReason /*reason*/) override {}
std::unique_ptr<QuicDecrypter> AdvanceKeysAndCreateCurrentOneRttDecrypter()
override {
return nullptr;
std::unique_ptr<QuicEncrypter> CreateCurrentOneRttEncrypter() override {
return nullptr;
void BeforeConnectionCloseSent() override {}
bool ValidateToken(absl::string_view /*token*/) override { return true; }
bool MaybeSendAddressToken() override { return false; }
bool IsKnownServerAddress(
const QuicSocketAddress& /*address*/) const override {
return false;
// End QuicConnectionVisitorInterface implementation.
// Begin SessionNotifierInterface methods:
bool OnFrameAcked(const QuicFrame& frame,
QuicTime::Delta ack_delay_time,
QuicTime receive_timestamp) override;
void OnStreamFrameRetransmitted(const QuicStreamFrame& /*frame*/) override {}
void OnFrameLost(const QuicFrame& frame) override;
void RetransmitFrames(const QuicFrames& frames,
TransmissionType type) override;
bool IsFrameOutstanding(const QuicFrame& frame) const override;
bool HasUnackedCryptoData() const override;
bool HasUnackedStreamData() const override;
// End SessionNotifierInterface implementation.
// The producer outputs the repetition of the same byte. That sequence is
// verified by the receiver.
class DataProducer : public QuicStreamFrameDataProducer {
WriteStreamDataResult WriteStreamData(QuicStreamId id,
QuicStreamOffset offset,
QuicByteCount data_length,
QuicDataWriter* writer) override;
bool WriteCryptoData(EncryptionLevel level,
QuicStreamOffset offset,
QuicByteCount data_length,
QuicDataWriter* writer) override;
std::unique_ptr<QuicConnection> CreateConnection(
Simulator* simulator,
std::string name,
std::string peer_name,
Perspective perspective,
QuicConnectionId connection_id);
// Write stream data until |bytes_to_transfer_| is zero or the connection is
// write-blocked.
void WriteStreamData();
DataProducer producer_;
QuicByteCount bytes_to_transfer_;
QuicByteCount bytes_transferred_;
// Set to true if the endpoint receives stream data different from what it
// expects.
bool wrong_data_received_;
// Record of received offsets in the data stream.
QuicIntervalSet<QuicStreamOffset> offsets_received_;
std::unique_ptr<test::SimpleSessionNotifier> notifier_;
} // namespace simulator
} // namespace quic