grpc 1.83.0 → 1.84.0.pre1

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

@@ -25,168 +25,203 @@
 #include <zconf.h>
 #include <zlib.h>
 
+#include <algorithm>
+#include <cstdint>
+#include <optional>
+
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/grpc_check.h"
+#include "src/core/util/status_helper.h"
 #include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 #define OUTPUT_BLOCK_SIZE 1024
 
-static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
-                     grpc_slice_buffer* output,
-                     int (*flate)(z_stream* zs, int flush)) {
+namespace grpc_core {
+namespace {
+
+absl::StatusOr<SliceBuffer> ZlibBody(z_stream* zs, const SliceBuffer& input,
+                                     int (*flate)(z_stream* zs, int flush),
+                                     std::optional<uint32_t> max_output_size) {
   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);
+  uint32_t remaining_output_size = max_output_size.value_or(UINT32_MAX);
+  SliceBuffer output_sb;
   const uInt uint_max = ~uInt{0};
+  auto outbuf = MutableSlice::CreateUninitialized(
+      std::min<uint32_t>(remaining_output_size, OUTPUT_BLOCK_SIZE));
 
-  GRPC_CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
-  zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
-  zs->next_out = GRPC_SLICE_START_PTR(outbuf);
+  GRPC_CHECK(outbuf.length() <= uint_max);
+  zs->avail_out = static_cast<uInt>(outbuf.length());
+  zs->next_out = const_cast<uint8_t*>(outbuf.begin());
   flush = Z_NO_FLUSH;
-  for (i = 0; i < input->count; i++) {
-    if (i == input->count - 1) flush = Z_FINISH;
-    GRPC_CHECK(GRPC_SLICE_LENGTH(input->slices[i]) <= uint_max);
-    zs->avail_in = static_cast<uInt> GRPC_SLICE_LENGTH(input->slices[i]);
-    zs->next_in = GRPC_SLICE_START_PTR(input->slices[i]);
+  for (i = 0; i < input.Count(); i++) {
+    if (i == input.Count() - 1) {
+      flush = Z_FINISH;
+    }
+    GRPC_CHECK(input[i].length() <= uint_max);
+    zs->avail_in = static_cast<uInt>(input[i].length());
+    zs->next_in = const_cast<uint8_t*>(input[i].begin());
     do {
       if (zs->avail_out == 0) {
-        grpc_slice_buffer_add_indexed(output, outbuf);
-        outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
-        GRPC_CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
-        zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
-        zs->next_out = GRPC_SLICE_START_PTR(outbuf);
+        if (max_output_size.has_value() && remaining_output_size == 0) {
+          VLOG(2) << "zlib: max provided output size exceeded";
+          return absl::ResourceExhaustedError(
+              "Decompressed message larger than max");
+        }
+        output_sb.AppendIndexed(Slice(std::move(outbuf)));
+        outbuf = MutableSlice::CreateUninitialized(
+            std::min<uint32_t>(remaining_output_size, OUTPUT_BLOCK_SIZE));
+        // Update remaining output size to reflect the size of the slice we just
+        // filled with compressed / decompressed data.
+        if (max_output_size.has_value()) {
+          remaining_output_size -= outbuf.length();
+        }
+        GRPC_CHECK(outbuf.length() <= uint_max);
+        zs->avail_out = static_cast<uInt>(outbuf.length());
+        zs->next_out = const_cast<uint8_t*>(outbuf.begin());
       }
       r = flate(zs, flush);
       if (r < 0 && r != Z_BUF_ERROR /* not fatal */) {
         VLOG(2) << "zlib error (" << r << ")";
-        goto error;
+        return absl::InternalError("Decompression failed due to zlib error");
       }
     } while (zs->avail_out == 0);
     if (zs->avail_in) {
       VLOG(2) << "zlib: not all input consumed";
-      goto error;
+      return absl::InternalError(
+          "Decompression failed due to not all input "
+          "consumed");
     }
   }
   if (r != Z_STREAM_END) {
     VLOG(2) << "zlib: Data error";
-    goto error;
+    return absl::InternalError("Decompression failed due to data error");
   }
 
-  GRPC_CHECK(outbuf.refcount);
-  outbuf.data.refcounted.length -= zs->avail_out;
-  grpc_slice_buffer_add_indexed(output, outbuf);
-
-  return 1;
-
-error:
-  grpc_core::CSliceUnref(outbuf);
-  return 0;
+  // TODO(vigneshbabu): Add a Truncate() method to the Slice type to avoid using
+  // the underlying C type here.
+  grpc_slice slice = outbuf.TakeCSlice();
+  if (slice.refcount) {
+    slice.data.refcounted.length -= zs->avail_out;
+  } else {
+    slice.data.inlined.length -= zs->avail_out;
+  }
+  output_sb.AppendIndexed(Slice(slice));
+  return output_sb;
 }
 
-static void* zalloc_gpr(void* /*opaque*/, unsigned int items,
-                        unsigned int size) {
+void* ZallocGpr(void* /*opaque*/, unsigned int items, unsigned int size) {
   return gpr_malloc(items * size);
 }
 
-static void zfree_gpr(void* /*opaque*/, void* address) { gpr_free(address); }
+void ZFreeGpr(void* /*opaque*/, void* address) { gpr_free(address); }
 
-static int zlib_compress(grpc_slice_buffer* input, grpc_slice_buffer* output,
-                         int gzip) {
+std::optional<SliceBuffer> ZlibCompress(const SliceBuffer& input, int gzip) {
   z_stream zs;
-  int r;
-  size_t i;
-  size_t count_before = output->count;
-  size_t length_before = output->length;
+  absl::StatusOr<SliceBuffer> compression_result;
   memset(&zs, 0, sizeof(zs));
-  zs.zalloc = zalloc_gpr;
-  zs.zfree = zfree_gpr;
-  r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | (gzip ? 16 : 0),
-                   8, Z_DEFAULT_STRATEGY);
+  zs.zalloc = ZallocGpr;
+  zs.zfree = ZFreeGpr;
+  bool r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                        15 | (gzip ? 16 : 0), 8, Z_DEFAULT_STRATEGY);
   GRPC_CHECK(r == Z_OK);
-  r = zlib_body(&zs, input, output, deflate) && output->length < input->length;
-  if (!r) {
-    for (i = count_before; i < output->count; i++) {
-      grpc_core::CSliceUnref(output->slices[i]);
-    }
-    output->count = count_before;
-    output->length = length_before;
-  }
+  compression_result = ZlibBody(&zs, input, deflate, input.Length());
   deflateEnd(&zs);
-  return r;
+  if (compression_result.ok() &&
+      compression_result->Length() < input.Length()) {
+    return std::move(*compression_result);
+  }
+  return std::nullopt;
 }
 
-static int zlib_decompress(grpc_slice_buffer* input, grpc_slice_buffer* output,
-                           int gzip) {
+absl::StatusOr<SliceBuffer> ZlibDecompress(
+    const SliceBuffer& input, int gzip,
+    std::optional<uint32_t> max_output_size) {
   z_stream zs;
-  int r;
-  size_t i;
-  size_t count_before = output->count;
-  size_t length_before = output->length;
+  absl::StatusOr<SliceBuffer> decompression_result;
   memset(&zs, 0, sizeof(zs));
-  zs.zalloc = zalloc_gpr;
-  zs.zfree = zfree_gpr;
-  r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
+  zs.zalloc = ZallocGpr;
+  zs.zfree = ZFreeGpr;
+  bool r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
   GRPC_CHECK(r == Z_OK);
-  r = zlib_body(&zs, input, output, inflate);
-  if (!r) {
-    for (i = count_before; i < output->count; i++) {
-      grpc_core::CSliceUnref(output->slices[i]);
-    }
-    output->count = count_before;
-    output->length = length_before;
-  }
+  decompression_result = ZlibBody(&zs, input, inflate, max_output_size);
   inflateEnd(&zs);
-  return r;
+  return decompression_result;
 }
 
-static int copy(grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  size_t i;
-  for (i = 0; i < input->count; i++) {
-    grpc_slice_buffer_add(output, grpc_core::CSliceRef(input->slices[i]));
-  }
-  return 1;
-}
+}  // namespace
 
-static int compress_inner(grpc_compression_algorithm algorithm,
-                          grpc_slice_buffer* input, grpc_slice_buffer* output) {
+std::optional<SliceBuffer> MessageCompress(grpc_compression_algorithm algorithm,
+                                           const SliceBuffer& input) {
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       // the fallback path always needs to be send uncompressed: we simply
       // rely on that here
-      return 0;
+      return std::nullopt;
     case GRPC_COMPRESS_DEFLATE:
-      return zlib_compress(input, output, 0);
+      return ZlibCompress(input, 0);
     case GRPC_COMPRESS_GZIP:
-      return zlib_compress(input, output, 1);
+      return ZlibCompress(input, 1);
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   LOG(ERROR) << "invalid compression algorithm " << algorithm;
-  return 0;
+  return std::nullopt;
 }
 
+absl::StatusOr<SliceBuffer> MessageDecompress(
+    grpc_compression_algorithm algorithm, const SliceBuffer& input,
+    std::optional<uint32_t> max_output_size) {
+  switch (algorithm) {
+    case GRPC_COMPRESS_NONE: {
+      SliceBuffer output;
+      output.Append(input);
+      return output;
+    }
+    case GRPC_COMPRESS_DEFLATE:
+      return ZlibDecompress(input, 0, max_output_size);
+    case GRPC_COMPRESS_GZIP:
+      return ZlibDecompress(input, 1, max_output_size);
+    case GRPC_COMPRESS_ALGORITHMS_COUNT:
+      break;
+  }
+  LOG(ERROR) << "invalid compression algorithm " << algorithm;
+  return absl::InternalError("Invalid compression algorithm");
+}
+
+}  // namespace grpc_core
+
 int grpc_msg_compress(grpc_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  if (!compress_inner(algorithm, input, output)) {
-    copy(input, output);
-    return 0;
+  int retval = 1;
+  grpc_core::SliceBuffer input_sb;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+  std::optional<grpc_core::SliceBuffer> output_sb =
+      grpc_core::MessageCompress(algorithm, input_sb);
+  if (!output_sb.has_value()) {
+    output_sb.emplace();
+    output_sb->Append(input_sb);
+    retval = 0;
   }
-  return 1;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+  grpc_slice_buffer_swap(output, output_sb->c_slice_buffer());
+  return retval;
 }
 
 int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  switch (algorithm) {
-    case GRPC_COMPRESS_NONE:
-      return copy(input, output);
-    case GRPC_COMPRESS_DEFLATE:
-      return zlib_decompress(input, output, 0);
-    case GRPC_COMPRESS_GZIP:
-      return zlib_decompress(input, output, 1);
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
-      break;
+  grpc_core::SliceBuffer input_sb;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+
+  absl::StatusOr<grpc_core::SliceBuffer> output_sb =
+      grpc_core::MessageDecompress(algorithm, input_sb, std::nullopt);
+  if (!output_sb.ok()) {
+    return 0;
   }
-  LOG(ERROR) << "invalid compression algorithm " << algorithm;
-  return 0;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+  grpc_slice_buffer_swap(output, output_sb->c_slice_buffer());
+  return 1;
 }

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

@@ -23,6 +23,13 @@
 #include <grpc/slice.h>
 #include <grpc/support/port_platform.h>
 
+#include <cstdint>
+#include <optional>
+
+#include "src/core/lib/slice/slice_buffer.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
 // compress 'input' to 'output' using 'algorithm'.
 // On success, appends compressed slices to output and returns 1.
 // On failure, appends uncompressed slices to output and returns 0.
@@ -35,4 +42,21 @@ int grpc_msg_compress(grpc_compression_algorithm algorithm,
 int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output);
 
+namespace grpc_core {
+
+// Compresses 'input' using 'algorithm'.
+// On success, returns a SliceBuffer containing the compressed data.
+// On failure, returns nullopt.
+std::optional<SliceBuffer> MessageCompress(grpc_compression_algorithm algorithm,
+                                           const SliceBuffer& input);
+// Decompresses 'input'.
+// On success, returns a SliceBuffer containing the decompressed data.
+// On failure, returns a non-OK status.
+// Fails if the decompressed data would be larger than max_output_size.
+absl::StatusOr<SliceBuffer> MessageDecompress(
+    grpc_compression_algorithm algorithm, const SliceBuffer& input,
+    std::optional<uint32_t> max_output_size);
+
+}  // namespace grpc_core
+
 #endif  // GRPC_SRC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H

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

@@ -68,6 +68,7 @@ TraceFlag client_channel_trace(false, "client_channel");
 TraceFlag client_channel_call_trace(false, "client_channel_call");
 TraceFlag client_channel_lb_call_trace(false, "client_channel_lb_call");
 TraceFlag client_idle_filter_trace(false, "client_idle_filter");
+TraceFlag composite_filter_trace(false, "composite_filter");
 TraceFlag compression_trace(false, "compression");
 TraceFlag connectivity_state_trace(false, "connectivity_state");
 TraceFlag dns_resolver_trace(false, "dns_resolver");
@@ -79,6 +80,7 @@ TraceFlag event_engine_dns_trace(false, "event_engine_dns");
 TraceFlag event_engine_endpoint_trace(false, "event_engine_endpoint");
 TraceFlag event_engine_endpoint_data_trace(false, "event_engine_endpoint_data");
 TraceFlag event_engine_poller_trace(false, "event_engine_poller");
+TraceFlag ext_proc_filter_trace(false, "ext_proc_filter");
 TraceFlag fault_injection_filter_trace(false, "fault_injection_filter");
 TraceFlag flowctl_trace(false, "flowctl");
 TraceFlag fork_trace(false, "fork");
@@ -109,6 +111,8 @@ TraceFlag rls_lb_trace(false, "rls_lb");
 TraceFlag round_robin_trace(false, "round_robin");
 TraceFlag secure_endpoint_trace(false, "secure_endpoint");
 TraceFlag server_channel_trace(false, "server_channel");
+TraceFlag server_config_selector_interceptor_trace(
+    false, "server_config_selector_interceptor");
 TraceFlag stateful_session_filter_trace(false, "stateful_session_filter");
 TraceFlag subchannel_trace(false, "subchannel");
 TraceFlag subchannel_call_trace(false, "subchannel_call");
@@ -151,6 +155,7 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"client_channel_call", &client_channel_call_trace},
           {"client_channel_lb_call", &client_channel_lb_call_trace},
           {"client_idle_filter", &client_idle_filter_trace},
+          {"composite_filter", &composite_filter_trace},
           {"compression", &compression_trace},
           {"connectivity_state", &connectivity_state_trace},
           {"dns_resolver", &dns_resolver_trace},
@@ -162,6 +167,7 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"event_engine_endpoint", &event_engine_endpoint_trace},
           {"event_engine_endpoint_data", &event_engine_endpoint_data_trace},
           {"event_engine_poller", &event_engine_poller_trace},
+          {"ext_proc_filter", &ext_proc_filter_trace},
           {"fault_injection_filter", &fault_injection_filter_trace},
           {"flowctl", &flowctl_trace},
           {"fork", &fork_trace},
@@ -192,6 +198,8 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"round_robin", &round_robin_trace},
           {"secure_endpoint", &secure_endpoint_trace},
           {"server_channel", &server_channel_trace},
+          {"server_config_selector_interceptor",
+           &server_config_selector_interceptor_trace},
           {"stateful_session_filter", &stateful_session_filter_trace},
           {"subchannel", &subchannel_trace},
           {"subchannel_call", &subchannel_call_trace},

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

@@ -67,6 +67,7 @@ extern TraceFlag client_channel_trace;
 extern TraceFlag client_channel_call_trace;
 extern TraceFlag client_channel_lb_call_trace;
 extern TraceFlag client_idle_filter_trace;
+extern TraceFlag composite_filter_trace;
 extern TraceFlag compression_trace;
 extern TraceFlag connectivity_state_trace;
 extern TraceFlag dns_resolver_trace;
@@ -77,6 +78,7 @@ extern TraceFlag event_engine_dns_trace;
 extern TraceFlag event_engine_endpoint_trace;
 extern TraceFlag event_engine_endpoint_data_trace;
 extern TraceFlag event_engine_poller_trace;
+extern TraceFlag ext_proc_filter_trace;
 extern TraceFlag fault_injection_filter_trace;
 extern TraceFlag flowctl_trace;
 extern TraceFlag fork_trace;
@@ -107,6 +109,7 @@ extern TraceFlag rls_lb_trace;
 extern TraceFlag round_robin_trace;
 extern TraceFlag secure_endpoint_trace;
 extern TraceFlag server_channel_trace;
+extern TraceFlag server_config_selector_interceptor_trace;
 extern TraceFlag stateful_session_filter_trace;
 extern TraceFlag subchannel_trace;
 extern TraceFlag subchannel_call_trace;

data/src/core/lib/event_engine/ares_resolver.cc

@@ -60,11 +60,13 @@
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/util/address_sorting_init.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/base/call_once.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
 #include "absl/strings/match.h"
@@ -79,8 +81,58 @@
 
 namespace grpc_event_engine::experimental {
 
+std::vector<EventEngine::ResolvedAddress> SortAddresses(
+    const std::vector<EventEngine::ResolvedAddress>& addresses) {
+  address_sorting_sortable* sortables = static_cast<address_sorting_sortable*>(
+      gpr_zalloc(sizeof(address_sorting_sortable) * addresses.size()));
+  for (size_t i = 0; i < addresses.size(); i++) {
+    sortables[i].user_data =
+        const_cast<EventEngine::ResolvedAddress*>(&addresses[i]);
+    memcpy(&sortables[i].dest_addr.addr, addresses[i].address(),
+           addresses[i].size());
+    sortables[i].dest_addr.len = addresses[i].size();
+  }
+  address_sorting_rfc_6724_sort(sortables, addresses.size());
+  std::vector<EventEngine::ResolvedAddress> sorted_addresses;
+  sorted_addresses.reserve(addresses.size());
+  for (size_t i = 0; i < addresses.size(); ++i) {
+    sorted_addresses.emplace_back(
+        *static_cast<EventEngine::ResolvedAddress*>(sortables[i].user_data));
+  }
+  gpr_free(sortables);
+  return sorted_addresses;
+}
+
 namespace {
 
+absl::Status AresInit() {
+  if (ShouldUseAresDnsResolver()) {
+    // ares_library_init and ares_library_cleanup are currently no-op except
+    // under Windows. Calling them may cause race conditions when other parts of
+    // the binary calls these functions concurrently.
+#ifdef GPR_WINDOWS
+    int status = ares_library_init(ARES_LIB_INIT_ALL);
+    if (status != ARES_SUCCESS) {
+      return GRPC_ERROR_CREATE(
+          absl::StrCat("ares_library_init failed: ", ares_strerror(status)));
+    }
+#endif  // GPR_WINDOWS
+  }
+  return absl::OkStatus();
+}
+
+absl::once_flag init_flag;
+
+void AresOnceInit() {
+  grpc_core::AddressSortingInitOnce();
+  absl::call_once(init_flag, []() {
+    auto status = AresInit();
+    if (!status.ok()) {
+      VLOG(2) << "AresInit failed: " << status.message();
+    }
+  });
+}
+
 // A hard limit on the number of records (A/AAAA or SRV) we may get from a
 // single response. This is to be defensive to prevent a bad DNS response from
 // OOMing the process.
@@ -151,28 +203,6 @@ absl::Status SetRequestDNSServer(absl::string_view dns_server,
   return absl::OkStatus();
 }
 
-std::vector<EventEngine::ResolvedAddress> SortAddresses(
-    const std::vector<EventEngine::ResolvedAddress>& addresses) {
-  address_sorting_sortable* sortables = static_cast<address_sorting_sortable*>(
-      gpr_zalloc(sizeof(address_sorting_sortable) * addresses.size()));
-  for (size_t i = 0; i < addresses.size(); i++) {
-    sortables[i].user_data =
-        const_cast<EventEngine::ResolvedAddress*>(&addresses[i]);
-    memcpy(&sortables[i].dest_addr.addr, addresses[i].address(),
-           addresses[i].size());
-    sortables[i].dest_addr.len = addresses[i].size();
-  }
-  address_sorting_rfc_6724_sort(sortables, addresses.size());
-  std::vector<EventEngine::ResolvedAddress> sorted_addresses;
-  sorted_addresses.reserve(addresses.size());
-  for (size_t i = 0; i < addresses.size(); ++i) {
-    sorted_addresses.emplace_back(
-        *static_cast<EventEngine::ResolvedAddress*>(sortables[i].user_data));
-  }
-  gpr_free(sortables);
-  return sorted_addresses;
-}
-
 struct QueryArg {
   QueryArg(AresResolver* ar, int id, absl::string_view name)
       : ares_resolver(ar), callback_map_id(id), query_name(name) {}
@@ -253,6 +283,7 @@ AresResolver::CreateAresResolver(
     std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
     std::shared_ptr<EventEngine> event_engine) {
   ares_channel channel;
+  AresOnceInit();
   absl::Status status =
       InitAresChannel(dns_server, *polled_fd_factory, &channel);
   if (!status.ok()) {
@@ -276,6 +307,7 @@ AresResolver::AresResolver(
 #endif  // GRPC_ENABLE_FORK_SUPPORT
       event_engine_(std::move(event_engine)) {
   (void)dns_server;  // Used whether or not compiled with fork support
+  AresOnceInit();
   polled_fd_factory_->Initialize(&mutex_, event_engine_.get());
 }
 
@@ -951,36 +983,8 @@ bool ShouldUseAresDnsResolver() {
         // defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 }
 
-absl::Status AresInit() {
-  if (ShouldUseAresDnsResolver()) {
-    // ares_library_init and ares_library_cleanup are currently no-op except
-    // under Windows. Calling them may cause race conditions when other parts of
-    // the binary calls these functions concurrently.
-#ifdef GPR_WINDOWS
-    int status = ares_library_init(ARES_LIB_INIT_ALL);
-    if (status != ARES_SUCCESS) {
-      return GRPC_ERROR_CREATE(
-          absl::StrCat("ares_library_init failed: ", ares_strerror(status)));
-    }
-#endif  // GPR_WINDOWS
-  }
-  return absl::OkStatus();
-}
-void AresShutdown() {
-  if (ShouldUseAresDnsResolver()) {
-    // ares_library_init and ares_library_cleanup are currently no-op except
-    // under Windows. Calling them may cause race conditions when other parts of
-    // the binary calls these functions concurrently.
-#ifdef GPR_WINDOWS
-    ares_library_cleanup();
-#endif  // GPR_WINDOWS
-  }
-}
-
 #else  // GRPC_ARES == 1
 
 bool ShouldUseAresDnsResolver() { return false; }
-absl::Status AresInit() { return absl::OkStatus(); }
-void AresShutdown() {}
 
 #endif  // GRPC_ARES == 1

data/src/core/lib/event_engine/ares_resolver.h

@@ -41,6 +41,9 @@
 
 namespace grpc_event_engine::experimental {
 
+std::vector<EventEngine::ResolvedAddress> SortAddresses(
+    const std::vector<EventEngine::ResolvedAddress>& addresses);
+
 class AresResolver : public RefCountedDNSResolverInterface {
  public:
 #ifdef GRPC_ENABLE_FORK_SUPPORT
@@ -182,7 +185,5 @@ extern bool g_event_engine_grpc_ares_test_only_force_tcp;
 #endif  // GRPC_ARES == 1
 
 bool ShouldUseAresDnsResolver();
-absl::Status AresInit();
-void AresShutdown();
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H

data/src/core/lib/event_engine/posix_engine/ev_epoll1_linux.cc

@@ -226,9 +226,9 @@ void Epoll1EventHandle::OrphanHandle(PosixEngineClosure* on_done,
 // shutdown() syscall on that fd)
 void Epoll1EventHandle::HandleShutdownInternal(absl::Status why,
                                                bool releasing_fd) {
-  grpc_core::StatusSetInt(
-      &why, grpc_core::StatusIntProperty::kRpcStatus,
-      absl::IsCancelled(why) ? GRPC_STATUS_CANCELLED : GRPC_STATUS_UNAVAILABLE);
+  if (!absl::IsCancelled(why)) {
+    why = absl::UnavailableError(why.message());
+  }
   if (read_closure_.SetShutdown(why)) {
     if (releasing_fd) {
       auto result = poller_->posix_interface().EpollCtlDel(

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.cc

@@ -263,11 +263,7 @@ void PollEventHandle::OrphanHandle(PosixEngineClosure* on_done,
     // Perform shutdown operations if not already done so.
     if (!is_shutdown_) {
       is_shutdown_ = true;
-      shutdown_error_ =
-          absl::Status(absl::StatusCode::kInternal, "FD Orphaned");
-      grpc_core::StatusSetInt(&shutdown_error_,
-                              grpc_core::StatusIntProperty::kRpcStatus,
-                              GRPC_STATUS_UNAVAILABLE);
+      shutdown_error_ = absl::UnavailableError("FD Orphaned");
       SetReadyLocked(&read_closure_);
       SetReadyLocked(&write_closure_);
     }
@@ -341,11 +337,9 @@ void PollEventHandle::ShutdownHandle(absl::Status why) {
     // only shutdown once
     if (!is_shutdown_) {
       is_shutdown_ = true;
-      shutdown_error_ = std::move(why);
-      grpc_core::StatusSetInt(
-          &shutdown_error_, grpc_core::StatusIntProperty::kRpcStatus,
-          absl::IsCancelled(shutdown_error_) ? GRPC_STATUS_CANCELLED
-                                             : GRPC_STATUS_UNAVAILABLE);
+      shutdown_error_ = absl::IsCancelled(why)
+                            ? std::move(why)
+                            : absl::UnavailableError(why.message());
       SetReadyLocked(&read_closure_);
       SetReadyLocked(&write_closure_);
     }