chromium/third_party/boringssl/src/pki/cert_errors.cc

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "cert_errors.h"

#include "cert_error_params.h"
#include "parse_name.h"
#include "parsed_certificate.h"

#include <sstream>

BSSL_NAMESPACE_BEGIN

namespace {

void AppendLinesWithIndentation(const std::string &text,
                                const std::string &indentation,
                                std::string *out) { … }

}  // namespace

CertError::CertError() = default;

CertError::CertError(Severity in_severity, CertErrorId in_id,
                     std::unique_ptr<CertErrorParams> in_params)
    : … { … }

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

CertError &CertError::operator=(CertError &&) = default;

CertError::~CertError() = default;

std::string CertError::ToDebugString() const { … }

CertErrors::CertErrors() = default;
CertErrors::CertErrors(CertErrors &&other) = default;
CertErrors &CertErrors::operator=(CertErrors &&) = default;
CertErrors::~CertErrors() = default;

void CertErrors::Add(CertError::Severity severity, CertErrorId id,
                     std::unique_ptr<CertErrorParams> params) { … }

void CertErrors::AddError(CertErrorId id,
                          std::unique_ptr<CertErrorParams> params) { … }

void CertErrors::AddError(CertErrorId id) { … }

void CertErrors::AddWarning(CertErrorId id,
                            std::unique_ptr<CertErrorParams> params) { … }

void CertErrors::AddWarning(CertErrorId id) { … }

std::string CertErrors::ToDebugString() const { … }

bool CertErrors::ContainsErrorWithSeverity(CertErrorId id,
                                           CertError::Severity severity) const { … }

bool CertErrors::ContainsError(CertErrorId id) const { … }

bool CertErrors::ContainsAnyErrorWithSeverity(
    CertError::Severity severity) const { … }

CertPathErrors::CertPathErrors() = default;

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

CertPathErrors::~CertPathErrors() = default;

CertErrors *CertPathErrors::GetErrorsForCert(size_t cert_index) { … }

const CertErrors *CertPathErrors::GetErrorsForCert(size_t cert_index) const { … }

CertErrors *CertPathErrors::GetOtherErrors() { … }

const CertErrors *CertPathErrors::GetOtherErrors() const { … }

bool CertPathErrors::ContainsError(CertErrorId id) const { … }

bool CertPathErrors::ContainsAnyErrorWithSeverity(
    CertError::Severity severity) const { … }

std::optional<CertErrorId> CertPathErrors::FindSingleHighSeverityError(
    ptrdiff_t &out_depth) const { … }

std::string CertPathErrors::ToDebugString(
    const ParsedCertificateList &certs) const { … }

BSSL_NAMESPACE_END