grpc 1.27.0.pre1 → 1.30.1

data/src/core/lib/json/json_writer.cc

@@ -21,11 +21,17 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "absl/strings/string_view.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/json/json.h"
 
+namespace grpc_core {
+
+namespace {
+
 /* The idea of the writer is basically symmetrical of the reader. While the
  * reader emits various calls to your code, the writer takes basically the
  * same calls and emit json out of it. It doesn't try to make any check on
@@ -37,133 +43,130 @@
  * cut the conversion short, before any invalid UTF-8 sequence, thus forming
  * a valid UTF-8 string overall.
  */
+class JsonWriter {
+ public:
+  static std::string Dump(const Json& value, int indent);
+
+ private:
+  explicit JsonWriter(int indent) : indent_(indent) {}
+
+  void OutputCheck(size_t needed);
+  void OutputChar(char c);
+  void OutputString(const absl::string_view str);
+  void OutputIndent();
+  void ValueEnd();
+  void EscapeUtf16(uint16_t utf16);
+  void EscapeString(const std::string& string);
+  void ContainerBegins(Json::Type type);
+  void ContainerEnds(Json::Type type);
+  void ObjectKey(const std::string& string);
+  void ValueRaw(const std::string& string);
+  void ValueString(const std::string& string);
 
-typedef struct grpc_json_writer {
-  int indent;
-  int depth;
-  int container_empty;
-  int got_key;
-  char* output;
-  size_t free_space;
-  size_t string_len;
-  size_t allocated;
-} grpc_json_writer;
+  void DumpObject(const Json::Object& object);
+  void DumpArray(const Json::Array& array);
+  void DumpValue(const Json& value);
+
+  int indent_;
+  int depth_ = 0;
+  bool container_empty_ = true;
+  bool got_key_ = false;
+  std::string output_;
+};
 
 /* This function checks if there's enough space left in the output buffer,
  * and will enlarge it if necessary. We're only allocating chunks of 256
  * bytes at a time (or multiples thereof).
  */
-static void json_writer_output_check(grpc_json_writer* writer, size_t needed) {
-  if (writer->free_space >= needed) return;
-  needed -= writer->free_space;
+void JsonWriter::OutputCheck(size_t needed) {
+  size_t free_space = output_.capacity() - output_.size();
+  if (free_space >= needed) return;
+  needed -= free_space;
   /* Round up by 256 bytes. */
   needed = (needed + 0xff) & ~0xffU;
-  writer->output = static_cast<char*>(
-      gpr_realloc(writer->output, writer->allocated + needed));
-  writer->free_space += needed;
-  writer->allocated += needed;
-}
-
-static void json_writer_output_char(grpc_json_writer* writer, char c) {
-  json_writer_output_check(writer, 1);
-  writer->output[writer->string_len++] = c;
-  writer->free_space--;
+  output_.reserve(output_.capacity() + needed);
 }
 
-static void json_writer_output_string_with_len(grpc_json_writer* writer,
-                                               const char* str, size_t len) {
-  json_writer_output_check(writer, len);
-  memcpy(writer->output + writer->string_len, str, len);
-  writer->string_len += len;
-  writer->free_space -= len;
+void JsonWriter::OutputChar(char c) {
+  OutputCheck(1);
+  output_.push_back(c);
 }
 
-static void json_writer_output_string(grpc_json_writer* writer,
-                                      const char* str) {
-  size_t len = strlen(str);
-  json_writer_output_string_with_len(writer, str, len);
+void JsonWriter::OutputString(const absl::string_view str) {
+  OutputCheck(str.size());
+  output_.append(str.data(), str.size());
 }
 
-static void json_writer_output_indent(grpc_json_writer* writer) {
+void JsonWriter::OutputIndent() {
   static const char spacesstr[] =
       "                "
       "                "
       "                "
       "                ";
-
-  unsigned spaces = static_cast<unsigned>(writer->depth * writer->indent);
-
-  if (writer->indent == 0) return;
-
-  if (writer->got_key) {
-    json_writer_output_char(writer, ' ');
+  unsigned spaces = static_cast<unsigned>(depth_ * indent_);
+  if (indent_ == 0) return;
+  if (got_key_) {
+    OutputChar(' ');
     return;
   }
-
   while (spaces >= (sizeof(spacesstr) - 1)) {
-    json_writer_output_string_with_len(writer, spacesstr,
-                                       sizeof(spacesstr) - 1);
+    OutputString(absl::string_view(spacesstr, sizeof(spacesstr) - 1));
     spaces -= static_cast<unsigned>(sizeof(spacesstr) - 1);
   }
-
   if (spaces == 0) return;
-
-  json_writer_output_string_with_len(
-      writer, spacesstr + sizeof(spacesstr) - 1 - spaces, spaces);
+  OutputString(
+      absl::string_view(spacesstr + sizeof(spacesstr) - 1 - spaces, spaces));
 }
 
-static void json_writer_value_end(grpc_json_writer* writer) {
-  if (writer->container_empty) {
-    writer->container_empty = 0;
-    if ((writer->indent == 0) || (writer->depth == 0)) return;
-    json_writer_output_char(writer, '\n');
+void JsonWriter::ValueEnd() {
+  if (container_empty_) {
+    container_empty_ = false;
+    if (indent_ == 0 || depth_ == 0) return;
+    OutputChar('\n');
   } else {
-    json_writer_output_char(writer, ',');
-    if (writer->indent == 0) return;
-    json_writer_output_char(writer, '\n');
+    OutputChar(',');
+    if (indent_ == 0) return;
+    OutputChar('\n');
   }
 }
 
-static void json_writer_escape_utf16(grpc_json_writer* writer, uint16_t utf16) {
+void JsonWriter::EscapeUtf16(uint16_t utf16) {
   static const char hex[] = "0123456789abcdef";
-
-  json_writer_output_string_with_len(writer, "\\u", 2);
-  json_writer_output_char(writer, hex[(utf16 >> 12) & 0x0f]);
-  json_writer_output_char(writer, hex[(utf16 >> 8) & 0x0f]);
-  json_writer_output_char(writer, hex[(utf16 >> 4) & 0x0f]);
-  json_writer_output_char(writer, hex[(utf16)&0x0f]);
+  OutputString(absl::string_view("\\u", 2));
+  OutputChar(hex[(utf16 >> 12) & 0x0f]);
+  OutputChar(hex[(utf16 >> 8) & 0x0f]);
+  OutputChar(hex[(utf16 >> 4) & 0x0f]);
+  OutputChar(hex[(utf16)&0x0f]);
 }
 
-static void json_writer_escape_string(grpc_json_writer* writer,
-                                      const char* string) {
-  json_writer_output_char(writer, '"');
-
-  for (;;) {
-    uint8_t c = static_cast<uint8_t>(*string++);
+void JsonWriter::EscapeString(const std::string& string) {
+  OutputChar('"');
+  for (size_t idx = 0; idx < string.size(); ++idx) {
+    uint8_t c = static_cast<uint8_t>(string[idx]);
     if (c == 0) {
       break;
-    } else if ((c >= 32) && (c <= 126)) {
-      if ((c == '\\') || (c == '"')) json_writer_output_char(writer, '\\');
-      json_writer_output_char(writer, static_cast<char>(c));
-    } else if ((c < 32) || (c == 127)) {
+    } else if (c >= 32 && c <= 126) {
+      if (c == '\\' || c == '"') OutputChar('\\');
+      OutputChar(static_cast<char>(c));
+    } else if (c < 32 || c == 127) {
       switch (c) {
         case '\b':
-          json_writer_output_string_with_len(writer, "\\b", 2);
+          OutputString(absl::string_view("\\b", 2));
           break;
         case '\f':
-          json_writer_output_string_with_len(writer, "\\f", 2);
+          OutputString(absl::string_view("\\f", 2));
           break;
         case '\n':
-          json_writer_output_string_with_len(writer, "\\n", 2);
+          OutputString(absl::string_view("\\n", 2));
           break;
         case '\r':
-          json_writer_output_string_with_len(writer, "\\r", 2);
+          OutputString(absl::string_view("\\r", 2));
           break;
         case '\t':
-          json_writer_output_string_with_len(writer, "\\t", 2);
+          OutputString(absl::string_view("\\t", 2));
           break;
         default:
-          json_writer_escape_utf16(writer, c);
+          EscapeUtf16(c);
           break;
       }
     } else {
@@ -185,7 +188,13 @@ static void json_writer_escape_string(grpc_json_writer* writer,
       }
       for (i = 0; i < extra; i++) {
         utf32 <<= 6;
-        c = static_cast<uint8_t>(*string++);
+        ++idx;
+        /* Breaks out and bail if we hit the end of the string. */
+        if (idx == string.size()) {
+          valid = 0;
+          break;
+        }
+        c = static_cast<uint8_t>(string[idx]);
         /* Breaks out and bail on any invalid UTF-8 sequence, including \0. */
         if ((c & 0xc0) != 0x80) {
           valid = 0;
@@ -218,115 +227,111 @@ static void json_writer_escape_string(grpc_json_writer* writer,
          * That range is exactly 20 bits.
          */
         utf32 -= 0x10000;
-        json_writer_escape_utf16(writer,
-                                 static_cast<uint16_t>(0xd800 | (utf32 >> 10)));
-        json_writer_escape_utf16(
-            writer, static_cast<uint16_t>(0xdc00 | (utf32 & 0x3ff)));
+        EscapeUtf16(static_cast<uint16_t>(0xd800 | (utf32 >> 10)));
+        EscapeUtf16(static_cast<uint16_t>(0xdc00 | (utf32 & 0x3ff)));
       } else {
-        json_writer_escape_utf16(writer, static_cast<uint16_t>(utf32));
+        EscapeUtf16(static_cast<uint16_t>(utf32));
       }
     }
   }
+  OutputChar('"');
+}
 
-  json_writer_output_char(writer, '"');
+void JsonWriter::ContainerBegins(Json::Type type) {
+  if (!got_key_) ValueEnd();
+  OutputIndent();
+  OutputChar(type == Json::Type::OBJECT ? '{' : '[');
+  container_empty_ = true;
+  got_key_ = false;
+  depth_++;
 }
 
-static void grpc_json_writer_container_begins(grpc_json_writer* writer,
-                                              grpc_json_type type) {
-  if (!writer->got_key) json_writer_value_end(writer);
-  json_writer_output_indent(writer);
-  json_writer_output_char(writer, type == GRPC_JSON_OBJECT ? '{' : '[');
-  writer->container_empty = 1;
-  writer->got_key = 0;
-  writer->depth++;
+void JsonWriter::ContainerEnds(Json::Type type) {
+  if (indent_ && !container_empty_) OutputChar('\n');
+  depth_--;
+  if (!container_empty_) OutputIndent();
+  OutputChar(type == Json::Type::OBJECT ? '}' : ']');
+  container_empty_ = false;
+  got_key_ = false;
 }
 
-static void grpc_json_writer_container_ends(grpc_json_writer* writer,
-                                            grpc_json_type type) {
-  if (writer->indent && !writer->container_empty)
-    json_writer_output_char(writer, '\n');
-  writer->depth--;
-  if (!writer->container_empty) json_writer_output_indent(writer);
-  json_writer_output_char(writer, type == GRPC_JSON_OBJECT ? '}' : ']');
-  writer->container_empty = 0;
-  writer->got_key = 0;
+void JsonWriter::ObjectKey(const std::string& string) {
+  ValueEnd();
+  OutputIndent();
+  EscapeString(string);
+  OutputChar(':');
+  got_key_ = true;
 }
 
-static void grpc_json_writer_object_key(grpc_json_writer* writer,
-                                        const char* string) {
-  json_writer_value_end(writer);
-  json_writer_output_indent(writer);
-  json_writer_escape_string(writer, string);
-  json_writer_output_char(writer, ':');
-  writer->got_key = 1;
+void JsonWriter::ValueRaw(const std::string& string) {
+  if (!got_key_) ValueEnd();
+  OutputIndent();
+  OutputString(string);
+  got_key_ = false;
 }
 
-static void grpc_json_writer_value_raw(grpc_json_writer* writer,
-                                       const char* string) {
-  if (!writer->got_key) json_writer_value_end(writer);
-  json_writer_output_indent(writer);
-  json_writer_output_string(writer, string);
-  writer->got_key = 0;
+void JsonWriter::ValueString(const std::string& string) {
+  if (!got_key_) ValueEnd();
+  OutputIndent();
+  EscapeString(string);
+  got_key_ = false;
 }
 
-static void grpc_json_writer_value_raw_with_len(grpc_json_writer* writer,
-                                                const char* string,
-                                                size_t len) {
-  if (!writer->got_key) json_writer_value_end(writer);
-  json_writer_output_indent(writer);
-  json_writer_output_string_with_len(writer, string, len);
-  writer->got_key = 0;
+void JsonWriter::DumpObject(const Json::Object& object) {
+  ContainerBegins(Json::Type::OBJECT);
+  for (const auto& p : object) {
+    ObjectKey(p.first.data());
+    DumpValue(p.second);
+  }
+  ContainerEnds(Json::Type::OBJECT);
 }
 
-static void grpc_json_writer_value_string(grpc_json_writer* writer,
-                                          const char* string) {
-  if (!writer->got_key) json_writer_value_end(writer);
-  json_writer_output_indent(writer);
-  json_writer_escape_string(writer, string);
-  writer->got_key = 0;
+void JsonWriter::DumpArray(const Json::Array& array) {
+  ContainerBegins(Json::Type::ARRAY);
+  for (const auto& v : array) {
+    DumpValue(v);
+  }
+  ContainerEnds(Json::Type::ARRAY);
 }
 
-static void json_dump_recursive(grpc_json_writer* writer, const grpc_json* json,
-                                int in_object) {
-  while (json) {
-    if (in_object) grpc_json_writer_object_key(writer, json->key);
-    switch (json->type) {
-      case GRPC_JSON_OBJECT:
-      case GRPC_JSON_ARRAY:
-        grpc_json_writer_container_begins(writer, json->type);
-        if (json->child)
-          json_dump_recursive(writer, json->child,
-                              json->type == GRPC_JSON_OBJECT);
-        grpc_json_writer_container_ends(writer, json->type);
-        break;
-      case GRPC_JSON_STRING:
-        grpc_json_writer_value_string(writer, json->value);
-        break;
-      case GRPC_JSON_NUMBER:
-        grpc_json_writer_value_raw(writer, json->value);
-        break;
-      case GRPC_JSON_TRUE:
-        grpc_json_writer_value_raw_with_len(writer, "true", 4);
-        break;
-      case GRPC_JSON_FALSE:
-        grpc_json_writer_value_raw_with_len(writer, "false", 5);
-        break;
-      case GRPC_JSON_NULL:
-        grpc_json_writer_value_raw_with_len(writer, "null", 4);
-        break;
-      default:
-        GPR_UNREACHABLE_CODE(abort());
-    }
-    json = json->next;
+void JsonWriter::DumpValue(const Json& value) {
+  switch (value.type()) {
+    case Json::Type::OBJECT:
+      DumpObject(value.object_value());
+      break;
+    case Json::Type::ARRAY:
+      DumpArray(value.array_value());
+      break;
+    case Json::Type::STRING:
+      ValueString(value.string_value());
+      break;
+    case Json::Type::NUMBER:
+      ValueRaw(value.string_value());
+      break;
+    case Json::Type::JSON_TRUE:
+      ValueRaw(std::string("true", 4));
+      break;
+    case Json::Type::JSON_FALSE:
+      ValueRaw(std::string("false", 5));
+      break;
+    case Json::Type::JSON_NULL:
+      ValueRaw(std::string("null", 4));
+      break;
+    default:
+      GPR_UNREACHABLE_CODE(abort());
   }
 }
 
-char* grpc_json_dump_to_string(const grpc_json* json, int indent) {
-  grpc_json_writer writer;
-  memset(&writer, 0, sizeof(writer));
-  writer.container_empty = 1;
-  writer.indent = indent;
-  json_dump_recursive(&writer, json, 0);
-  json_writer_output_char(&writer, 0);
-  return writer.output;
+std::string JsonWriter::Dump(const Json& value, int indent) {
+  JsonWriter writer(indent);
+  writer.DumpValue(value);
+  return std::move(writer.output_);
 }
+
+}  // namespace
+
+std::string Json::Dump(int indent) const {
+  return JsonWriter::Dump(*this, indent);
+}
+
+}  // namespace grpc_core

data/src/core/lib/security/credentials/alts/check_gcp_environment.cc

@@ -30,7 +30,7 @@
 const size_t kBiosDataBufferSize = 256;
 
 static char* trim(const char* src) {
-  if (src == nullptr) {
+  if (src == nullptr || *src == '\0') {
     return nullptr;
   }
   char* des = nullptr;

data/src/core/lib/security/credentials/composite/composite_credentials.cc

@@ -22,7 +22,10 @@
 
 #include <cstring>
 #include <new>
+#include <vector>
 
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/surface/api_trace.h"
@@ -116,6 +119,15 @@ void grpc_composite_call_credentials::cancel_get_request_metadata(
   GRPC_ERROR_UNREF(error);
 }
 
+std::string grpc_composite_call_credentials::debug_string() {
+  std::vector<std::string> outputs;
+  for (auto& inner_cred : inner_) {
+    outputs.emplace_back(inner_cred->debug_string());
+  }
+  return absl::StrCat("CompositeCallCredentials{", absl::StrJoin(outputs, ","),
+                      "}");
+}
+
 static size_t get_creds_array_size(const grpc_call_credentials* creds,
                                    bool is_composite) {
   return is_composite