crypto_handshake_message.cc | Explore in Territory

// Copyright (c) 2013 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 "quiche/quic/core/crypto/crypto_handshake_message.h"

#include <memory>
#include <string>

#include "absl/strings/escaping.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/core/crypto/crypto_framer.h"
#include "quiche/quic/core/crypto/crypto_protocol.h"
#include "quiche/quic/core/crypto/crypto_utils.h"
#include "quiche/quic/core/quic_socket_address_coder.h"
#include "quiche/quic/core/quic_utils.h"
#include "quiche/common/quiche_endian.h"

namespace quic {

CryptoHandshakeMessage::CryptoHandshakeMessage() : … { … }

CryptoHandshakeMessage::CryptoHandshakeMessage(
    const CryptoHandshakeMessage& other)
    : … { … }

CryptoHandshakeMessage::CryptoHandshakeMessage(CryptoHandshakeMessage&& other) =
    default;

CryptoHandshakeMessage::~CryptoHandshakeMessage() { … }

CryptoHandshakeMessage& CryptoHandshakeMessage::operator=(
    const CryptoHandshakeMessage& other) { … }

CryptoHandshakeMessage& CryptoHandshakeMessage::operator=(
    CryptoHandshakeMessage&& other) = default;

bool CryptoHandshakeMessage::operator==(
    const CryptoHandshakeMessage& rhs) const { … }

bool CryptoHandshakeMessage::operator!=(
    const CryptoHandshakeMessage& rhs) const { … }

void CryptoHandshakeMessage::Clear() { … }

const QuicData& CryptoHandshakeMessage::GetSerialized() const { … }

void CryptoHandshakeMessage::MarkDirty() { … }

void CryptoHandshakeMessage::SetVersionVector(
    QuicTag tag, ParsedQuicVersionVector versions) { … }

void CryptoHandshakeMessage::SetVersion(QuicTag tag,
                                        ParsedQuicVersion version) { … }

void CryptoHandshakeMessage::SetStringPiece(QuicTag tag,
                                            absl::string_view value) { … }

void CryptoHandshakeMessage::Erase(QuicTag tag) { … }

QuicErrorCode CryptoHandshakeMessage::GetTaglist(
    QuicTag tag, QuicTagVector* out_tags) const { … }

QuicErrorCode CryptoHandshakeMessage::GetVersionLabelList(
    QuicTag tag, QuicVersionLabelVector* out) const { … }

QuicErrorCode CryptoHandshakeMessage::GetVersionLabel(
    QuicTag tag, QuicVersionLabel* out) const { … }

bool CryptoHandshakeMessage::GetStringPiece(QuicTag tag,
                                            absl::string_view* out) const { … }

bool CryptoHandshakeMessage::HasStringPiece(QuicTag tag) const { … }

QuicErrorCode CryptoHandshakeMessage::GetNthValue24(
    QuicTag tag, unsigned index, absl::string_view* out) const { … }

QuicErrorCode CryptoHandshakeMessage::GetUint32(QuicTag tag,
                                                uint32_t* out) const { … }

QuicErrorCode CryptoHandshakeMessage::GetUint64(QuicTag tag,
                                                uint64_t* out) const { … }

QuicErrorCode CryptoHandshakeMessage::GetStatelessResetToken(
    QuicTag tag, StatelessResetToken* out) const { … }

size_t CryptoHandshakeMessage::size() const { … }

void CryptoHandshakeMessage::set_minimum_size(size_t min_bytes) { … }

size_t CryptoHandshakeMessage::minimum_size() const { … }

std::string CryptoHandshakeMessage::DebugString() const { … }

QuicErrorCode CryptoHandshakeMessage::GetPOD(QuicTag tag, void* out,
                                             size_t len) const { … }

std::string CryptoHandshakeMessage::DebugStringInternal(size_t indent) const { … }

}  // namespace quic
chromium/net/third_party/quiche/src/quiche/quic/core/crypto/crypto_handshake_message.cc
