grpc 1.30.1 → 1.40.0

data/src/core/lib/security/transport/target_authority_table.cc

@@ -1,75 +0,0 @@
-/*
- *
- * Copyright 2017 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 <grpc/support/log.h>
-
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/security/transport/target_authority_table.h"
-
-// Channel arg key for the mapping of target addresses to their authorities.
-#define GRPC_ARG_TARGET_AUTHORITY_TABLE "grpc.target_authority_table"
-
-namespace grpc_core {
-namespace {
-
-void* target_authority_table_copy(void* p) {
-  TargetAuthorityTable* table = static_cast<TargetAuthorityTable*>(p);
-  // TODO(roth): When channel_args are converted to C++, pass the
-  // RefCountedPtr<> directly instead of managing the ref manually.
-  table->Ref().release();
-  return p;
-}
-void target_authority_table_destroy(void* p) {
-  TargetAuthorityTable* table = static_cast<TargetAuthorityTable*>(p);
-  table->Unref();
-}
-int target_authority_table_cmp(void* a, void* b) {
-  return TargetAuthorityTable::Cmp(
-      *static_cast<const TargetAuthorityTable*>(a),
-      *static_cast<const TargetAuthorityTable*>(b));
-}
-const grpc_arg_pointer_vtable target_authority_table_arg_vtable = {
-    target_authority_table_copy, target_authority_table_destroy,
-    target_authority_table_cmp};
-
-}  // namespace
-
-grpc_arg CreateTargetAuthorityTableChannelArg(TargetAuthorityTable* table) {
-  return grpc_channel_arg_pointer_create((char*)GRPC_ARG_TARGET_AUTHORITY_TABLE,
-                                         table,
-                                         &target_authority_table_arg_vtable);
-}
-
-TargetAuthorityTable* FindTargetAuthorityTableInArgs(
-    const grpc_channel_args* args) {
-  const grpc_arg* arg =
-      grpc_channel_args_find(args, GRPC_ARG_TARGET_AUTHORITY_TABLE);
-  if (arg != nullptr) {
-    if (arg->type == GRPC_ARG_POINTER) {
-      return static_cast<TargetAuthorityTable*>(arg->value.pointer.p);
-    } else {
-      gpr_log(GPR_ERROR, "value of " GRPC_ARG_TARGET_AUTHORITY_TABLE
-                         " channel arg was not pointer type; ignoring");
-    }
-  }
-  return nullptr;
-}
-
-}  // namespace grpc_core

data/src/core/lib/security/transport/target_authority_table.h

@@ -1,40 +0,0 @@
-/*
- *
- * Copyright 2017 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_CORE_LIB_SECURITY_TRANSPORT_TARGET_AUTHORITY_TABLE_H
-#define GRPC_CORE_LIB_SECURITY_TRANSPORT_TARGET_AUTHORITY_TABLE_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/slice/slice_hash_table.h"
-
-namespace grpc_core {
-
-/// A hash table mapping target addresses to authorities.
-typedef SliceHashTable<grpc_core::UniquePtr<char>> TargetAuthorityTable;
-
-/// Returns a channel argument containing \a table.
-grpc_arg CreateTargetAuthorityTableChannelArg(TargetAuthorityTable* table);
-
-/// Returns the target authority table from \a args or nullptr.
-TargetAuthorityTable* FindTargetAuthorityTableInArgs(
-    const grpc_channel_args* args);
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_SECURITY_TRANSPORT_TARGET_AUTHORITY_TABLE_H */

data/src/core/lib/slice/slice_hash_table.h

@@ -1,199 +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_CORE_LIB_SLICE_SLICE_HASH_TABLE_H
-#define GRPC_CORE_LIB_SLICE_SLICE_HASH_TABLE_H
-
-#include <grpc/support/port_platform.h>
-
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/slice/slice_internal.h"
-
-/// Hash table implementation.
-///
-/// This implementation uses open addressing
-/// (https://en.wikipedia.org/wiki/Open_addressing) with linear
-/// probing (https://en.wikipedia.org/wiki/Linear_probing).
-///
-/// The keys are \a grpc_slice objects.  The values can be any type.
-///
-/// Hash tables are intentionally immutable, to avoid the need for locking.
-
-namespace grpc_core {
-
-template <typename T>
-class SliceHashTable : public RefCounted<SliceHashTable<T>> {
- public:
-  struct Entry {
-    grpc_slice key;
-    T value;
-    bool is_set;
-  };
-
-  // Function for comparing values.
-  // TODO(roth): Eliminate this and the Cmp() method from this API once
-  // grpc_channel_args is redesigned to require that keys are unique.
-  typedef int (*ValueCmp)(const T&, const T&);
-
-  /// Creates a new hash table containing \a entries, which is an array
-  /// of length \a num_entries.  Takes ownership of all keys and values in \a
-  /// entries.  If not null, \a value_cmp will be used to compare values in
-  /// the context of \a Cmp(). If null, raw pointer (\a GPR_ICMP) comparison
-  /// will be used.
-  static RefCountedPtr<SliceHashTable> Create(size_t num_entries,
-                                              Entry* entries,
-                                              ValueCmp value_cmp);
-
-  // Use Create function instead of using this directly.
-  SliceHashTable(size_t num_entries, Entry* entries, ValueCmp value_cmp);
-  virtual ~SliceHashTable();
-
-  /// Returns the value from the table associated with \a key.
-  /// Returns null if \a key is not found.
-  const T* Get(const grpc_slice& key) const;
-
-  /// Compares \a a vs. \a b.
-  /// A table is considered "smaller" (resp. "greater") if:
-  ///  - GPR_ICMP(a->value_cmp, b->value_cmp) < 1 (resp. > 1),
-  ///  - else, it contains fewer (resp. more) entries,
-  ///  - else, if strcmp(a_key, b_key) < 1 (resp. > 1),
-  ///  - else, if value_cmp(a_value, b_value) < 1 (resp. > 1).
-  static int Cmp(const SliceHashTable& a, const SliceHashTable& b);
-
- private:
-  void Add(const grpc_slice& key, T& value);
-
-  // Default value comparison function, if none specified by caller.
-  static int DefaultValueCmp(const T& a, const T& b) { return GPR_ICMP(a, b); }
-
-  const ValueCmp value_cmp_;
-  const size_t size_;
-  size_t max_num_probes_;
-  Entry* entries_;
-};
-
-//
-// implementation -- no user-serviceable parts below
-//
-
-template <typename T>
-RefCountedPtr<SliceHashTable<T>> SliceHashTable<T>::Create(size_t num_entries,
-                                                           Entry* entries,
-                                                           ValueCmp value_cmp) {
-  return MakeRefCounted<SliceHashTable<T>>(num_entries, entries, value_cmp);
-}
-
-template <typename T>
-SliceHashTable<T>::SliceHashTable(size_t num_entries, Entry* entries,
-                                  ValueCmp value_cmp)
-    : value_cmp_(value_cmp),
-      // Keep load factor low to improve performance of lookups.
-      size_(num_entries * 2),
-      max_num_probes_(0) {
-  entries_ = static_cast<Entry*>(gpr_zalloc(sizeof(Entry) * size_));
-  for (size_t i = 0; i < num_entries; ++i) {
-    Entry* entry = &entries[i];
-    Add(entry->key, entry->value);
-  }
-}
-
-template <typename T>
-SliceHashTable<T>::~SliceHashTable() {
-  for (size_t i = 0; i < size_; ++i) {
-    Entry& entry = entries_[i];
-    if (entry.is_set) {
-      grpc_slice_unref_internal(entry.key);
-      entry.value.~T();
-    }
-  }
-  gpr_free(entries_);
-}
-
-template <typename T>
-void SliceHashTable<T>::Add(const grpc_slice& key, T& value) {
-  const size_t hash = grpc_slice_hash_internal(key);
-  for (size_t offset = 0; offset < size_; ++offset) {
-    const size_t idx = (hash + offset) % size_;
-    if (!entries_[idx].is_set) {
-      entries_[idx].is_set = true;
-      entries_[idx].key = key;
-      entries_[idx].value = std::move(value);
-      // Keep track of the maximum number of probes needed, since this
-      // provides an upper bound for lookups.
-      if (offset > max_num_probes_) max_num_probes_ = offset;
-      return;
-    }
-  }
-  GPR_ASSERT(false);  // Table should never be full.
-}
-
-template <typename T>
-const T* SliceHashTable<T>::Get(const grpc_slice& key) const {
-  const size_t hash = grpc_slice_hash_internal(key);
-  // We cap the number of probes at the max number recorded when
-  // populating the table.
-  for (size_t offset = 0; offset <= max_num_probes_; ++offset) {
-    const size_t idx = (hash + offset) % size_;
-    if (!entries_[idx].is_set) break;
-    if (grpc_slice_eq(entries_[idx].key, key)) {
-      return &entries_[idx].value;
-    }
-  }
-  return nullptr;  // Not found.
-}
-
-template <typename T>
-int SliceHashTable<T>::Cmp(const SliceHashTable& a, const SliceHashTable& b) {
-  ValueCmp value_cmp_a =
-      a.value_cmp_ != nullptr ? a.value_cmp_ : DefaultValueCmp;
-  ValueCmp value_cmp_b =
-      b.value_cmp_ != nullptr ? b.value_cmp_ : DefaultValueCmp;
-  // Compare value_fns
-  const int value_fns_cmp = GPR_ICMP((void*)value_cmp_a, (void*)value_cmp_b);
-  if (value_fns_cmp != 0) return value_fns_cmp;
-  // Compare sizes
-  if (a.size_ < b.size_) return -1;
-  if (a.size_ > b.size_) return 1;
-  // Compare rows.
-  for (size_t i = 0; i < a.size_; ++i) {
-    if (!a.entries_[i].is_set) {
-      if (b.entries_[i].is_set) {
-        return -1;  // a empty but b non-empty
-      }
-      continue;  // both empty, no need to check key or value
-    } else if (!b.entries_[i].is_set) {
-      return 1;  // a non-empty but b empty
-    }
-    // neither entry is empty
-    const int key_cmp = grpc_slice_cmp(a.entries_[i].key, b.entries_[i].key);
-    if (key_cmp != 0) return key_cmp;
-    const int value_cmp = value_cmp_a(a.entries_[i].value, b.entries_[i].value);
-    if (value_cmp != 0) return value_cmp;
-  }
-  return 0;
-}
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_SLICE_SLICE_HASH_TABLE_H */

data/src/core/lib/slice/slice_weak_hash_table.h

@@ -1,102 +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_CORE_LIB_SLICE_SLICE_WEAK_HASH_TABLE_H
-#define GRPC_CORE_LIB_SLICE_SLICE_WEAK_HASH_TABLE_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/slice/slice_internal.h"
-
-/// Weak hash table implementation.
-///
-/// This entries in this table are weak: an entry may be removed at any time due
-/// to a number of reasons: memory pressure, hash collisions, etc.
-///
-/// The keys are \a grpc_slice objects. The values are of arbitrary type.
-///
-/// This class is thread unsafe. It's the caller's responsibility to ensure
-/// proper locking when accessing its methods.
-
-namespace grpc_core {
-
-template <typename T, size_t Size>
-class SliceWeakHashTable : public RefCounted<SliceWeakHashTable<T, Size>> {
- public:
-  /// Creates a new table of at most \a size entries.
-  static RefCountedPtr<SliceWeakHashTable> Create() {
-    return MakeRefCounted<SliceWeakHashTable<T, Size>>();
-  }
-
-  /// Use Create function instead of using this directly.
-  SliceWeakHashTable() = default;
-  ~SliceWeakHashTable() = default;
-
-  /// Add a mapping from \a key to \a value, taking ownership of \a key. This
-  /// operation will always succeed. It may discard older entries.
-  void Add(const grpc_slice& key, T value) {
-    const size_t idx = grpc_slice_hash_internal(key) % Size;
-    entries_[idx].Set(key, std::move(value));
-    return;
-  }
-
-  /// Returns the value from the table associated with / \a key or null if not
-  /// found.
-  const T* Get(const grpc_slice& key) const {
-    const size_t idx = grpc_slice_hash_internal(key) % Size;
-    const auto& entry = entries_[idx];
-    return grpc_slice_eq(entry.key(), key) ? entry.value() : nullptr;
-  }
-
- private:
-  /// The type of the table "rows".
-  class Entry {
-   public:
-    Entry() = default;
-    ~Entry() {
-      if (is_set_) grpc_slice_unref_internal(key_);
-    }
-    const grpc_slice& key() const { return key_; }
-
-    /// Return the entry's value, or null if unset.
-    const T* value() const {
-      if (!is_set_) return nullptr;
-      return &value_;
-    }
-
-    /// Set the \a key and \a value (which is moved) for the entry.
-    void Set(const grpc_slice& key, T&& value) {
-      if (is_set_) grpc_slice_unref_internal(key_);
-      key_ = key;
-      value_ = std::move(value);
-      is_set_ = true;
-    }
-
-   private:
-    grpc_slice key_;
-    T value_;
-    bool is_set_ = false;
-  };
-
-  Entry entries_[Size];
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_SLICE_SLICE_WEAK_HASH_TABLE_H */

data/third_party/abseil-cpp/absl/base/dynamic_annotations.cc

@@ -1,129 +0,0 @@
-// Copyright 2017 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 <stdlib.h>
-#include <string.h>
-
-#include "absl/base/dynamic_annotations.h"
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-/* Compiler-based ThreadSanitizer defines
-   DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL = 1
-   and provides its own definitions of the functions. */
-
-#ifndef DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL
-# define DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL 0
-#endif
-
-/* Each function is empty and called (via a macro) only in debug mode.
-   The arguments are captured by dynamic tools at runtime. */
-
-#if DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL == 0 && !defined(__native_client__)
-
-#if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void AnnotateRWLockCreate(const char *, int,
-                          const volatile void *){}
-void AnnotateRWLockDestroy(const char *, int,
-                           const volatile void *){}
-void AnnotateRWLockAcquired(const char *, int,
-                            const volatile void *, long){}
-void AnnotateRWLockReleased(const char *, int,
-                            const volatile void *, long){}
-void AnnotateBenignRace(const char *, int,
-                        const volatile void *,
-                        const char *){}
-void AnnotateBenignRaceSized(const char *, int,
-                             const volatile void *,
-                             size_t,
-                             const char *) {}
-void AnnotateThreadName(const char *, int,
-                        const char *){}
-void AnnotateIgnoreReadsBegin(const char *, int){}
-void AnnotateIgnoreReadsEnd(const char *, int){}
-void AnnotateIgnoreWritesBegin(const char *, int){}
-void AnnotateIgnoreWritesEnd(const char *, int){}
-void AnnotateEnableRaceDetection(const char *, int, int){}
-void AnnotateMemoryIsInitialized(const char *, int,
-                                 const volatile void *mem, size_t size) {
-#if __has_feature(memory_sanitizer)
-  __msan_unpoison(mem, size);
-#else
-  (void)mem;
-  (void)size;
-#endif
-}
-
-void AnnotateMemoryIsUninitialized(const char *, int,
-                                   const volatile void *mem, size_t size) {
-#if __has_feature(memory_sanitizer)
-  __msan_allocated_memory(mem, size);
-#else
-  (void)mem;
-  (void)size;
-#endif
-}
-
-static int GetRunningOnValgrind(void) {
-#ifdef RUNNING_ON_VALGRIND
-  if (RUNNING_ON_VALGRIND) return 1;
-#endif
-  char *running_on_valgrind_str = getenv("RUNNING_ON_VALGRIND");
-  if (running_on_valgrind_str) {
-    return strcmp(running_on_valgrind_str, "0") != 0;
-  }
-  return 0;
-}
-
-/* See the comments in dynamic_annotations.h */
-int RunningOnValgrind(void) {
-  static volatile int running_on_valgrind = -1;
-  int local_running_on_valgrind = running_on_valgrind;
-  /* C doesn't have thread-safe initialization of statics, and we
-     don't want to depend on pthread_once here, so hack it. */
-  ANNOTATE_BENIGN_RACE(&running_on_valgrind, "safe hack");
-  if (local_running_on_valgrind == -1)
-    running_on_valgrind = local_running_on_valgrind = GetRunningOnValgrind();
-  return local_running_on_valgrind;
-}
-
-/* See the comments in dynamic_annotations.h */
-double ValgrindSlowdown(void) {
-  /* Same initialization hack as in RunningOnValgrind(). */
-  static volatile double slowdown = 0.0;
-  double local_slowdown = slowdown;
-  ANNOTATE_BENIGN_RACE(&slowdown, "safe hack");
-  if (RunningOnValgrind() == 0) {
-    return 1.0;
-  }
-  if (local_slowdown == 0.0) {
-    char *env = getenv("VALGRIND_SLOWDOWN");
-    slowdown = local_slowdown = env ? atof(env) : 50.0;
-  }
-  return local_slowdown;
-}
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-#endif  /* DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL == 0 */