grpc 1.28.0 → 1.31.0.pre2

data/src/core/lib/channel/status_util.cc

@@ -22,11 +22,10 @@
 
 #include "src/core/lib/gpr/useful.h"
 
-typedef struct {
+struct status_string_entry {
   const char* str;
   grpc_status_code status;
-} status_string_entry;
-
+};
 static const status_string_entry g_status_string_entries[] = {
     {"OK", GRPC_STATUS_OK},
     {"CANCELLED", GRPC_STATUS_CANCELLED},

data/src/core/lib/compression/message_compress.cc

@@ -34,7 +34,7 @@
 static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
                      grpc_slice_buffer* output,
                      int (*flate)(z_stream* zs, int flush)) {
-  int r;
+  int r = Z_STREAM_END; /* Do not fail on an empty input. */
   int flush;
   size_t i;
   grpc_slice outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
@@ -68,6 +68,10 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
       goto error;
     }
   }
+  if (r != Z_STREAM_END) {
+    gpr_log(GPR_INFO, "zlib: Data error");
+    goto error;
+  }
 
   GPR_ASSERT(outbuf.refcount);
   outbuf.data.refcounted.length -= zs->avail_out;

data/src/core/lib/debug/stats.cc

@@ -23,6 +23,11 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include <vector>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
@@ -140,39 +145,28 @@ double grpc_stats_histo_percentile(const grpc_stats_data* stats,
       static_cast<double>(count) * percentile / 100.0);
 }
 
-char* grpc_stats_data_as_json(const grpc_stats_data* data) {
-  gpr_strvec v;
-  char* tmp;
-  bool is_first = true;
-  gpr_strvec_init(&v);
-  gpr_strvec_add(&v, gpr_strdup("{"));
+std::string grpc_stats_data_as_json(const grpc_stats_data* data) {
+  std::vector<std::string> parts;
+  parts.push_back("{");
   for (size_t i = 0; i < GRPC_STATS_COUNTER_COUNT; i++) {
-    gpr_asprintf(&tmp, "%s\"%s\": %" PRIdPTR, is_first ? "" : ", ",
-                 grpc_stats_counter_name[i], data->counters[i]);
-    gpr_strvec_add(&v, tmp);
-    is_first = false;
+    parts.push_back(absl::StrFormat(
+        "\"%s\": %" PRIdPTR, grpc_stats_counter_name[i], data->counters[i]));
   }
   for (size_t i = 0; i < GRPC_STATS_HISTOGRAM_COUNT; i++) {
-    gpr_asprintf(&tmp, "%s\"%s\": [", is_first ? "" : ", ",
-                 grpc_stats_histogram_name[i]);
-    gpr_strvec_add(&v, tmp);
+    parts.push_back(absl::StrFormat("\"%s\": [", grpc_stats_histogram_name[i]));
     for (int j = 0; j < grpc_stats_histo_buckets[i]; j++) {
-      gpr_asprintf(&tmp, "%s%" PRIdPTR, j == 0 ? "" : ",",
-                   data->histograms[grpc_stats_histo_start[i] + j]);
-      gpr_strvec_add(&v, tmp);
+      parts.push_back(
+          absl::StrFormat("%s%" PRIdPTR, j == 0 ? "" : ",",
+                          data->histograms[grpc_stats_histo_start[i] + j]));
     }
-    gpr_asprintf(&tmp, "], \"%s_bkt\": [", grpc_stats_histogram_name[i]);
-    gpr_strvec_add(&v, tmp);
+    parts.push_back(
+        absl::StrFormat("], \"%s_bkt\": [", grpc_stats_histogram_name[i]));
     for (int j = 0; j < grpc_stats_histo_buckets[i]; j++) {
-      gpr_asprintf(&tmp, "%s%d", j == 0 ? "" : ",",
-                   grpc_stats_histo_bucket_boundaries[i][j]);
-      gpr_strvec_add(&v, tmp);
+      parts.push_back(absl::StrFormat(
+          "%s%d", j == 0 ? "" : ",", grpc_stats_histo_bucket_boundaries[i][j]));
     }
-    gpr_strvec_add(&v, gpr_strdup("]"));
-    is_first = false;
+    parts.push_back("]");
   }
-  gpr_strvec_add(&v, gpr_strdup("}"));
-  tmp = gpr_strvec_flatten(&v, nullptr);
-  gpr_strvec_destroy(&v);
-  return tmp;
+  parts.push_back("}");
+  return absl::StrJoin(parts, "");
 }

data/src/core/lib/debug/stats.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include <grpc/support/atm.h>
 #include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -56,7 +58,7 @@ void grpc_stats_collect(grpc_stats_data* output);
 // c = b-a
 void grpc_stats_diff(const grpc_stats_data* b, const grpc_stats_data* a,
                      grpc_stats_data* c);
-char* grpc_stats_data_as_json(const grpc_stats_data* data);
+std::string grpc_stats_data_as_json(const grpc_stats_data* data);
 int grpc_stats_histo_find_bucket_slow(int value, const int* table,
                                       int table_size);
 double grpc_stats_histo_percentile(const grpc_stats_data* data,

data/src/core/lib/gpr/log_linux.cc

@@ -30,7 +30,6 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 #include <inttypes.h>
 #include <stdarg.h>
@@ -39,6 +38,8 @@
 #include <sys/syscall.h>
 #include <time.h>
 #include <unistd.h>
+#include <string>
+#include "absl/strings/str_format.h"
 
 static long sys_gettid(void) { return syscall(__NR_gettid); }
 
@@ -63,7 +64,6 @@ void gpr_log(const char* file, int line, gpr_log_severity severity,
 
 void gpr_default_log(gpr_log_func_args* args) {
   const char* final_slash;
-  char* prefix;
   const char* display_file;
   char time_buffer[64];
   time_t timer;
@@ -86,12 +86,10 @@ void gpr_default_log(gpr_log_func_args* args) {
     strcpy(time_buffer, "error:strftime");
   }
 
-  gpr_asprintf(&prefix, "%s%s.%09" PRId32 " %7ld %s:%d]",
-               gpr_log_severity_string(args->severity), time_buffer,
-               now.tv_nsec, tid, display_file, args->line);
-
-  fprintf(stderr, "%-60s %s\n", prefix, args->message);
-  gpr_free(prefix);
+  std::string prefix = absl::StrFormat(
+      "%s%s.%09" PRId32 " %7ld %s:%d]", gpr_log_severity_string(args->severity),
+      time_buffer, now.tv_nsec, tid, display_file, args->line);
+  fprintf(stderr, "%-60s %s\n", prefix.c_str(), args->message);
 }
 
 #endif /* GPR_LINUX_LOG */

data/src/core/lib/gpr/log_posix.cc

@@ -22,7 +22,6 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 #include <inttypes.h>
 #include <pthread.h>
@@ -30,6 +29,8 @@
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
+#include <string>
+#include "absl/strings/str_format.h"
 
 static intptr_t sys_gettid(void) { return (intptr_t)pthread_self(); }
 
@@ -83,13 +84,10 @@ void gpr_default_log(gpr_log_func_args* args) {
     strcpy(time_buffer, "error:strftime");
   }
 
-  char* prefix;
-  gpr_asprintf(&prefix, "%s%s.%09d %7" PRIdPTR " %s:%d]",
-               gpr_log_severity_string(args->severity), time_buffer,
-               (int)(now.tv_nsec), sys_gettid(), display_file, args->line);
-
-  fprintf(stderr, "%-70s %s\n", prefix, args->message);
-  gpr_free(prefix);
+  std::string prefix = absl::StrFormat(
+      "%s%s.%09d %7" PRIdPTR " %s:%d]", gpr_log_severity_string(args->severity),
+      time_buffer, (int)(now.tv_nsec), sys_gettid(), display_file, args->line);
+  fprintf(stderr, "%-70s %s\n", prefix.c_str(), args->message);
 }
 
 #endif /* defined(GPR_POSIX_LOG) */

data/src/core/lib/gpr/spinlock.h

@@ -25,10 +25,9 @@
 
 /* Simple spinlock. No backoff strategy, gpr_spinlock_lock is almost always
    a concurrency code smell. */
-typedef struct {
+struct gpr_spinlock {
   gpr_atm atm;
-} gpr_spinlock;
-
+};
 #ifdef __cplusplus
 #define GPR_SPINLOCK_INITIALIZER (gpr_spinlock{0})
 #else

data/src/core/lib/gpr/string.cc

@@ -28,6 +28,8 @@
 #include <string.h>
 #include <time.h>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -50,13 +52,7 @@ char* gpr_strdup(const char* src) {
   return dst;
 }
 
-typedef struct {
-  size_t capacity;
-  size_t length;
-  char* data;
-} dump_out;
-
-char* gpr_format_timespec(gpr_timespec tm) {
+std::string gpr_format_timespec(gpr_timespec tm) {
   char time_buffer[35];
   char ns_buffer[11];  // '.' + 9 digits of precision
   struct tm* tm_info = localtime((const time_t*)&tm.tv_sec);
@@ -77,11 +73,15 @@ char* gpr_format_timespec(gpr_timespec tm) {
       break;
     }
   }
-  char* full_time_str;
-  gpr_asprintf(&full_time_str, "%s%sZ", time_buffer, ns_buffer);
-  return full_time_str;
+  return absl::StrCat(time_buffer, ns_buffer, "Z");
 }
 
+struct dump_out {
+  size_t capacity;
+  size_t length;
+  char* data;
+};
+
 static dump_out dump_out_create(void) {
   dump_out r = {0, 0, nullptr};
   return r;
@@ -266,29 +266,6 @@ char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
   return out;
 }
 
-void gpr_strvec_init(gpr_strvec* sv) { memset(sv, 0, sizeof(*sv)); }
-
-void gpr_strvec_destroy(gpr_strvec* sv) {
-  size_t i;
-  for (i = 0; i < sv->count; i++) {
-    gpr_free(sv->strs[i]);
-  }
-  gpr_free(sv->strs);
-}
-
-void gpr_strvec_add(gpr_strvec* sv, char* str) {
-  if (sv->count == sv->capacity) {
-    sv->capacity = GPR_MAX(sv->capacity + 8, sv->capacity * 2);
-    sv->strs = static_cast<char**>(
-        gpr_realloc(sv->strs, sizeof(char*) * sv->capacity));
-  }
-  sv->strs[sv->count++] = str;
-}
-
-char* gpr_strvec_flatten(gpr_strvec* sv, size_t* final_length) {
-  return gpr_strjoin((const char**)sv->strs, sv->count, final_length);
-}
-
 int gpr_strincmp(const char* a, const char* b, size_t n) {
   int ca, cb;
   do {

data/src/core/lib/gpr/string.h

@@ -26,6 +26,8 @@
 #include <stdbool.h>
 #include <stddef.h>
 
+#include <string>
+
 /* String utility functions */
 
 /* Flags for gpr_dump function. */
@@ -88,29 +90,13 @@ char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
 void gpr_string_split(const char* input, const char* sep, char*** strs,
                       size_t* nstrs);
 
-/* Returns an allocated string that represents tm according to RFC-3339, and,
+/* Returns a string that represents tm according to RFC-3339, and,
    more specifically, follows:
    https://developers.google.com/protocol-buffers/docs/proto3#json
 
    Uses RFC 3339, where generated output will always be Z-normalized and uses
    0, 3, 6 or 9 fractional digits. */
-char* gpr_format_timespec(gpr_timespec);
-
-/* A vector of strings... for building up a final string one piece at a time */
-typedef struct {
-  char** strs;
-  size_t count;
-  size_t capacity;
-} gpr_strvec;
-
-/* Initialize/destroy */
-void gpr_strvec_init(gpr_strvec* strs);
-void gpr_strvec_destroy(gpr_strvec* strs);
-/* Add a string to a strvec, takes ownership of the string */
-void gpr_strvec_add(gpr_strvec* strs, char* add);
-/* Return a joined string with all added substrings, optionally setting
-   total_length as per gpr_strjoin */
-char* gpr_strvec_flatten(gpr_strvec* strs, size_t* total_length);
+std::string gpr_format_timespec(gpr_timespec);
 
 /** Case insensitive string comparison... return <0 if lower(a)<lower(b), ==0 if
     lower(a)==lower(b), >0 if lower(a)>lower(b) */

data/src/core/lib/gpr/sync_abseil.cc

@@ -108,6 +108,8 @@ void gpr_cv_broadcast(gpr_cv* cv) {
 /*----------------------------------------*/
 
 void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
+  static_assert(sizeof(gpr_once) == sizeof(absl::once_flag),
+                "gpr_once and absl::once_flag must be the same size");
   absl::call_once(*reinterpret_cast<absl::once_flag*>(once), init_function);
 }
 

data/src/core/lib/gpr/time.cc

@@ -254,6 +254,10 @@ gpr_timespec gpr_convert_clock_type(gpr_timespec t, gpr_clock_type clock_type) {
     return gpr_time_add(gpr_now(clock_type), t);
   }
 
+  // If the given input hits this code, the same result is not guaranteed for
+  // the same input because it relies on `gpr_now` to calculate the difference
+  // between two different clocks. Please be careful when you want to use this
+  // function in unit tests. (e.g. https://github.com/grpc/grpc/pull/22655)
   return gpr_time_add(gpr_now(clock_type),
                       gpr_time_sub(t, gpr_now(t.clock_type)));
 }

data/src/core/lib/gpr/time_posix.cc

@@ -82,7 +82,7 @@ static gpr_timespec now_impl(gpr_clock_type clock_type) {
   }
 }
 #else
-  /* For some reason Apple's OSes haven't implemented clock_gettime. */
+/* For some reason Apple's OSes haven't implemented clock_gettime. */
 
 #include <mach/mach.h>
 #include <mach/mach_time.h>

data/src/core/lib/gprpp/atomic.h

@@ -28,12 +28,12 @@
 namespace grpc_core {
 
 enum class MemoryOrder {
-  RELAXED = std::memory_order_relaxed,
-  CONSUME = std::memory_order_consume,
-  ACQUIRE = std::memory_order_acquire,
-  RELEASE = std::memory_order_release,
-  ACQ_REL = std::memory_order_acq_rel,
-  SEQ_CST = std::memory_order_seq_cst
+  RELAXED = static_cast<int>(std::memory_order_relaxed),
+  CONSUME = static_cast<int>(std::memory_order_consume),
+  ACQUIRE = static_cast<int>(std::memory_order_acquire),
+  RELEASE = static_cast<int>(std::memory_order_release),
+  ACQ_REL = static_cast<int>(std::memory_order_acq_rel),
+  SEQ_CST = static_cast<int>(std::memory_order_seq_cst)
 };
 
 template <typename T>

data/src/core/lib/gprpp/fork.cc

@@ -164,7 +164,7 @@ class ThreadState {
   int count_;
 };
 
-}  // namespace
+}  // namespace internal
 
 void Fork::GlobalInit() {
   if (!override_enabled_) {

data/src/core/lib/gprpp/global_config_env.cc

@@ -30,6 +30,10 @@
 #include <ctype.h>
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_format.h"
+
 namespace grpc_core {
 
 namespace {
@@ -42,12 +46,10 @@ GlobalConfigEnvErrorFunctionType g_global_config_env_error_func =
     DefaultGlobalConfigEnvErrorFunction;
 
 void LogParsingError(const char* name, const char* value) {
-  char* error_message;
-  gpr_asprintf(&error_message,
-               "Illegal value '%s' specified for environment variable '%s'",
-               value, name);
-  (*g_global_config_env_error_func)(error_message);
-  gpr_free(error_message);
+  std::string error_message = absl::StrFormat(
+      "Illegal value '%s' specified for environment variable '%s'", value,
+      name);
+  (*g_global_config_env_error_func)(error_message.c_str());
 }
 
 }  // namespace

data/src/core/lib/gprpp/host_port.cc

@@ -20,44 +20,36 @@
 
 #include "src/core/lib/gprpp/host_port.h"
 
-#include <string.h>
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/string_view.h"
 
 namespace grpc_core {
-int JoinHostPort(grpc_core::UniquePtr<char>* out, const char* host, int port) {
-  char* tmp;
-  int ret;
-  if (host[0] != '[' && strchr(host, ':') != nullptr) {
-    /* IPv6 literals must be enclosed in brackets. */
-    ret = gpr_asprintf(&tmp, "[%s]:%d", host, port);
-  } else {
-    /* Ordinary non-bracketed host:port. */
-    ret = gpr_asprintf(&tmp, "%s:%d", host, port);
+
+std::string JoinHostPort(absl::string_view host, int port) {
+  if (!host.empty() && host[0] != '[' && host.rfind(':') != host.npos) {
+    // IPv6 literals must be enclosed in brackets.
+    return absl::StrFormat("[%s]:%d", host, port);
   }
-  out->reset(tmp);
-  return ret;
+  // Ordinary non-bracketed host:port.
+  return absl::StrFormat("%s:%d", host, port);
 }
 
 namespace {
-bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
-                     bool* has_port) {
+bool DoSplitHostPort(absl::string_view name, absl::string_view* host,
+                     absl::string_view* port, bool* has_port) {
   *has_port = false;
   if (!name.empty() && name[0] == '[') {
     /* Parse a bracketed host, typically an IPv6 literal. */
     const size_t rbracket = name.find(']', 1);
-    if (rbracket == grpc_core::StringView::npos) {
+    if (rbracket == absl::string_view::npos) {
       /* Unmatched [ */
       return false;
     }
     if (rbracket == name.size() - 1) {
       /* ]<end> */
-      *port = StringView();
+      *port = absl::string_view();
     } else if (name[rbracket + 1] == ':') {
       /* ]:<port?> */
       *port = name.substr(rbracket + 2, name.size() - rbracket - 2);
@@ -67,16 +59,16 @@ bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
       return false;
     }
     *host = name.substr(1, rbracket - 1);
-    if (host->find(':') == grpc_core::StringView::npos) {
+    if (host->find(':') == absl::string_view::npos) {
       /* Require all bracketed hosts to contain a colon, because a hostname or
          IPv4 address should never use brackets. */
-      *host = StringView();
+      *host = absl::string_view();
       return false;
     }
   } else {
     size_t colon = name.find(':');
-    if (colon != grpc_core::StringView::npos &&
-        name.find(':', colon + 1) == grpc_core::StringView::npos) {
+    if (colon != absl::string_view::npos &&
+        name.find(':', colon + 1) == absl::string_view::npos) {
       /* Exactly 1 colon.  Split into host:port. */
       *host = name.substr(0, colon);
       *port = name.substr(colon + 1, name.size() - colon - 1);
@@ -84,35 +76,37 @@ bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
     } else {
       /* 0 or 2+ colons.  Bare hostname or IPv6 litearal. */
       *host = name;
-      *port = StringView();
+      *port = absl::string_view();
     }
   }
   return true;
 }
 }  // namespace
 
-bool SplitHostPort(StringView name, StringView* host, StringView* port) {
+bool SplitHostPort(absl::string_view name, absl::string_view* host,
+                   absl::string_view* port) {
   bool unused;
   return DoSplitHostPort(name, host, port, &unused);
 }
 
-bool SplitHostPort(StringView name, grpc_core::UniquePtr<char>* host,
-                   grpc_core::UniquePtr<char>* port) {
-  GPR_DEBUG_ASSERT(host != nullptr && *host == nullptr);
-  GPR_DEBUG_ASSERT(port != nullptr && *port == nullptr);
-  StringView host_view;
-  StringView port_view;
+bool SplitHostPort(absl::string_view name, std::string* host,
+                   std::string* port) {
+  GPR_DEBUG_ASSERT(host != nullptr && host->empty());
+  GPR_DEBUG_ASSERT(port != nullptr && port->empty());
+  absl::string_view host_view;
+  absl::string_view port_view;
   bool has_port;
   const bool ret = DoSplitHostPort(name, &host_view, &port_view, &has_port);
   if (ret) {
     // We always set the host, but port is set only when DoSplitHostPort find a
     // port in the string, to remain backward compatible with the old
     // gpr_split_host_port API.
-    *host = StringViewToCString(host_view);
+    *host = std::string(host_view);
     if (has_port) {
-      *port = StringViewToCString(port_view);
+      *port = std::string(port_view);
     }
   }
   return ret;
 }
+
 }  // namespace grpc_core