grpc 1.62.3 → 1.63.0

data/third_party/abseil-cpp/absl/log/internal/log_sink_set.h

@@ -0,0 +1,54 @@
+// Copyright 2022 The Abseil 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// File: log/internal/log_sink_set.h
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_LOG_INTERNAL_LOG_SINK_SET_H_
+#define ABSL_LOG_INTERNAL_LOG_SINK_SET_H_
+
+#include "absl/base/config.h"
+#include "absl/log/log_entry.h"
+#include "absl/log/log_sink.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+
+// Returns true if a globally-registered `LogSink`'s `Send()` is currently
+// being invoked on this thread.
+bool ThreadIsLoggingToLogSink();
+
+// This function may log to two sets of sinks:
+//
+// * If `extra_sinks_only` is true, it will dispatch only to `extra_sinks`.
+//   `LogMessage::ToSinkAlso` and `LogMessage::ToSinkOnly` are used to attach
+//    extra sinks to the entry.
+// * Otherwise it will also log to the global sinks set. This set is managed
+//   by `absl::AddLogSink` and `absl::RemoveLogSink`.
+void LogToSinks(const absl::LogEntry& entry,
+                absl::Span<absl::LogSink*> extra_sinks, bool extra_sinks_only);
+
+// Implementation for operations with log sink set.
+void AddLogSink(absl::LogSink* sink);
+void RemoveLogSink(absl::LogSink* sink);
+void FlushLogSinks();
+
+}  // namespace log_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_LOG_INTERNAL_LOG_SINK_SET_H_

data/third_party/abseil-cpp/absl/log/internal/nullguard.cc

@@ -0,0 +1,35 @@
+// Copyright 2023 The Abseil 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
+//
+//     https://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 "absl/log/internal/nullguard.h"
+
+#include <array>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+
+ABSL_CONST_INIT ABSL_DLL const std::array<char, 7> kCharNull{
+    {'(', 'n', 'u', 'l', 'l', ')', '\0'}};
+ABSL_CONST_INIT ABSL_DLL const std::array<signed char, 7> kSignedCharNull{
+    {'(', 'n', 'u', 'l', 'l', ')', '\0'}};
+ABSL_CONST_INIT ABSL_DLL const std::array<unsigned char, 7> kUnsignedCharNull{
+    {'(', 'n', 'u', 'l', 'l', ')', '\0'}};
+
+}  // namespace log_internal
+ABSL_NAMESPACE_END
+}  // namespace absl

data/third_party/abseil-cpp/absl/log/internal/nullguard.h

@@ -0,0 +1,88 @@
+// Copyright 2022 The Abseil 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// File: log/internal/nullguard.h
+// -----------------------------------------------------------------------------
+//
+// NullGuard exists such that NullGuard<T>::Guard(v) returns v, unless passed a
+// nullptr_t, or a null char* or const char*, in which case it returns "(null)".
+// This allows streaming NullGuard<T>::Guard(v) to an output stream without
+// hitting undefined behavior for null values.
+
+#ifndef ABSL_LOG_INTERNAL_NULLGUARD_H_
+#define ABSL_LOG_INTERNAL_NULLGUARD_H_
+
+#include <array>
+#include <cstddef>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+
+ABSL_CONST_INIT ABSL_DLL extern const std::array<char, 7> kCharNull;
+ABSL_CONST_INIT ABSL_DLL extern const std::array<signed char, 7>
+    kSignedCharNull;
+ABSL_CONST_INIT ABSL_DLL extern const std::array<unsigned char, 7>
+    kUnsignedCharNull;
+
+template <typename T>
+struct NullGuard final {
+  static const T& Guard(const T& v) { return v; }
+};
+template <>
+struct NullGuard<char*> final {
+  static const char* Guard(const char* v) { return v ? v : kCharNull.data(); }
+};
+template <>
+struct NullGuard<const char*> final {
+  static const char* Guard(const char* v) { return v ? v : kCharNull.data(); }
+};
+template <>
+struct NullGuard<signed char*> final {
+  static const signed char* Guard(const signed char* v) {
+    return v ? v : kSignedCharNull.data();
+  }
+};
+template <>
+struct NullGuard<const signed char*> final {
+  static const signed char* Guard(const signed char* v) {
+    return v ? v : kSignedCharNull.data();
+  }
+};
+template <>
+struct NullGuard<unsigned char*> final {
+  static const unsigned char* Guard(const unsigned char* v) {
+    return v ? v : kUnsignedCharNull.data();
+  }
+};
+template <>
+struct NullGuard<const unsigned char*> final {
+  static const unsigned char* Guard(const unsigned char* v) {
+    return v ? v : kUnsignedCharNull.data();
+  }
+};
+template <>
+struct NullGuard<std::nullptr_t> final {
+  static const char* Guard(const std::nullptr_t&) { return kCharNull.data(); }
+};
+
+}  // namespace log_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_LOG_INTERNAL_NULLGUARD_H_

data/third_party/abseil-cpp/absl/log/internal/nullstream.h

@@ -0,0 +1,136 @@
+// Copyright 2022 The Abseil 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// File: log/internal/nullstream.h
+// -----------------------------------------------------------------------------
+//
+// Classes `NullStream`, `NullStreamMaybeFatal ` and `NullStreamFatal`
+// implement a subset of the `LogMessage` API and are used instead when logging
+// of messages has been disabled.
+
+#ifndef ABSL_LOG_INTERNAL_NULLSTREAM_H_
+#define ABSL_LOG_INTERNAL_NULLSTREAM_H_
+
+#ifdef _WIN32
+#include <cstdlib>
+#else
+#include <unistd.h>
+#endif
+#include <ios>
+#include <ostream>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/log_severity.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+
+// A `NullStream` implements the API of `LogMessage` (a few methods and
+// `operator<<`) but does nothing.  All methods are defined inline so the
+// compiler can eliminate the whole instance and discard anything that's
+// streamed in.
+class NullStream {
+ public:
+  NullStream& AtLocation(absl::string_view, int) { return *this; }
+  template <typename SourceLocationType>
+  NullStream& AtLocation(SourceLocationType) {
+    return *this;
+  }
+  NullStream& NoPrefix() { return *this; }
+  NullStream& WithVerbosity(int) { return *this; }
+  template <typename TimeType>
+  NullStream& WithTimestamp(TimeType) {
+    return *this;
+  }
+  template <typename Tid>
+  NullStream& WithThreadID(Tid) {
+    return *this;
+  }
+  template <typename LogEntryType>
+  NullStream& WithMetadataFrom(const LogEntryType&) {
+    return *this;
+  }
+  NullStream& WithPerror() { return *this; }
+  template <typename LogSinkType>
+  NullStream& ToSinkAlso(LogSinkType*) {
+    return *this;
+  }
+  template <typename LogSinkType>
+  NullStream& ToSinkOnly(LogSinkType*) {
+    return *this;
+  }
+  template <typename LogSinkType>
+  NullStream& OutputToSink(LogSinkType*, bool) {
+    return *this;
+  }
+  NullStream& InternalStream() { return *this; }
+};
+template <typename T>
+inline NullStream& operator<<(NullStream& str, const T&) {
+  return str;
+}
+inline NullStream& operator<<(NullStream& str,
+                              std::ostream& (*)(std::ostream& os)) {
+  return str;
+}
+inline NullStream& operator<<(NullStream& str,
+                              std::ios_base& (*)(std::ios_base& os)) {
+  return str;
+}
+
+// `NullStreamMaybeFatal` implements the process termination semantics of
+// `LogMessage`, which is used for `DFATAL` severity and expression-defined
+// severity e.g. `LOG(LEVEL(HowBadIsIt()))`.  Like `LogMessage`, it terminates
+// the process when destroyed if the passed-in severity equals `FATAL`.
+class NullStreamMaybeFatal final : public NullStream {
+ public:
+  explicit NullStreamMaybeFatal(absl::LogSeverity severity)
+      : fatal_(severity == absl::LogSeverity::kFatal) {}
+  ~NullStreamMaybeFatal() {
+    if (fatal_) {
+      _exit(1);
+    }
+  }
+
+ private:
+  bool fatal_;
+};
+
+// `NullStreamFatal` implements the process termination semantics of
+// `LogMessageFatal`, which means it always terminates the process.  `DFATAL`
+// and expression-defined severity use `NullStreamMaybeFatal` above.
+class NullStreamFatal final : public NullStream {
+ public:
+  NullStreamFatal() = default;
+  // ABSL_ATTRIBUTE_NORETURN doesn't seem to work on destructors with msvc, so
+  // disable msvc's warning about the d'tor never returning.
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma warning(push)
+#pragma warning(disable : 4722)
+#endif
+  ABSL_ATTRIBUTE_NORETURN ~NullStreamFatal() { _exit(1); }
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma warning(pop)
+#endif
+};
+
+}  // namespace log_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_LOG_INTERNAL_GLOBALS_H_

data/third_party/abseil-cpp/absl/log/internal/proto.cc

@@ -0,0 +1,220 @@
+// Copyright 2020 The Abseil 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
+//
+//      https://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 "absl/log/internal/proto.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+namespace {
+void EncodeRawVarint(uint64_t value, size_t size, absl::Span<char> *buf) {
+  for (size_t s = 0; s < size; s++) {
+    (*buf)[s] = static_cast<char>((value & 0x7f) | (s + 1 == size ? 0 : 0x80));
+    value >>= 7;
+  }
+  buf->remove_prefix(size);
+}
+constexpr uint64_t MakeTagType(uint64_t tag, WireType type) {
+  return tag << 3 | static_cast<uint64_t>(type);
+}
+}  // namespace
+
+bool EncodeVarint(uint64_t tag, uint64_t value, absl::Span<char> *buf) {
+  const uint64_t tag_type = MakeTagType(tag, WireType::kVarint);
+  const size_t tag_type_size = VarintSize(tag_type);
+  const size_t value_size = VarintSize(value);
+  if (tag_type_size + value_size > buf->size()) {
+    buf->remove_suffix(buf->size());
+    return false;
+  }
+  EncodeRawVarint(tag_type, tag_type_size, buf);
+  EncodeRawVarint(value, value_size, buf);
+  return true;
+}
+
+bool Encode64Bit(uint64_t tag, uint64_t value, absl::Span<char> *buf) {
+  const uint64_t tag_type = MakeTagType(tag, WireType::k64Bit);
+  const size_t tag_type_size = VarintSize(tag_type);
+  if (tag_type_size + sizeof(value) > buf->size()) {
+    buf->remove_suffix(buf->size());
+    return false;
+  }
+  EncodeRawVarint(tag_type, tag_type_size, buf);
+  for (size_t s = 0; s < sizeof(value); s++) {
+    (*buf)[s] = static_cast<char>(value & 0xff);
+    value >>= 8;
+  }
+  buf->remove_prefix(sizeof(value));
+  return true;
+}
+
+bool Encode32Bit(uint64_t tag, uint32_t value, absl::Span<char> *buf) {
+  const uint64_t tag_type = MakeTagType(tag, WireType::k32Bit);
+  const size_t tag_type_size = VarintSize(tag_type);
+  if (tag_type_size + sizeof(value) > buf->size()) {
+    buf->remove_suffix(buf->size());
+    return false;
+  }
+  EncodeRawVarint(tag_type, tag_type_size, buf);
+  for (size_t s = 0; s < sizeof(value); s++) {
+    (*buf)[s] = static_cast<char>(value & 0xff);
+    value >>= 8;
+  }
+  buf->remove_prefix(sizeof(value));
+  return true;
+}
+
+bool EncodeBytes(uint64_t tag, absl::Span<const char> value,
+                 absl::Span<char> *buf) {
+  const uint64_t tag_type = MakeTagType(tag, WireType::kLengthDelimited);
+  const size_t tag_type_size = VarintSize(tag_type);
+  uint64_t length = value.size();
+  const size_t length_size = VarintSize(length);
+  if (tag_type_size + length_size + value.size() > buf->size()) {
+    buf->remove_suffix(buf->size());
+    return false;
+  }
+  EncodeRawVarint(tag_type, tag_type_size, buf);
+  EncodeRawVarint(length, length_size, buf);
+  memcpy(buf->data(), value.data(), value.size());
+  buf->remove_prefix(value.size());
+  return true;
+}
+
+bool EncodeBytesTruncate(uint64_t tag, absl::Span<const char> value,
+                         absl::Span<char> *buf) {
+  const uint64_t tag_type = MakeTagType(tag, WireType::kLengthDelimited);
+  const size_t tag_type_size = VarintSize(tag_type);
+  uint64_t length = value.size();
+  const size_t length_size =
+      VarintSize(std::min<uint64_t>(length, buf->size()));
+  if (tag_type_size + length_size <= buf->size() &&
+      tag_type_size + length_size + value.size() > buf->size()) {
+    value.remove_suffix(tag_type_size + length_size + value.size() -
+                        buf->size());
+    length = value.size();
+  }
+  if (tag_type_size + length_size + value.size() > buf->size()) {
+    buf->remove_suffix(buf->size());
+    return false;
+  }
+  EncodeRawVarint(tag_type, tag_type_size, buf);
+  EncodeRawVarint(length, length_size, buf);
+  memcpy(buf->data(), value.data(), value.size());
+  buf->remove_prefix(value.size());
+  return true;
+}
+
+ABSL_MUST_USE_RESULT absl::Span<char> EncodeMessageStart(
+    uint64_t tag, uint64_t max_size, absl::Span<char> *buf) {
+  const uint64_t tag_type = MakeTagType(tag, WireType::kLengthDelimited);
+  const size_t tag_type_size = VarintSize(tag_type);
+  max_size = std::min<uint64_t>(max_size, buf->size());
+  const size_t length_size = VarintSize(max_size);
+  if (tag_type_size + length_size > buf->size()) {
+    buf->remove_suffix(buf->size());
+    return absl::Span<char>();
+  }
+  EncodeRawVarint(tag_type, tag_type_size, buf);
+  const absl::Span<char> ret = buf->subspan(0, length_size);
+  EncodeRawVarint(0, length_size, buf);
+  return ret;
+}
+
+void EncodeMessageLength(absl::Span<char> msg, const absl::Span<char> *buf) {
+  if (!msg.data()) return;
+  assert(buf->data() >= msg.data());
+  if (buf->data() < msg.data()) return;
+  EncodeRawVarint(
+      static_cast<uint64_t>(buf->data() - (msg.data() + msg.size())),
+      msg.size(), &msg);
+}
+
+namespace {
+uint64_t DecodeVarint(absl::Span<const char> *buf) {
+  uint64_t value = 0;
+  size_t s = 0;
+  while (s < buf->size()) {
+    value |= static_cast<uint64_t>(static_cast<unsigned char>((*buf)[s]) & 0x7f)
+             << 7 * s;
+    if (!((*buf)[s++] & 0x80)) break;
+  }
+  buf->remove_prefix(s);
+  return value;
+}
+
+uint64_t Decode64Bit(absl::Span<const char> *buf) {
+  uint64_t value = 0;
+  size_t s = 0;
+  while (s < buf->size()) {
+    value |= static_cast<uint64_t>(static_cast<unsigned char>((*buf)[s]))
+             << 8 * s;
+    if (++s == sizeof(value)) break;
+  }
+  buf->remove_prefix(s);
+  return value;
+}
+
+uint32_t Decode32Bit(absl::Span<const char> *buf) {
+  uint32_t value = 0;
+  size_t s = 0;
+  while (s < buf->size()) {
+    value |= static_cast<uint32_t>(static_cast<unsigned char>((*buf)[s]))
+             << 8 * s;
+    if (++s == sizeof(value)) break;
+  }
+  buf->remove_prefix(s);
+  return value;
+}
+}  // namespace
+
+bool ProtoField::DecodeFrom(absl::Span<const char> *data) {
+  if (data->empty()) return false;
+  const uint64_t tag_type = DecodeVarint(data);
+  tag_ = tag_type >> 3;
+  type_ = static_cast<WireType>(tag_type & 0x07);
+  switch (type_) {
+    case WireType::kVarint:
+      value_ = DecodeVarint(data);
+      break;
+    case WireType::k64Bit:
+      value_ = Decode64Bit(data);
+      break;
+    case WireType::kLengthDelimited: {
+      value_ = DecodeVarint(data);
+      data_ = data->subspan(
+          0, static_cast<size_t>(std::min<uint64_t>(value_, data->size())));
+      data->remove_prefix(data_.size());
+      break;
+    }
+    case WireType::k32Bit:
+      value_ = Decode32Bit(data);
+      break;
+  }
+  return true;
+}
+
+}  // namespace log_internal
+ABSL_NAMESPACE_END
+}  // namespace absl