blob: f209950fc952338e349243325225c94df464f6d2 [file] [log] [blame] [edit]
// Copyright (c) 2019 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.
#ifndef QUICHE_QUIC_CORE_QUIC_COALESCED_PACKET_H_
#define QUICHE_QUIC_CORE_QUIC_COALESCED_PACKET_H_
#include "quiche/quic/core/quic_packets.h"
namespace quic {
namespace test {
class QuicCoalescedPacketPeer;
}
// QuicCoalescedPacket is used to buffer multiple packets which can be coalesced
// into the same UDP datagram.
class QUICHE_EXPORT QuicCoalescedPacket {
public:
QuicCoalescedPacket();
~QuicCoalescedPacket();
// Returns true if |packet| is successfully coalesced with existing packets.
// Returns false otherwise.
bool MaybeCoalescePacket(const SerializedPacket& packet,
const QuicSocketAddress& self_address,
const QuicSocketAddress& peer_address,
quiche::QuicheBufferAllocator* allocator,
QuicPacketLength current_max_packet_length,
QuicEcnCodepoint ecn_codepoint, uint32_t flow_label);
// Clears this coalesced packet.
void Clear();
// Clears all state associated with initial_packet_.
void NeuterInitialPacket();
// Copies encrypted_buffers_ to |buffer| and sets |length_copied| to the
// copied amount. Returns false if copy fails (i.e., |buffer_len| is not
// enough).
bool CopyEncryptedBuffers(char* buffer, size_t buffer_len,
size_t* length_copied) const;
std::string ToString(size_t serialized_length) const;
// Returns true if this coalesced packet contains packet of |level|.
bool ContainsPacketOfEncryptionLevel(EncryptionLevel level) const;
// Returns transmission type of packet of |level|. This should only be called
// when this coalesced packet contains packet of |level|.
TransmissionType TransmissionTypeOfPacket(EncryptionLevel level) const;
// Returns number of packets contained in this coalesced packet.
size_t NumberOfPackets() const;
const SerializedPacket* initial_packet() const {
return initial_packet_.get();
}
const QuicSocketAddress& self_address() const { return self_address_; }
const QuicSocketAddress& peer_address() const { return peer_address_; }
QuicPacketLength length() const { return length_; }
QuicPacketLength max_packet_length() const { return max_packet_length_; }
std::vector<size_t> packet_lengths() const;
QuicEcnCodepoint ecn_codepoint() const { return ecn_codepoint_; }
uint32_t flow_label() const { return flow_label_; }
private:
friend class test::QuicCoalescedPacketPeer;
// self/peer addresses are set when trying to coalesce the first packet.
// Packets with different self/peer addresses cannot be coalesced.
QuicSocketAddress self_address_;
QuicSocketAddress peer_address_;
// Length of this coalesced packet.
QuicPacketLength length_;
// Max packet length. Do not try to coalesce packet when max packet length
// changes (e.g., with MTU discovery).
QuicPacketLength max_packet_length_;
// Copies of packets' encrypted buffers according to different encryption
// levels.
std::string encrypted_buffers_[NUM_ENCRYPTION_LEVELS];
// Recorded transmission type according to different encryption levels.
TransmissionType transmission_types_[NUM_ENCRYPTION_LEVELS];
// A copy of ENCRYPTION_INITIAL packet if this coalesced packet contains one.
// Null otherwise. Please note, the encrypted_buffer field is not copied. The
// frames are copied to allow it be re-serialized when this coalesced packet
// gets sent.
std::unique_ptr<SerializedPacket> initial_packet_;
// A coalesced packet shares an ECN codepoint.
QuicEcnCodepoint ecn_codepoint_;
// A coalesced packet shares an single flow label.
uint32_t flow_label_;
};
} // namespace quic
#endif // QUICHE_QUIC_CORE_QUIC_COALESCED_PACKET_H_