grpc 1.27.0 → 1.28.0.pre2

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

@@ -26,6 +26,12 @@
 
 #include "src/core/lib/json/json.h"
 
+#include "src/core/lib/gprpp/string_view.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,129 @@
  * 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 StringView 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 StringView 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(StringView(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(StringView(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(StringView("\\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(StringView("\\b", 2));
           break;
         case '\f':
-          json_writer_output_string_with_len(writer, "\\f", 2);
+          OutputString(StringView("\\f", 2));
           break;
         case '\n':
-          json_writer_output_string_with_len(writer, "\\n", 2);
+          OutputString(StringView("\\n", 2));
           break;
         case '\r':
-          json_writer_output_string_with_len(writer, "\\r", 2);
+          OutputString(StringView("\\r", 2));
           break;
         case '\t':
-          json_writer_output_string_with_len(writer, "\\t", 2);
+          OutputString(StringView("\\t", 2));
           break;
         default:
-          json_writer_escape_utf16(writer, c);
+          EscapeUtf16(c);
           break;
       }
     } else {
@@ -185,7 +187,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 +226,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/google_default/google_default_credentials.cc

@@ -44,6 +44,8 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/api_trace.h"
 
+using grpc_core::Json;
+
 /* -- Constants. -- */
 
 #define GRPC_COMPUTE_ENGINE_DETECTION_HOST "metadata.google.internal."
@@ -216,24 +218,25 @@ static int is_metadata_server_reachable() {
 /* Takes ownership of creds_path if not NULL. */
 static grpc_error* create_default_creds_from_path(
     char* creds_path, grpc_core::RefCountedPtr<grpc_call_credentials>* creds) {
-  grpc_json* json = nullptr;
   grpc_auth_json_key key;
   grpc_auth_refresh_token token;
   grpc_core::RefCountedPtr<grpc_call_credentials> result;
   grpc_slice creds_data = grpc_empty_slice();
   grpc_error* error = GRPC_ERROR_NONE;
+  Json json;
+  grpc_core::StringView str;
   if (creds_path == nullptr) {
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("creds_path unset");
     goto end;
   }
   error = grpc_load_file(creds_path, 0, &creds_data);
-  if (error != GRPC_ERROR_NONE) {
-    goto end;
-  }
-  json = grpc_json_parse_string_with_len(
-      reinterpret_cast<char*> GRPC_SLICE_START_PTR(creds_data),
+  if (error != GRPC_ERROR_NONE) goto end;
+  str = grpc_core::StringView(
+      reinterpret_cast<char*>(GRPC_SLICE_START_PTR(creds_data)),
       GRPC_SLICE_LENGTH(creds_data));
-  if (json == nullptr) {
+  json = Json::Parse(str, &error);
+  if (error != GRPC_ERROR_NONE) goto end;
+  if (json.type() != Json::Type::OBJECT) {
     error = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to parse JSON"),
         GRPC_ERROR_STR_RAW_BYTES, grpc_slice_ref_internal(creds_data));
@@ -271,7 +274,6 @@ end:
   GPR_ASSERT((result == nullptr) + (error == GRPC_ERROR_NONE) == 1);
   if (creds_path != nullptr) gpr_free(creds_path);
   grpc_slice_unref_internal(creds_data);
-  grpc_json_destroy(json);
   *creds = result;
   return error;
 }