grpc 1.53.0.pre2 → 1.54.0

data/src/core/lib/transport/transport_op_string.cc

@@ -18,15 +18,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <algorithm>
 #include <initializer_list>
 #include <memory>
 #include <string>
-#include <vector>
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 
 #include <grpc/support/log.h>
 
@@ -44,105 +41,118 @@
 // representations of various transport data structures
 
 std::string grpc_transport_stream_op_batch_string(
-    grpc_transport_stream_op_batch* op) {
-  std::vector<std::string> out;
+    grpc_transport_stream_op_batch* op, bool truncate) {
+  std::string out;
 
   if (op->send_initial_metadata) {
-    out.push_back(" SEND_INITIAL_METADATA{");
-    out.push_back(op->payload->send_initial_metadata.send_initial_metadata
-                      ->DebugString());
-    out.push_back("}");
+    absl::StrAppend(&out, " SEND_INITIAL_METADATA{");
+    if (truncate) {
+      absl::StrAppend(&out, "Length=",
+                      op->payload->send_initial_metadata.send_initial_metadata
+                          ->TransportSize());
+    } else {
+      absl::StrAppend(&out, op->payload->send_initial_metadata
+                                .send_initial_metadata->DebugString());
+    }
+    absl::StrAppend(&out, "}");
   }
 
   if (op->send_message) {
     if (op->payload->send_message.send_message != nullptr) {
-      out.push_back(absl::StrFormat(
-          " SEND_MESSAGE:flags=0x%08x:len=%d", op->payload->send_message.flags,
-          op->payload->send_message.send_message->Length()));
+      absl::StrAppendFormat(&out, " SEND_MESSAGE:flags=0x%08x:len=%d",
+                            op->payload->send_message.flags,
+                            op->payload->send_message.send_message->Length());
     } else {
       // This can happen when we check a batch after the transport has
       // processed and cleared the send_message op.
-      out.push_back(" SEND_MESSAGE(flag and length unknown, already orphaned)");
+      absl::StrAppend(
+          &out, " SEND_MESSAGE(flag and length unknown, already orphaned)");
     }
   }
 
   if (op->send_trailing_metadata) {
-    out.push_back(" SEND_TRAILING_METADATA{");
-    out.push_back(op->payload->send_trailing_metadata.send_trailing_metadata
-                      ->DebugString());
-    out.push_back("}");
+    absl::StrAppend(&out, " SEND_TRAILING_METADATA{");
+    if (truncate) {
+      absl::StrAppend(&out, "Length=",
+                      op->payload->send_trailing_metadata
+                          .send_trailing_metadata->TransportSize());
+    } else {
+      absl::StrAppend(&out, op->payload->send_trailing_metadata
+                                .send_trailing_metadata->DebugString());
+    }
+    absl::StrAppend(&out, "}");
   }
 
   if (op->recv_initial_metadata) {
-    out.push_back(" RECV_INITIAL_METADATA");
+    absl::StrAppend(&out, " RECV_INITIAL_METADATA");
   }
 
   if (op->recv_message) {
-    out.push_back(" RECV_MESSAGE");
+    absl::StrAppend(&out, " RECV_MESSAGE");
   }
 
   if (op->recv_trailing_metadata) {
-    out.push_back(" RECV_TRAILING_METADATA");
+    absl::StrAppend(&out, " RECV_TRAILING_METADATA");
   }
 
   if (op->cancel_stream) {
-    out.push_back(absl::StrCat(
-        " CANCEL:",
-        grpc_core::StatusToString(op->payload->cancel_stream.cancel_error)));
+    absl::StrAppend(
+        &out, " CANCEL:",
+        grpc_core::StatusToString(op->payload->cancel_stream.cancel_error));
   }
 
-  return absl::StrJoin(out, "");
+  return out;
 }
 
 std::string grpc_transport_op_string(grpc_transport_op* op) {
-  std::vector<std::string> out;
+  std::string out;
 
   if (op->start_connectivity_watch != nullptr) {
-    out.push_back(absl::StrFormat(
-        " START_CONNECTIVITY_WATCH:watcher=%p:from=%s",
+    absl::StrAppendFormat(
+        &out, " START_CONNECTIVITY_WATCH:watcher=%p:from=%s",
         op->start_connectivity_watch.get(),
-        grpc_core::ConnectivityStateName(op->start_connectivity_watch_state)));
+        grpc_core::ConnectivityStateName(op->start_connectivity_watch_state));
   }
 
   if (op->stop_connectivity_watch != nullptr) {
-    out.push_back(absl::StrFormat(" STOP_CONNECTIVITY_WATCH:watcher=%p",
-                                  op->stop_connectivity_watch));
+    absl::StrAppendFormat(&out, " STOP_CONNECTIVITY_WATCH:watcher=%p",
+                          op->stop_connectivity_watch);
   }
 
   if (!op->disconnect_with_error.ok()) {
-    out.push_back(absl::StrCat(
-        " DISCONNECT:", grpc_core::StatusToString(op->disconnect_with_error)));
+    absl::StrAppend(&out, " DISCONNECT:",
+                    grpc_core::StatusToString(op->disconnect_with_error));
   }
 
   if (!op->goaway_error.ok()) {
-    out.push_back(absl::StrCat(" SEND_GOAWAY:",
-                               grpc_core::StatusToString(op->goaway_error)));
+    absl::StrAppend(
+        &out, " SEND_GOAWAY:", grpc_core::StatusToString(op->goaway_error));
   }
 
   if (op->set_accept_stream) {
-    out.push_back(absl::StrFormat(" SET_ACCEPT_STREAM:%p(%p,...)",
-                                  op->set_accept_stream_fn,
-                                  op->set_accept_stream_user_data));
+    absl::StrAppendFormat(&out, " SET_ACCEPT_STREAM:%p(%p,...)",
+                          op->set_accept_stream_fn,
+                          op->set_accept_stream_user_data);
   }
 
   if (op->bind_pollset != nullptr) {
-    out.push_back(" BIND_POLLSET");
+    absl::StrAppend(&out, " BIND_POLLSET");
   }
 
   if (op->bind_pollset_set != nullptr) {
-    out.push_back(" BIND_POLLSET_SET");
+    absl::StrAppend(&out, " BIND_POLLSET_SET");
   }
 
   if (op->send_ping.on_initiate != nullptr || op->send_ping.on_ack != nullptr) {
-    out.push_back(" SEND_PING");
+    absl::StrAppend(&out, " SEND_PING");
   }
 
-  return absl::StrJoin(out, "");
+  return out;
 }
 
 void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
                       grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op) {
   gpr_log(file, line, severity, "OP[%s:%p]: %s", elem->filter->name, elem,
-          grpc_transport_stream_op_batch_string(op).c_str());
+          grpc_transport_stream_op_batch_string(op, false).c_str());
 }

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -76,8 +76,8 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   grpc_event_engine::experimental::RegisterEventEngineChannelArgPreconditioning(
       builder);
   // The order of the handshaker registration is crucial here.
-  // We want TCP connect handshaker to be registered last so that it is added to
-  // the start of the handshaker list.
+  // We want TCP connect handshaker to be registered last so that it is added
+  // to the start of the handshaker list.
   RegisterHttpConnectHandshaker(builder);
   RegisterTCPConnectHandshaker(builder);
   RegisterPriorityLbPolicy(builder);

data/src/core/tsi/alts/frame_protector/alts_frame_protector.cc

@@ -30,6 +30,7 @@
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/memory.h"
 #include "src/core/tsi/alts/crypt/gsec.h"
 #include "src/core/tsi/alts/frame_protector/alts_crypter.h"
 #include "src/core/tsi/alts/frame_protector/frame_handler.h"

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -22,6 +22,7 @@
 
 #include <list>
 
+#include "absl/strings/numbers.h"
 #include "upb/upb.hpp"
 
 #include <grpc/byte_buffer.h>
@@ -29,6 +30,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
@@ -40,6 +42,8 @@
 #define TSI_ALTS_INITIAL_BUFFER_SIZE 256
 
 const int kHandshakerClientOpNum = 4;
+const char kMaxConcurrentStreamsEnvironmentVariable[] =
+    "GRPC_ALTS_MAX_CONCURRENT_HANDSHAKES";
 
 struct alts_handshaker_client {
   const alts_handshaker_client_vtable* vtable;
@@ -419,7 +423,8 @@ HandshakeQueue* g_client_handshake_queue;
 HandshakeQueue* g_server_handshake_queue;
 
 void DoHandshakeQueuesInit(void) {
-  const size_t per_queue_max_outstanding_handshakes = 40;
+  const size_t per_queue_max_outstanding_handshakes =
+      MaxNumberOfConcurrentHandshakes();
   g_client_handshake_queue =
       new HandshakeQueue(per_queue_max_outstanding_handshakes);
   g_server_handshake_queue =
@@ -733,16 +738,14 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
   client->handshake_status_details = grpc_empty_slice();
   client->max_frame_size = max_frame_size;
   client->error = error;
-  grpc_slice slice = grpc_slice_from_copied_string(handshaker_service_url);
   client->call =
       strcmp(handshaker_service_url, ALTS_HANDSHAKER_SERVICE_URL_FOR_TESTING) ==
               0
           ? nullptr
           : grpc_channel_create_pollset_set_call(
                 channel, nullptr, GRPC_PROPAGATE_DEFAULTS, interested_parties,
-                grpc_slice_from_static_string(ALTS_SERVICE_METHOD), &slice,
+                grpc_slice_from_static_string(ALTS_SERVICE_METHOD), nullptr,
                 grpc_core::Timestamp::InfFuture(), nullptr);
-  grpc_core::CSliceUnref(slice);
   GRPC_CLOSURE_INIT(&client->on_handshaker_service_resp_recv, grpc_cb, client,
                     grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&client->on_status_received, on_status_received, client,
@@ -926,3 +929,17 @@ void alts_handshaker_client_destroy(alts_handshaker_client* c) {
     alts_grpc_handshaker_client_unref(client);
   }
 }
+
+size_t MaxNumberOfConcurrentHandshakes() {
+  size_t max_concurrent_handshakes = 40;
+  absl::optional<std::string> env_var_max_concurrent_handshakes =
+      grpc_core::GetEnv(kMaxConcurrentStreamsEnvironmentVariable);
+  if (env_var_max_concurrent_handshakes.has_value()) {
+    size_t effective_max_concurrent_handshakes = 40;
+    if (absl::SimpleAtoi(*env_var_max_concurrent_handshakes,
+                         &effective_max_concurrent_handshakes)) {
+      max_concurrent_handshakes = effective_max_concurrent_handshakes;
+    }
+  }
+  return max_concurrent_handshakes;
+}

data/src/core/tsi/alts/handshaker/alts_handshaker_client.h

@@ -157,4 +157,9 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
 void alts_handshaker_client_handle_response(alts_handshaker_client* client,
                                             bool is_ok);
 
+// Returns the max number of concurrent handshakes that are permitted.
+//
+// Exposed for testing purposes only.
+size_t MaxNumberOfConcurrentHandshakes();
+
 #endif  // GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -351,7 +351,7 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Null peer identity in ALTS context.");
     return TSI_FAILED_PRECONDITION;
   }
-  if (grpc_gcp_Identity_has_attributes(identity)) {
+  if (grpc_gcp_Identity_attributes_size(identity) != 0) {
     size_t iter = kUpb_Map_Begin;
     grpc_gcp_Identity_AttributesEntry* peer_attributes_entry =
         grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);

data/src/core/tsi/ssl_transport_security.cc

@@ -2060,7 +2060,8 @@ tsi_result tsi_create_ssl_client_handshaker_factory_with_options(
       gpr_log(GPR_ERROR, "Failed to load CRL File from directory.");
     } else {
       X509_VERIFY_PARAM* param = X509_STORE_get0_param(cert_store);
-      X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
+      X509_VERIFY_PARAM_set_flags(
+          param, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
       gpr_log(GPR_INFO, "enabled client side CRL checking.");
     }
   }
@@ -2244,7 +2245,8 @@ tsi_result tsi_create_ssl_server_handshaker_factory_with_options(
           gpr_log(GPR_ERROR, "Failed to load CRL File from directory.");
         } else {
           X509_VERIFY_PARAM* param = X509_STORE_get0_param(cert_store);
-          X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
+          X509_VERIFY_PARAM_set_flags(
+              param, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
           gpr_log(GPR_INFO, "enabled server CRL checking.");
         }
       }

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.53.0.pre2'
+  VERSION = '1.54.0'
 end

data/third_party/abseil-cpp/absl/base/config.h

@@ -112,7 +112,7 @@
 // LTS releases can be obtained from
 // https://github.com/abseil/abseil-cpp/releases.
 #define ABSL_LTS_RELEASE_VERSION 20230125
-#define ABSL_LTS_RELEASE_PATCH_LEVEL 0
+#define ABSL_LTS_RELEASE_PATCH_LEVEL 2
 
 // Helper macro to convert a CPP variable to a string literal.
 #define ABSL_INTERNAL_DO_TOKEN_STR(x) #x

data/third_party/abseil-cpp/absl/flags/commandlineflag.cc

@@ -0,0 +1,34 @@
+//
+// 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/flags/commandlineflag.h"
+
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/flags/internal/commandlineflag.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+bool CommandLineFlag::IsRetired() const { return false; }
+bool CommandLineFlag::ParseFrom(absl::string_view value, std::string* error) {
+  return ParseFrom(value, flags_internal::SET_FLAGS_VALUE,
+                   flags_internal::kProgrammaticChange, *error);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl

data/third_party/abseil-cpp/absl/flags/commandlineflag.h

@@ -0,0 +1,200 @@
+//
+// 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.
+//
+// -----------------------------------------------------------------------------
+// File: commandlineflag.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `CommandLineFlag`, which acts as a type-erased
+// handle for accessing metadata about the Abseil Flag in question.
+//
+// Because an actual Abseil flag is of an unspecified type, you should not
+// manipulate or interact directly with objects of that type. Instead, use the
+// CommandLineFlag type as an intermediary.
+#ifndef ABSL_FLAGS_COMMANDLINEFLAG_H_
+#define ABSL_FLAGS_COMMANDLINEFLAG_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/fast_type_id.h"
+#include "absl/flags/internal/commandlineflag.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+class PrivateHandleAccessor;
+}  // namespace flags_internal
+
+// CommandLineFlag
+//
+// This type acts as a type-erased handle for an instance of an Abseil Flag and
+// holds reflection information pertaining to that flag. Use CommandLineFlag to
+// access a flag's name, location, help string etc.
+//
+// To obtain an absl::CommandLineFlag, invoke `absl::FindCommandLineFlag()`
+// passing it the flag name string.
+//
+// Example:
+//
+//   // Obtain reflection handle for a flag named "flagname".
+//   const absl::CommandLineFlag* my_flag_data =
+//        absl::FindCommandLineFlag("flagname");
+//
+//   // Now you can get flag info from that reflection handle.
+//   std::string flag_location = my_flag_data->Filename();
+//   ...
+class CommandLineFlag {
+ public:
+  constexpr CommandLineFlag() = default;
+
+  // Not copyable/assignable.
+  CommandLineFlag(const CommandLineFlag&) = delete;
+  CommandLineFlag& operator=(const CommandLineFlag&) = delete;
+
+  // absl::CommandLineFlag::IsOfType()
+  //
+  // Return true iff flag has type T.
+  template <typename T>
+  inline bool IsOfType() const {
+    return TypeId() == base_internal::FastTypeId<T>();
+  }
+
+  // absl::CommandLineFlag::TryGet()
+  //
+  // Attempts to retrieve the flag value. Returns value on success,
+  // absl::nullopt otherwise.
+  template <typename T>
+  absl::optional<T> TryGet() const {
+    if (IsRetired() || !IsOfType<T>()) {
+      return absl::nullopt;
+    }
+
+    // Implementation notes:
+    //
+    // We are wrapping a union around the value of `T` to serve three purposes:
+    //
+    //  1. `U.value` has correct size and alignment for a value of type `T`
+    //  2. The `U.value` constructor is not invoked since U's constructor does
+    //     not do it explicitly.
+    //  3. The `U.value` destructor is invoked since U's destructor does it
+    //     explicitly. This makes `U` a kind of RAII wrapper around non default
+    //     constructible value of T, which is destructed when we leave the
+    //     scope. We do need to destroy U.value, which is constructed by
+    //     CommandLineFlag::Read even though we left it in a moved-from state
+    //     after std::move.
+    //
+    // All of this serves to avoid requiring `T` being default constructible.
+    union U {
+      T value;
+      U() {}
+      ~U() { value.~T(); }
+    };
+    U u;
+
+    Read(&u.value);
+    // allow retired flags to be "read", so we can report invalid access.
+    if (IsRetired()) {
+      return absl::nullopt;
+    }
+    return std::move(u.value);
+  }
+
+  // absl::CommandLineFlag::Name()
+  //
+  // Returns name of this flag.
+  virtual absl::string_view Name() const = 0;
+
+  // absl::CommandLineFlag::Filename()
+  //
+  // Returns name of the file where this flag is defined.
+  virtual std::string Filename() const = 0;
+
+  // absl::CommandLineFlag::Help()
+  //
+  // Returns help message associated with this flag.
+  virtual std::string Help() const = 0;
+
+  // absl::CommandLineFlag::IsRetired()
+  //
+  // Returns true iff this object corresponds to retired flag.
+  virtual bool IsRetired() const;
+
+  // absl::CommandLineFlag::DefaultValue()
+  //
+  // Returns the default value for this flag.
+  virtual std::string DefaultValue() const = 0;
+
+  // absl::CommandLineFlag::CurrentValue()
+  //
+  // Returns the current value for this flag.
+  virtual std::string CurrentValue() const = 0;
+
+  // absl::CommandLineFlag::ParseFrom()
+  //
+  // Sets the value of the flag based on specified string `value`. If the flag
+  // was successfully set to new value, it returns true. Otherwise, sets `error`
+  // to indicate the error, leaves the flag unchanged, and returns false.
+  bool ParseFrom(absl::string_view value, std::string* error);
+
+ protected:
+  ~CommandLineFlag() = default;
+
+ private:
+  friend class flags_internal::PrivateHandleAccessor;
+
+  // Sets the value of the flag based on specified string `value`. If the flag
+  // was successfully set to new value, it returns true. Otherwise, sets `error`
+  // to indicate the error, leaves the flag unchanged, and returns false. There
+  // are three ways to set the flag's value:
+  //  * Update the current flag value
+  //  * Update the flag's default value
+  //  * Update the current flag value if it was never set before
+  // The mode is selected based on `set_mode` parameter.
+  virtual bool ParseFrom(absl::string_view value,
+                         flags_internal::FlagSettingMode set_mode,
+                         flags_internal::ValueSource source,
+                         std::string& error) = 0;
+
+  // Returns id of the flag's value type.
+  virtual flags_internal::FlagFastTypeId TypeId() const = 0;
+
+  // Interface to save flag to some persistent state. Returns current flag state
+  // or nullptr if flag does not support saving and restoring a state.
+  virtual std::unique_ptr<flags_internal::FlagStateInterface> SaveState() = 0;
+
+  // Copy-construct a new value of the flag's type in a memory referenced by
+  // the dst based on the current flag's value.
+  virtual void Read(void* dst) const = 0;
+
+  // To be deleted. Used to return true if flag's current value originated from
+  // command line.
+  virtual bool IsSpecifiedOnCommandLine() const = 0;
+
+  // Validates supplied value usign validator or parseflag routine
+  virtual bool ValidateInputValue(absl::string_view value) const = 0;
+
+  // Checks that flags default value can be converted to string and back to the
+  // flag's value type.
+  virtual void CheckDefaultValueParsingRoundtrip() const = 0;
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_COMMANDLINEFLAG_H_

data/third_party/abseil-cpp/absl/flags/config.h

@@ -0,0 +1,68 @@
+//
+//  Copyright 2019 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.
+
+#ifndef ABSL_FLAGS_CONFIG_H_
+#define ABSL_FLAGS_CONFIG_H_
+
+// Determine if we should strip string literals from the Flag objects.
+// By default we strip string literals on mobile platforms.
+#if !defined(ABSL_FLAGS_STRIP_NAMES)
+
+#if defined(__ANDROID__)
+#define ABSL_FLAGS_STRIP_NAMES 1
+
+#elif defined(__APPLE__)
+#include <TargetConditionals.h>
+#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+#define ABSL_FLAGS_STRIP_NAMES 1
+#elif defined(TARGET_OS_EMBEDDED) && TARGET_OS_EMBEDDED
+#define ABSL_FLAGS_STRIP_NAMES 1
+#endif  // TARGET_OS_*
+#endif
+
+#endif  // !defined(ABSL_FLAGS_STRIP_NAMES)
+
+#if !defined(ABSL_FLAGS_STRIP_NAMES)
+// If ABSL_FLAGS_STRIP_NAMES wasn't set on the command line or above,
+// the default is not to strip.
+#define ABSL_FLAGS_STRIP_NAMES 0
+#endif
+
+#if !defined(ABSL_FLAGS_STRIP_HELP)
+// By default, if we strip names, we also strip help.
+#define ABSL_FLAGS_STRIP_HELP ABSL_FLAGS_STRIP_NAMES
+#endif
+
+// These macros represent the "source of truth" for the list of supported
+// built-in types.
+#define ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A) \
+  A(bool, bool)                              \
+  A(short, short)                            \
+  A(unsigned short, unsigned_short)          \
+  A(int, int)                                \
+  A(unsigned int, unsigned_int)              \
+  A(long, long)                              \
+  A(unsigned long, unsigned_long)            \
+  A(long long, long_long)                    \
+  A(unsigned long long, unsigned_long_long)  \
+  A(double, double)                          \
+  A(float, float)
+
+#define ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(A) \
+  ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A)         \
+  A(std::string, std_string)                   \
+  A(std::vector<std::string>, std_vector_of_string)
+
+#endif  // ABSL_FLAGS_CONFIG_H_