http_decoder.cc | Explore in Territory

// Copyright (c) 2018 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/http/http_decoder.h"

#include <algorithm>
#include <cstdint>
#include <string>
#include <utility>

#include "absl/base/attributes.h"
#include "absl/strings/string_view.h"
#include "quiche/http2/http2_constants.h"
#include "quiche/quic/core/http/http_frames.h"
#include "quiche/quic/core/quic_data_reader.h"
#include "quiche/quic/core/quic_error_codes.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/platform/api/quic_bug_tracker.h"
#include "quiche/quic/platform/api/quic_flag_utils.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_logging.h"

namespace quic {

namespace {

// Limit on the payload length for frames that are buffered by HttpDecoder.
// If a frame header indicating a payload length exceeding this limit is
// received, HttpDecoder closes the connection.  Does not apply to frames that
// are not buffered here but each payload fragment is immediately passed to
// Visitor, like HEADERS, DATA, and unknown frames.
constexpr QuicByteCount kPayloadLengthLimit = …;

}  // anonymous namespace

HttpDecoder::HttpDecoder(Visitor* visitor)
    : … { … }

HttpDecoder::~HttpDecoder() { … }

// static
bool HttpDecoder::DecodeSettings(const char* data, QuicByteCount len,
                                 SettingsFrame* frame) { … }

QuicByteCount HttpDecoder::ProcessInput(const char* data, QuicByteCount len) { … }

bool HttpDecoder::ReadFrameType(QuicDataReader& reader) { … }

bool HttpDecoder::ReadFrameLength(QuicDataReader& reader) { … }

bool HttpDecoder::IsFrameBuffered() { … }

bool HttpDecoder::ReadFramePayload(QuicDataReader& reader) { … }

bool HttpDecoder::FinishParsing() { … }

void HttpDecoder::ResetForNextFrame() { … }

bool HttpDecoder::HandleUnknownFramePayload(QuicDataReader& reader) { … }

bool HttpDecoder::BufferOrParsePayload(QuicDataReader& reader) { … }

bool HttpDecoder::ParseEntirePayload(QuicDataReader& reader) { … }

void HttpDecoder::BufferFrameLength(QuicDataReader& reader) { … }

void HttpDecoder::BufferFrameType(QuicDataReader& reader) { … }

void HttpDecoder::RaiseError(QuicErrorCode error, std::string error_detail) { … }

bool HttpDecoder::ParseSettingsFrame(QuicDataReader& reader,
                                     SettingsFrame& frame) { … }

bool HttpDecoder::ParsePriorityUpdateFrame(QuicDataReader& reader,
                                           PriorityUpdateFrame& frame) { … }

bool HttpDecoder::ParseOriginFrame(QuicDataReader& reader, OriginFrame& frame) { … }

bool HttpDecoder::ParseAcceptChFrame(QuicDataReader& reader,
                                     AcceptChFrame& frame) { … }

QuicByteCount HttpDecoder::MaxFrameLength(uint64_t frame_type) { … }

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

}  // namespace quic
chromium/net/third_party/quiche/src/quiche/quic/core/http/http_decoder.cc
