grpc 1.63.0 → 1.64.0

data/src/core/ext/filters/deadline/deadline_filter.cc

@@ -1,407 +0,0 @@
-//
-// Copyright 2016 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/deadline/deadline_filter.h"
-
-#include <functional>
-#include <memory>
-#include <new>
-#include <utility>
-
-#include "absl/status/status.h"
-#include "absl/types/optional.h"
-
-#include <grpc/impl/channel_arg_names.h>
-#include <grpc/status.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/promise/arena_promise.h"
-#include "src/core/lib/promise/context.h"
-#include "src/core/lib/surface/call.h"
-#include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/metadata_batch.h"
-
-namespace grpc_core {
-
-// A fire-and-forget class representing a pending deadline timer.
-// Allocated on the call arena.
-class TimerState {
- public:
-  TimerState(grpc_deadline_state* deadline_state, Timestamp deadline)
-      : deadline_state_(deadline_state) {
-    GRPC_CALL_STACK_REF(deadline_state->call_stack, "DeadlineTimerState");
-    GRPC_CLOSURE_INIT(&closure_, TimerCallback, this, nullptr);
-    grpc_timer_init(&timer_, deadline, &closure_);
-  }
-
-  void Cancel() { grpc_timer_cancel(&timer_); }
-
- private:
-  // The on_complete callback used when sending a cancel_error batch down the
-  // filter stack.  Yields the call combiner when the batch returns.
-  static void YieldCallCombiner(void* arg, grpc_error_handle /*ignored*/) {
-    TimerState* self = static_cast<TimerState*>(arg);
-    GRPC_CALL_COMBINER_STOP(self->deadline_state_->call_combiner,
-                            "got on_complete from cancel_stream batch");
-    GRPC_CALL_STACK_UNREF(self->deadline_state_->call_stack,
-                          "DeadlineTimerState");
-  }
-
-  // This is called via the call combiner, so access to deadline_state is
-  // synchronized.
-  static void SendCancelOpInCallCombiner(void* arg, grpc_error_handle error) {
-    TimerState* self = static_cast<TimerState*>(arg);
-    grpc_transport_stream_op_batch* batch = grpc_make_transport_stream_op(
-        GRPC_CLOSURE_INIT(&self->closure_, YieldCallCombiner, self, nullptr));
-    batch->cancel_stream = true;
-    batch->payload->cancel_stream.cancel_error = error;
-    grpc_call_element* elem = self->deadline_state_->elem;
-    elem->filter->start_transport_stream_op_batch(elem, batch);
-  }
-
-  // Timer callback.
-  static void TimerCallback(void* arg, grpc_error_handle error) {
-    TimerState* self = static_cast<TimerState*>(arg);
-    if (error != absl::CancelledError()) {
-      error = grpc_error_set_int(GRPC_ERROR_CREATE("Deadline Exceeded"),
-                                 StatusIntProperty::kRpcStatus,
-                                 GRPC_STATUS_DEADLINE_EXCEEDED);
-      self->deadline_state_->call_combiner->Cancel(error);
-      GRPC_CLOSURE_INIT(&self->closure_, SendCancelOpInCallCombiner, self,
-                        nullptr);
-      GRPC_CALL_COMBINER_START(self->deadline_state_->call_combiner,
-                               &self->closure_, error,
-                               "deadline exceeded -- sending cancel_stream op");
-    } else {
-      GRPC_CALL_STACK_UNREF(self->deadline_state_->call_stack,
-                            "DeadlineTimerState");
-    }
-  }
-
-  // NOTE: This object's dtor is never called, so do not add any data
-  // members that require destruction!
-  // TODO(roth): We should ideally call this object's dtor somewhere,
-  // but that would require adding more synchronization, because we'd
-  // need to call the dtor only after both (a) the timer callback
-  // finishes and (b) the filter sees the call completion and attempts
-  // to cancel the timer.
-  grpc_deadline_state* deadline_state_;
-  grpc_timer timer_;
-  grpc_closure closure_;
-};
-
-}  // namespace grpc_core
-
-//
-// grpc_deadline_state
-//
-
-// Starts the deadline timer.
-// This is called via the call combiner, so access to deadline_state is
-// synchronized.
-static void start_timer_if_needed(grpc_deadline_state* deadline_state,
-                                  grpc_core::Timestamp deadline) {
-  if (deadline == grpc_core::Timestamp::InfFuture()) return;
-  GPR_ASSERT(deadline_state->timer_state == nullptr);
-  deadline_state->timer_state =
-      deadline_state->arena->New<grpc_core::TimerState>(deadline_state,
-                                                        deadline);
-}
-
-// Cancels the deadline timer.
-// This is called via the call combiner, so access to deadline_state is
-// synchronized.
-static void cancel_timer_if_needed(grpc_deadline_state* deadline_state) {
-  if (deadline_state->timer_state != nullptr) {
-    deadline_state->timer_state->Cancel();
-    deadline_state->timer_state = nullptr;
-  }
-}
-
-// Callback run when we receive trailing metadata.
-static void recv_trailing_metadata_ready(void* arg, grpc_error_handle error) {
-  grpc_deadline_state* deadline_state = static_cast<grpc_deadline_state*>(arg);
-  cancel_timer_if_needed(deadline_state);
-  // Invoke the original callback.
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          deadline_state->original_recv_trailing_metadata_ready,
-                          error);
-}
-
-// Inject our own recv_trailing_metadata_ready callback into op.
-static void inject_recv_trailing_metadata_ready(
-    grpc_deadline_state* deadline_state, grpc_transport_stream_op_batch* op) {
-  deadline_state->original_recv_trailing_metadata_ready =
-      op->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
-  GRPC_CLOSURE_INIT(&deadline_state->recv_trailing_metadata_ready,
-                    recv_trailing_metadata_ready, deadline_state,
-                    grpc_schedule_on_exec_ctx);
-  op->payload->recv_trailing_metadata.recv_trailing_metadata_ready =
-      &deadline_state->recv_trailing_metadata_ready;
-}
-
-// Callback and associated state for starting the timer after call stack
-// initialization has been completed.
-struct start_timer_after_init_state {
-  start_timer_after_init_state(grpc_deadline_state* deadline_state,
-                               grpc_core::Timestamp deadline)
-      : deadline_state(deadline_state), deadline(deadline) {}
-  ~start_timer_after_init_state() {
-    start_timer_if_needed(deadline_state, deadline);
-  }
-
-  bool in_call_combiner = false;
-  grpc_deadline_state* deadline_state;
-  grpc_core::Timestamp deadline;
-  grpc_closure closure;
-};
-static void start_timer_after_init(void* arg, grpc_error_handle error) {
-  struct start_timer_after_init_state* state =
-      static_cast<struct start_timer_after_init_state*>(arg);
-  grpc_deadline_state* deadline_state = state->deadline_state;
-  if (!state->in_call_combiner) {
-    // We are initially called without holding the call combiner, so we
-    // need to bounce ourselves into it.
-    state->in_call_combiner = true;
-    GRPC_CALL_COMBINER_START(deadline_state->call_combiner, &state->closure,
-                             error, "scheduling deadline timer");
-    return;
-  }
-  delete state;
-  GRPC_CALL_COMBINER_STOP(deadline_state->call_combiner,
-                          "done scheduling deadline timer");
-}
-
-grpc_deadline_state::grpc_deadline_state(grpc_call_element* elem,
-                                         const grpc_call_element_args& args,
-                                         grpc_core::Timestamp deadline)
-    : elem(elem),
-      call_stack(args.call_stack),
-      call_combiner(args.call_combiner),
-      arena(args.arena) {
-  // Deadline will always be infinite on servers, so the timer will only be
-  // set on clients with a finite deadline.
-  if (deadline != grpc_core::Timestamp::InfFuture()) {
-    // When the deadline passes, we indicate the failure by sending down
-    // an op with cancel_error set.  However, we can't send down any ops
-    // until after the call stack is fully initialized.  If we start the
-    // timer here, we have no guarantee that the timer won't pop before
-    // call stack initialization is finished.  To avoid that problem, we
-    // create a closure to start the timer, and we schedule that closure
-    // to be run after call stack initialization is done.
-    struct start_timer_after_init_state* state =
-        new start_timer_after_init_state(this, deadline);
-    GRPC_CLOSURE_INIT(&state->closure, start_timer_after_init, state,
-                      grpc_schedule_on_exec_ctx);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &state->closure, absl::OkStatus());
-  }
-}
-
-grpc_deadline_state::~grpc_deadline_state() { cancel_timer_if_needed(this); }
-
-void grpc_deadline_state_reset(grpc_deadline_state* deadline_state,
-                               grpc_core::Timestamp new_deadline) {
-  cancel_timer_if_needed(deadline_state);
-  start_timer_if_needed(deadline_state, new_deadline);
-}
-
-void grpc_deadline_state_client_start_transport_stream_op_batch(
-    grpc_deadline_state* deadline_state, grpc_transport_stream_op_batch* op) {
-  if (op->cancel_stream) {
-    cancel_timer_if_needed(deadline_state);
-  } else {
-    // Make sure we know when the call is complete, so that we can cancel
-    // the timer.
-    if (op->recv_trailing_metadata) {
-      inject_recv_trailing_metadata_ready(deadline_state, op);
-    }
-  }
-}
-
-//
-// filter code
-//
-
-// Constructor for channel_data.  Used for both client and server filters.
-static grpc_error_handle deadline_init_channel_elem(
-    grpc_channel_element* /*elem*/, grpc_channel_element_args* args) {
-  GPR_ASSERT(!args->is_last);
-  return absl::OkStatus();
-}
-
-// Destructor for channel_data.  Used for both client and server filters.
-static void deadline_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
-
-// Additional call data used only for the server filter.
-struct server_call_data {
-  grpc_deadline_state deadline_state;  // Must be first.
-  // The closure for receiving initial metadata.
-  grpc_closure recv_initial_metadata_ready;
-  // Received initial metadata batch.
-  grpc_metadata_batch* recv_initial_metadata;
-  // The original recv_initial_metadata_ready closure, which we chain to
-  // after our own closure is invoked.
-  grpc_closure* next_recv_initial_metadata_ready;
-};
-
-// Constructor for call_data.  Used for both client and server filters.
-static grpc_error_handle deadline_init_call_elem(
-    grpc_call_element* elem, const grpc_call_element_args* args) {
-  new (elem->call_data) grpc_deadline_state(elem, *args, args->deadline);
-  return absl::OkStatus();
-}
-
-// Destructor for call_data.  Used for both client and server filters.
-static void deadline_destroy_call_elem(
-    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
-    grpc_closure* /*ignored*/) {
-  grpc_deadline_state* deadline_state =
-      static_cast<grpc_deadline_state*>(elem->call_data);
-  deadline_state->~grpc_deadline_state();
-}
-
-// Method for starting a call op for client filter.
-static void deadline_client_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  grpc_deadline_state_client_start_transport_stream_op_batch(
-      static_cast<grpc_deadline_state*>(elem->call_data), op);
-  // Chain to next filter.
-  grpc_call_next_op(elem, op);
-}
-
-// Callback for receiving initial metadata on the server.
-static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
-  server_call_data* calld = static_cast<server_call_data*>(elem->call_data);
-  start_timer_if_needed(
-      &calld->deadline_state,
-      calld->recv_initial_metadata->get(grpc_core::GrpcTimeoutMetadata())
-          .value_or(grpc_core::Timestamp::InfFuture()));
-  // Invoke the next callback.
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->next_recv_initial_metadata_ready, error);
-}
-
-// Method for starting a call op for server filter.
-static void deadline_server_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  server_call_data* calld = static_cast<server_call_data*>(elem->call_data);
-  if (op->cancel_stream) {
-    cancel_timer_if_needed(&calld->deadline_state);
-  } else {
-    // If we're receiving initial metadata, we need to get the deadline
-    // from the recv_initial_metadata_ready callback.  So we inject our
-    // own callback into that hook.
-    if (op->recv_initial_metadata) {
-      calld->next_recv_initial_metadata_ready =
-          op->payload->recv_initial_metadata.recv_initial_metadata_ready;
-      calld->recv_initial_metadata =
-          op->payload->recv_initial_metadata.recv_initial_metadata;
-      GRPC_CLOSURE_INIT(&calld->recv_initial_metadata_ready,
-                        recv_initial_metadata_ready, elem,
-                        grpc_schedule_on_exec_ctx);
-      op->payload->recv_initial_metadata.recv_initial_metadata_ready =
-          &calld->recv_initial_metadata_ready;
-    }
-    // Make sure we know when the call is complete, so that we can cancel
-    // the timer.
-    // Note that we trigger this on recv_trailing_metadata, even though
-    // the client never sends trailing metadata, because this is the
-    // hook that tells us when the call is complete on the server side.
-    if (op->recv_trailing_metadata) {
-      inject_recv_trailing_metadata_ready(&calld->deadline_state, op);
-    }
-  }
-  // Chain to next filter.
-  grpc_call_next_op(elem, op);
-}
-
-const grpc_channel_filter grpc_client_deadline_filter = {
-    deadline_client_start_transport_stream_op_batch,
-    [](grpc_channel_element*, grpc_core::CallArgs call_args,
-       grpc_core::NextPromiseFactory next_promise_factory) {
-      return next_promise_factory(std::move(call_args));
-    },
-    /* init_call: */ nullptr,
-    grpc_channel_next_op,
-    sizeof(grpc_deadline_state),
-    deadline_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    deadline_destroy_call_elem,
-    0,  // sizeof(channel_data)
-    deadline_init_channel_elem,
-    grpc_channel_stack_no_post_init,
-    deadline_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "deadline",
-};
-
-const grpc_channel_filter grpc_server_deadline_filter = {
-    deadline_server_start_transport_stream_op_batch,
-    [](grpc_channel_element*, grpc_core::CallArgs call_args,
-       grpc_core::NextPromiseFactory next_promise_factory) {
-      auto deadline = call_args.client_initial_metadata->get(
-          grpc_core::GrpcTimeoutMetadata());
-      if (deadline.has_value()) {
-        grpc_core::GetContext<grpc_core::CallContext>()->UpdateDeadline(
-            *deadline);
-      }
-      return next_promise_factory(std::move(call_args));
-    },
-    [](grpc_channel_element*, grpc_core::CallSpineInterface* spine) {
-      spine->client_initial_metadata().receiver.InterceptAndMap(
-          [](grpc_core::ClientMetadataHandle md) {
-            auto deadline = md->get(grpc_core::GrpcTimeoutMetadata());
-            if (deadline.has_value()) {
-              grpc_core::GetContext<grpc_core::CallContext>()->UpdateDeadline(
-                  *deadline);
-            }
-            return md;
-          });
-    },
-    grpc_channel_next_op,
-    sizeof(server_call_data),
-    deadline_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    deadline_destroy_call_elem,
-    0,  // sizeof(channel_data)
-    deadline_init_channel_elem,
-    grpc_channel_stack_no_post_init,
-    deadline_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "deadline",
-};
-
-namespace grpc_core {
-void RegisterDeadlineFilter(CoreConfiguration::Builder* builder) {
-  builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL, &grpc_client_deadline_filter)
-      .ExcludeFromMinimalStack()
-      .IfChannelArg(GRPC_ARG_ENABLE_DEADLINE_CHECKS, true);
-  builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL, &grpc_server_deadline_filter)
-      .ExcludeFromMinimalStack()
-      .IfChannelArg(GRPC_ARG_ENABLE_DEADLINE_CHECKS, true);
-}
-}  // namespace grpc_core

data/src/core/ext/filters/deadline/deadline_filter.h

@@ -1,85 +0,0 @@
-//
-// Copyright 2016 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H
-#define GRPC_SRC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/channel/channel_fwd.h"
-#include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/call_combiner.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/transport/transport.h"
-
-namespace grpc_core {
-class TimerState;
-}  // namespace grpc_core
-
-// State used for filters that enforce call deadlines.
-// Must be the first field in the filter's call_data.
-struct grpc_deadline_state {
-  grpc_deadline_state(grpc_call_element* elem,
-                      const grpc_call_element_args& args,
-                      grpc_core::Timestamp deadline);
-  ~grpc_deadline_state();
-
-  // We take a reference to the call stack for the timer callback.
-  grpc_call_element* elem;
-  grpc_call_stack* call_stack;
-  grpc_core::CallCombiner* call_combiner;
-  grpc_core::Arena* arena;
-  grpc_core::TimerState* timer_state = nullptr;
-  // Closure to invoke when we receive trailing metadata.
-  // We use this to cancel the timer.
-  grpc_closure recv_trailing_metadata_ready;
-  // The original recv_trailing_metadata_ready closure, which we chain to
-  // after our own closure is invoked.
-  grpc_closure* original_recv_trailing_metadata_ready;
-};
-
-// Cancels the existing timer and starts a new one with new_deadline.
-//
-// Note: It is generally safe to call this with an earlier deadline
-// value than the current one, but not the reverse.  No checks are done
-// to ensure that the timer callback is not invoked while it is in the
-// process of being reset, which means that attempting to increase the
-// deadline may result in the timer being called twice.
-//
-// Note: Must be called while holding the call combiner.
-void grpc_deadline_state_reset(grpc_deadline_state* deadline_state,
-                               grpc_core::Timestamp new_deadline);
-
-// To be called from the client-side filter's start_transport_stream_op_batch()
-// method.  Ensures that the deadline timer is cancelled when the call
-// is completed.
-//
-// Note: It is the caller's responsibility to chain to the next filter if
-// necessary after this function returns.
-//
-// Note: Must be called while holding the call combiner.
-void grpc_deadline_state_client_start_transport_stream_op_batch(
-    grpc_deadline_state* deadline_state, grpc_transport_stream_op_batch* op);
-
-// Deadline filters for direct client channels and server channels.
-// Note: Deadlines for non-direct client channels are handled by the
-// client_channel filter.
-extern const grpc_channel_filter grpc_client_deadline_filter;
-extern const grpc_channel_filter grpc_server_deadline_filter;
-
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H

data/src/core/lib/gpr/log_internal.h

@@ -1,55 +0,0 @@
-// Copyright 2022 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef GRPC_SRC_CORE_LIB_GPR_LOG_INTERNAL_H
-#define GRPC_SRC_CORE_LIB_GPR_LOG_INTERNAL_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <cstring>
-
-/// abort() the process if x is zero, with rudimentary logging to prevent
-/// circular dependencies with gpr_log.
-
-/// Intended for internal invariants.  If the error can be recovered from,
-/// without the possibility of corruption, or might best be reflected via
-/// an exception in a higher-level language, consider returning error code.
-#define GPR_ASSERT_INTERNAL(x)                     \
-  do {                                             \
-    if (GPR_UNLIKELY(!(x))) {                      \
-      fprintf(stderr, "assertion failed: %s", #x); \
-      abort();                                     \
-    }                                              \
-  } while (0)
-
-#ifndef NDEBUG
-#define GPR_DEBUG_ASSERT_INTERNAL(x) GPR_ASSERT_INTERNAL(x)
-#else
-#define GPR_DEBUG_ASSERT_INTERNAL(x)
-#endif
-
-#define GPR_LOG_ERROR_INTERNAL(format, ...)                       \
-  do {                                                            \
-    char f[] = __FILE__;                                          \
-    char* display_file = f;                                       \
-    char* slash_pos = strrchr(f, '/');                            \
-    if (slash_pos != nullptr) display_file = slash_pos + 1;       \
-    char prefix[60];                                              \
-    sprintf(prefix, "INTERNAL %37s:%d]", display_file, __LINE__); \
-    fprintf(stderr, "%-60s " format "\n", prefix, __VA_ARGS__);   \
-  } while (0)
-
-#endif  // GRPC_SRC_CORE_LIB_GPR_LOG_INTERNAL_H

data/third_party/boringssl-with-bazel/src/include/openssl/pki/certificate.h

@@ -1,83 +0,0 @@
-/* Copyright (c) 2023, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#if !defined(OPENSSL_HEADER_BSSL_PKI_CERTIFICATE_H_) && defined(__cplusplus)
-#define OPENSSL_HEADER_BSSL_PKI_CERTIFICATE_H_
-
-#include <memory>
-#include <string>
-#include <string_view>
-
-#include <openssl/base.h>
-#include <openssl/span.h>
-
-namespace bssl {
-
-struct CertificateInternals;
-
-// Certificate represents a parsed X.509 certificate. It includes accessors for
-// the various things that one might want to extract from a certificate,
-class OPENSSL_EXPORT Certificate {
- public:
-  Certificate(Certificate&& other);
-  Certificate(const Certificate& other) = delete;
-  ~Certificate();
-  Certificate& operator=(const Certificate& other) = delete;
-
-  // FromDER returns a certificate from an DER-encoded X.509 object in |der|.
-  // In the event of a failure, it will return no value, and |out_diagnostic|
-  // may be set to a string of human readable debugging information if
-  // information abou the failure is available.
-  static std::unique_ptr<Certificate> FromDER(
-      bssl::Span<const uint8_t> der, std::string *out_diagnostic);
-
-  // FromPEM returns a certificate from the first CERTIFICATE PEM block in
-  // |pem|. In the event of a failure, it will return no value, and
-  // |out_diagnostic| may be set to a string of human readable debugging
-  // informtion if informaiton about the failuew is available.
-  static std::unique_ptr<Certificate> FromPEM(
-      std::string_view pem, std::string *out_diagnostic);
-
-  // IsSelfIssued returns true if the certificate is "self-issued" per RFC 5280
-  // section 6.1. I.e. that the subject and issuer names are equal after
-  // canonicalization (and no other checks).
-  //
-  // Other contexts may have a different notion such as "self signed" which
-  // may or may not be this, and may check other properties of the certificate.
-  bool IsSelfIssued() const;
-
-  // Validity specifies the temporal validity of a cerificate, expressed in
-  // POSIX time values of seconds since the POSIX epoch. The certificate is
-  // valid at POSIX time t in second granularity, where not_before <= t <=
-  // not_after.
-  struct Validity {
-    int64_t not_before;
-    int64_t not_after;
-  };
-
-  Validity GetValidity() const;
-
-  // The binary, big-endian, DER representation of the certificate serial
-  // number. It may include a leading 00 byte.
-  bssl::Span<const uint8_t> GetSerialNumber() const;
-
- private:
-  explicit Certificate(std::unique_ptr<CertificateInternals> internals);
-
-  std::unique_ptr<CertificateInternals> internals_;
-};
-
-}  // namespace bssl
-
-#endif  // OPENSSL_HEADER_BSSL_PKI_CERTIFICATE_H_ && __cplusplus

data/third_party/boringssl-with-bazel/src/include/openssl/pki/signature_verify_cache.h

@@ -1,41 +0,0 @@
-// Copyright 2022 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#if !defined(BSSL_PKI_SIGNATURE_VERIFY_CACHE_H_) && defined(__cplusplus)
-#define BSSL_PKI_SIGNATURE_VERIFY_CACHE_H_
-
-#include <openssl/base.h>
-#include <string>
-
-namespace bssl {
-
-class OPENSSL_EXPORT SignatureVerifyCache {
- public:
-  enum class Value {
-    kValid,    // Cached as a valid signature result.
-    kInvalid,  // Cached as an invalid signature result.
-    kUnknown,  // Cache has no information.
-  };
-
-  virtual ~SignatureVerifyCache() = default;
-
-  // This interface uses a const std::string reference instead of
-  // std::string_view because any implementation that may reasonably want to use
-  // std::unordered_map or similar can run into problems with std::hash before
-  // C++20. (https://en.cppreference.com/w/cpp/container/unordered_map/find)
-
-  // |Store| is called to store the result of a verification for |key| as kValid
-  // or kInvalid after a signature check.
-  virtual void Store(const std::string &key, Value value) = 0;
-
-  // |Check| is called to fetch a cached value for a verification for |key|. If
-  // the result is kValid, or kInvalid, signature checking is skipped and the
-  // corresponding cached result is used.  If the result is kUnknown signature
-  // checking is performed and the corresponding result saved using |Store|.
-  virtual Value Check(const std::string &key) = 0;
-};
-
-}  // namespace bssl
-
-#endif  // BSSL_PKI_SIGNATURE_VERIFY_CACHE_H_ && __cplusplus