grpc 1.30.2 → 1.32.0

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,13 +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);
+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_posix.cc

@@ -116,10 +116,6 @@ void gpr_cv_destroy(gpr_cv* cv) {
 #endif
 }
 
-#define gpr_convert_clock_type_debug(t, clock_type, now1, now2, add_result, \
-                                     sub_result)                            \
-  gpr_convert_clock_type((t), (clock_type))
-
 int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
   int err = 0;
   if (gpr_time_cmp(abs_deadline, gpr_inf_future(abs_deadline.clock_type)) ==
@@ -132,11 +128,9 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
   } else {
     struct timespec abs_deadline_ts;
 #if GPR_LINUX
-    abs_deadline = gpr_convert_clock_type_debug(
-        abs_deadline, GPR_CLOCK_MONOTONIC, now1, now2, add_result, sub_result);
+    abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_MONOTONIC);
 #else
-    abs_deadline = gpr_convert_clock_type_debug(
-        abs_deadline, GPR_CLOCK_REALTIME, now1, now2, add_result, sub_result);
+    abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME);
 #endif  // GPR_LINUX
     abs_deadline_ts.tv_sec = static_cast<time_t>(abs_deadline.tv_sec);
     abs_deadline_ts.tv_nsec = abs_deadline.tv_nsec;

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/http/httpcli.cc

@@ -22,6 +22,10 @@
 
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -112,11 +116,11 @@ static void append_error(internal_request* req, grpc_error* error) {
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
   }
   grpc_resolved_address* addr = &req->addresses->addrs[req->next_address - 1];
-  grpc_core::UniquePtr<char> addr_text(grpc_sockaddr_to_uri(addr));
+  std::string addr_text = grpc_sockaddr_to_uri(addr);
   req->overall_error = grpc_error_add_child(
       req->overall_error,
       grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_slice_from_moved_string(std::move(addr_text))));
+                         grpc_slice_from_cpp_string(std::move(addr_text))));
 }
 
 static void do_read(internal_request* req) {
@@ -266,15 +270,14 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
                       grpc_resource_quota* resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
                       grpc_closure* on_done, grpc_httpcli_response* response) {
-  char* name;
   if (g_get_override && g_get_override(request, deadline, on_done, response)) {
     return;
   }
-  gpr_asprintf(&name, "HTTP:GET:%s:%s", request->host, request->http.path);
+  std::string name =
+      absl::StrFormat("HTTP:GET:%s:%s", request->host, request->http.path);
   internal_request_begin(context, pollent, resource_quota, request, deadline,
-                         on_done, response, name,
+                         on_done, response, name.c_str(),
                          grpc_httpcli_format_get_request(request));
-  gpr_free(name);
 }
 
 void grpc_httpcli_post(grpc_httpcli_context* context,
@@ -284,16 +287,16 @@ void grpc_httpcli_post(grpc_httpcli_context* context,
                        const char* body_bytes, size_t body_size,
                        grpc_millis deadline, grpc_closure* on_done,
                        grpc_httpcli_response* response) {
-  char* name;
   if (g_post_override && g_post_override(request, body_bytes, body_size,
                                          deadline, on_done, response)) {
     return;
   }
-  gpr_asprintf(&name, "HTTP:POST:%s:%s", request->host, request->http.path);
+  std::string name =
+      absl::StrFormat("HTTP:POST:%s:%s", request->host, request->http.path);
   internal_request_begin(
       context, pollent, resource_quota, request, deadline, on_done, response,
-      name, grpc_httpcli_format_post_request(request, body_bytes, body_size));
-  gpr_free(name);
+      name.c_str(),
+      grpc_httpcli_format_post_request(request, body_bytes, body_size));
 }
 
 void grpc_httpcli_set_override(grpc_httpcli_get_override get,

data/src/core/lib/http/httpcli_security_connector.cc

@@ -22,6 +22,7 @@
 
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/support/alloc.h>
@@ -95,11 +96,10 @@ class grpc_httpcli_ssl_channel_security_connector final
     /* Check the peer name. */
     if (secure_peer_name_ != nullptr &&
         !tsi_ssl_peer_matches_name(&peer, secure_peer_name_)) {
-      char* msg;
-      gpr_asprintf(&msg, "Peer name %s is not in peer certificate",
-                   secure_peer_name_);
-      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-      gpr_free(msg);
+      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrCat("Peer name ", secure_peer_name_,
+                       " is not in peer certificate")
+              .c_str());
     }
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
     tsi_peer_destruct(&peer);

data/src/core/lib/iomgr/cfstream_handle.cc

@@ -156,6 +156,7 @@ CFStreamHandle::~CFStreamHandle() {
   open_event_.DestroyEvent();
   read_event_.DestroyEvent();
   write_event_.DestroyEvent();
+  dispatch_release(dispatch_queue_);
 }
 
 void CFStreamHandle::NotifyOnOpen(grpc_closure* closure) {

data/src/core/lib/iomgr/endpoint.cc

@@ -52,10 +52,14 @@ void grpc_endpoint_shutdown(grpc_endpoint* ep, grpc_error* why) {
 
 void grpc_endpoint_destroy(grpc_endpoint* ep) { ep->vtable->destroy(ep); }
 
-char* grpc_endpoint_get_peer(grpc_endpoint* ep) {
+absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep) {
   return ep->vtable->get_peer(ep);
 }
 
+absl::string_view grpc_endpoint_get_local_address(grpc_endpoint* ep) {
+  return ep->vtable->get_local_address(ep);
+}
+
 int grpc_endpoint_get_fd(grpc_endpoint* ep) { return ep->vtable->get_fd(ep); }
 
 grpc_resource_user* grpc_endpoint_get_resource_user(grpc_endpoint* ep) {

data/src/core/lib/iomgr/endpoint.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/strings/string_view.h"
+
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/time.h>
@@ -33,7 +35,6 @@
 
 typedef struct grpc_endpoint grpc_endpoint;
 typedef struct grpc_endpoint_vtable grpc_endpoint_vtable;
-class Timestamps;
 
 struct grpc_endpoint_vtable {
   void (*read)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
@@ -46,7 +47,8 @@ struct grpc_endpoint_vtable {
   void (*shutdown)(grpc_endpoint* ep, grpc_error* why);
   void (*destroy)(grpc_endpoint* ep);
   grpc_resource_user* (*get_resource_user)(grpc_endpoint* ep);
-  char* (*get_peer)(grpc_endpoint* ep);
+  absl::string_view (*get_peer)(grpc_endpoint* ep);
+  absl::string_view (*get_local_address)(grpc_endpoint* ep);
   int (*get_fd)(grpc_endpoint* ep);
   bool (*can_track_err)(grpc_endpoint* ep);
 };
@@ -59,7 +61,9 @@ struct grpc_endpoint_vtable {
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
                         grpc_closure* cb, bool urgent);
 
-char* grpc_endpoint_get_peer(grpc_endpoint* ep);
+absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep);
+
+absl::string_view grpc_endpoint_get_local_address(grpc_endpoint* ep);
 
 /* Get the file descriptor used by \a ep. Return -1 if \a ep is not using an fd.
  */

data/src/core/lib/iomgr/endpoint_cfstream.cc

@@ -34,6 +34,8 @@
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
+#include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -55,7 +57,8 @@ struct CFStreamEndpoint {
   grpc_closure read_action;
   grpc_closure write_action;
 
-  char* peer_string;
+  std::string peer_string;
+  std::string local_address;
   grpc_resource_user* resource_user;
   grpc_resource_user_slice_allocator slice_allocator;
 };
@@ -64,8 +67,7 @@ static void CFStreamFree(CFStreamEndpoint* ep) {
   CFRelease(ep->read_stream);
   CFRelease(ep->write_stream);
   CFSTREAM_HANDLE_UNREF(ep->stream_sync, "free");
-  gpr_free(ep->peer_string);
-  gpr_free(ep);
+  delete ep;
 }
 
 #ifndef NDEBUG
@@ -110,7 +112,7 @@ static grpc_error* CFStreamAnnotateError(grpc_error* src_error,
       grpc_error_set_int(src_error, GRPC_ERROR_INT_GRPC_STATUS,
                          GRPC_STATUS_UNAVAILABLE),
       GRPC_ERROR_STR_TARGET_ADDRESS,
-      grpc_slice_from_copied_string(ep->peer_string));
+      grpc_slice_from_copied_string(ep->peer_string.c_str()));
 }
 
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error* error) {
@@ -124,7 +126,8 @@ static void CallReadCb(CFStreamEndpoint* ep, grpc_error* error) {
     for (i = 0; i < ep->read_slices->count; i++) {
       char* dump = grpc_dump_slice(ep->read_slices->slices[i],
                                    GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_DEBUG, "READ %p (peer=%s): %s", ep, ep->peer_string, dump);
+      gpr_log(GPR_DEBUG, "READ %p (peer=%s): %s", ep, ep->peer_string.c_str(),
+              dump);
       gpr_free(dump);
     }
   }
@@ -230,7 +233,8 @@ static void WriteAction(void* arg, grpc_error* error) {
     if (grpc_tcp_trace.enabled()) {
       grpc_slice trace_slice = grpc_slice_sub(slice, 0, write_size);
       char* dump = grpc_dump_slice(trace_slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", ep, ep->peer_string, dump);
+      gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", ep, ep->peer_string.c_str(),
+              dump);
       gpr_free(dump);
       grpc_slice_unref_internal(trace_slice);
     }
@@ -309,9 +313,14 @@ grpc_resource_user* CFStreamGetResourceUser(grpc_endpoint* ep) {
   return ep_impl->resource_user;
 }
 
-char* CFStreamGetPeer(grpc_endpoint* ep) {
+absl::string_view CFStreamGetPeer(grpc_endpoint* ep) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
-  return gpr_strdup(ep_impl->peer_string);
+  return ep_impl->peer_string;
+}
+
+absl::string_view CFStreamGetLocalAddress(grpc_endpoint* ep) {
+  CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
+  return ep_impl->local_address;
 }
 
 int CFStreamGetFD(grpc_endpoint* ep) { return 0; }
@@ -332,6 +341,7 @@ static const grpc_endpoint_vtable vtable = {CFStreamRead,
                                             CFStreamDestroy,
                                             CFStreamGetResourceUser,
                                             CFStreamGetPeer,
+                                            CFStreamGetLocalAddress,
                                             CFStreamGetFD,
                                             CFStreamCanTrackErr};
 
@@ -339,8 +349,7 @@ grpc_endpoint* grpc_cfstream_endpoint_create(
     CFReadStreamRef read_stream, CFWriteStreamRef write_stream,
     const char* peer_string, grpc_resource_quota* resource_quota,
     CFStreamHandle* stream_sync) {
-  CFStreamEndpoint* ep_impl =
-      static_cast<CFStreamEndpoint*>(gpr_malloc(sizeof(CFStreamEndpoint)));
+  CFStreamEndpoint* ep_impl = new CFStreamEndpoint;
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG,
             "CFStream endpoint:%p create readStream:%p writeStream: %p",
@@ -355,7 +364,19 @@ grpc_endpoint* grpc_cfstream_endpoint_create(
   ep_impl->stream_sync = stream_sync;
   CFSTREAM_HANDLE_REF(ep_impl->stream_sync, "endpoint create");
 
-  ep_impl->peer_string = gpr_strdup(peer_string);
+  ep_impl->peer_string = peer_string;
+  const int* native_handle =
+      reinterpret_cast<const int*>(CFReadStreamCopyProperty(
+          ep_impl->read_stream, kCFStreamPropertySocketNativeHandle));
+  grpc_resolved_address resolved_local_addr;
+  resolved_local_addr.len = sizeof(resolved_local_addr.addr);
+  if (getsockname(*native_handle,
+                  reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
+                  &resolved_local_addr.len) < 0) {
+    ep_impl->local_address = "";
+  } else {
+    ep_impl->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
+  }
   ep_impl->read_cb = nil;
   ep_impl->write_cb = nil;
   ep_impl->read_slices = nil;

data/src/core/lib/iomgr/endpoint_pair_posix.cc

@@ -32,9 +32,12 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 
+#include <string>
+
+#include "absl/strings/str_cat.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/iomgr/tcp_posix.h"
 
@@ -53,19 +56,16 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
                                                    grpc_channel_args* args) {
   int sv[2];
   grpc_endpoint_pair p;
-  char* final_name;
   create_sockets(sv);
 
   grpc_core::ExecCtx exec_ctx;
 
-  gpr_asprintf(&final_name, "%s:client", name);
-  p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name, false), args,
-                             "socketpair-server");
-  gpr_free(final_name);
-  gpr_asprintf(&final_name, "%s:server", name);
-  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name, false), args,
-                             "socketpair-client");
-  gpr_free(final_name);
+  std::string final_name = absl::StrCat(name, ":client");
+  p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
+                             args, "socketpair-server");
+  final_name = absl::StrCat(name, ":server");
+  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name.c_str(), false),
+                             args, "socketpair-client");
 
   return p;
 }

data/src/core/lib/iomgr/error_cfstream.cc

@@ -19,10 +19,13 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GRPC_CFSTREAM
+#include <string>
+
+#include "absl/strings/str_format.h"
+
 #include <CoreFoundation/CoreFoundation.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/error.h"
 
@@ -33,7 +36,6 @@ grpc_error* grpc_error_create_from_cferror(const char* file, int line,
   CFErrorRef error = static_cast<CFErrorRef>(arg);
   char buf_domain[MAX_ERROR_DESCRIPTION];
   char buf_desc[MAX_ERROR_DESCRIPTION];
-  char* error_msg;
   CFErrorDomain domain = CFErrorGetDomain((error));
   CFIndex code = CFErrorGetCode((error));
   CFStringRef desc = CFErrorCopyDescription((error));
@@ -41,12 +43,11 @@ grpc_error* grpc_error_create_from_cferror(const char* file, int line,
                      kCFStringEncodingUTF8);
   CFStringGetCString(desc, buf_desc, MAX_ERROR_DESCRIPTION,
                      kCFStringEncodingUTF8);
-  gpr_asprintf(&error_msg, "%s (error domain:%s, code:%ld, description:%s)",
-               custom_desc, buf_domain, code, buf_desc);
+  std::string error_msg =
+      absl::StrFormat("%s (error domain:%s, code:%ld, description:%s)",
+                      custom_desc, buf_domain, code, buf_desc);
   CFRelease(desc);
-  grpc_error* return_error = grpc_error_create(
-      file, line, grpc_slice_from_copied_string(error_msg), NULL, 0);
-  gpr_free(error_msg);
-  return return_error;
+  return grpc_error_create(
+      file, line, grpc_slice_from_copied_string(error_msg.c_str()), NULL, 0);
 }
 #endif /* GRPC_CFSTREAM */

data/src/core/lib/iomgr/ev_epoll1_linux.cc

@@ -38,14 +38,15 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
+#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/alloc.h>
 #include <grpc/support/cpu.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/string.h"
@@ -351,16 +352,14 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
 
   new_fd->freelist_next = nullptr;
 
-  char* fd_name;
-  gpr_asprintf(&fd_name, "%s fd=%d", name, fd);
-  grpc_iomgr_register_object(&new_fd->iomgr_object, fd_name);
+  std::string fd_name = absl::StrCat(name, " fd=", fd);
+  grpc_iomgr_register_object(&new_fd->iomgr_object, fd_name.c_str());
   fork_fd_list_add_grpc_fd(new_fd);
 #ifndef NDEBUG
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
-    gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, new_fd, fd_name);
+    gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, new_fd, fd_name.c_str());
   }
 #endif
-  gpr_free(fd_name);
 
   struct epoll_event ev;
   ev.events = static_cast<uint32_t>(EPOLLIN | EPOLLOUT | EPOLLET);