grpc 1.50.0 → 1.52.0.pre2

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver_windows.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/port.h"  // IWYU pragma: keep
@@ -36,18 +36,20 @@
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-/* TODO(apolcyn): remove this hack after fixing upstream.
- * Our grpc/c-ares code on Windows uses the ares_set_socket_functions API,
- * which uses "struct iovec" type, which on Windows is defined inside of
- * a c-ares header that is not public.
- * See https://github.com/c-ares/c-ares/issues/206. */
+// TODO(apolcyn): remove this hack after fixing upstream.
+// Our grpc/c-ares code on Windows uses the ares_set_socket_functions API,
+// which uses "struct iovec" type, which on Windows is defined inside of
+// a c-ares header that is not public.
+// See https://github.com/c-ares/c-ares/issues/206.
 struct iovec {
   void* iov_base;
   size_t iov_len;
@@ -55,12 +57,12 @@ struct iovec {
 
 namespace grpc_core {
 
-/* c-ares reads and takes action on the error codes of the
- * "virtual socket operations" in this file, via the WSAGetLastError
- * APIs. If code in this file wants to set a specific WSA error that
- * c-ares should read, it must do so by calling SetWSAError() on the
- * WSAErrorContext instance passed to it. A WSAErrorContext must only be
- * instantiated at the top of the virtual socket function callstack. */
+// c-ares reads and takes action on the error codes of the
+// "virtual socket operations" in this file, via the WSAGetLastError
+// APIs. If code in this file wants to set a specific WSA error that
+// c-ares should read, it must do so by calling SetWSAError() on the
+// WSAErrorContext instance passed to it. A WSAErrorContext must only be
+// instantiated at the top of the virtual socket function callstack.
 class WSAErrorContext {
  public:
   explicit WSAErrorContext(){};
@@ -71,7 +73,7 @@ class WSAErrorContext {
     }
   }
 
-  /* Disallow copy and assignment operators */
+  // Disallow copy and assignment operators
   WSAErrorContext(const WSAErrorContext&) = delete;
   WSAErrorContext& operator=(const WSAErrorContext&) = delete;
 
@@ -81,15 +83,15 @@ class WSAErrorContext {
   int error_ = 0;
 };
 
-/* c-ares creates its own sockets and is meant to read them when readable and
- * write them when writeable. To fit this socket usage model into the grpc
- * windows poller (which gives notifications when attempted reads and writes are
- * actually fulfilled rather than possible), this GrpcPolledFdWindows class
- * takes advantage of the ares_set_socket_functions API and acts as a virtual
- * socket. It holds its own read and write buffers which are written to and read
- * from c-ares and are used with the grpc windows poller, and it, e.g.,
- * manufactures virtual socket error codes when it e.g. needs to tell the c-ares
- * library to wait for an async read. */
+// c-ares creates its own sockets and is meant to read them when readable and
+// write them when writeable. To fit this socket usage model into the grpc
+// windows poller (which gives notifications when attempted reads and writes are
+// actually fulfilled rather than possible), this GrpcPolledFdWindows class
+// takes advantage of the ares_set_socket_functions API and acts as a virtual
+// socket. It holds its own read and write buffers which are written to and read
+// from c-ares and are used with the grpc windows poller, and it, e.g.,
+// manufactures virtual socket error codes when it e.g. needs to tell the c-ares
+// library to wait for an async read.
 class GrpcPolledFdWindows {
  public:
   enum WriteState {
@@ -123,8 +125,8 @@ class GrpcPolledFdWindows {
   }
 
   ~GrpcPolledFdWindows() {
-    grpc_slice_unref_internal(read_buf_);
-    grpc_slice_unref_internal(write_buf_);
+    CSliceUnref(read_buf_);
+    CSliceUnref(write_buf_);
     GPR_ASSERT(read_closure_ == nullptr);
     GPR_ASSERT(write_closure_ == nullptr);
     grpc_winsocket_destroy(winsocket_);
@@ -144,7 +146,7 @@ class GrpcPolledFdWindows {
     GPR_ASSERT(read_closure_ == nullptr);
     read_closure_ = read_closure;
     GPR_ASSERT(GRPC_SLICE_LENGTH(read_buf_) == 0);
-    grpc_slice_unref_internal(read_buf_);
+    CSliceUnref(read_buf_);
     GPR_ASSERT(!read_buf_has_data_);
     read_buf_ = GRPC_SLICE_MALLOC(4192);
     if (connect_done_) {
@@ -223,13 +225,13 @@ class GrpcPolledFdWindows {
       return;
     }
     if (socket_type_ == SOCK_DGRAM) {
-      ScheduleAndNullWriteClosure(GRPC_ERROR_NONE);
+      ScheduleAndNullWriteClosure(absl::OkStatus());
     } else {
       GPR_ASSERT(socket_type_ == SOCK_STREAM);
       int wsa_error_code = 0;
       switch (tcp_write_state_) {
         case WRITE_IDLE:
-          ScheduleAndNullWriteClosure(GRPC_ERROR_NONE);
+          ScheduleAndNullWriteClosure(absl::OkStatus());
           break;
         case WRITE_REQUESTED:
           tcp_write_state_ = WRITE_PENDING;
@@ -281,8 +283,8 @@ class GrpcPolledFdWindows {
     if (GRPC_SLICE_LENGTH(read_buf_) == 0) {
       read_buf_has_data_ = false;
     }
-    /* c-ares overloads this recv_from virtual socket function to receive
-     * data on both UDP and TCP sockets, and from is nullptr for TCP. */
+    // c-ares overloads this recv_from virtual socket function to receive
+    // data on both UDP and TCP sockets, and from is nullptr for TCP.
     if (from != nullptr) {
       GPR_ASSERT(*from_len <= recv_from_source_addr_len_);
       memcpy(from, &recv_from_source_addr_, recv_from_source_addr_len_);
@@ -354,12 +356,12 @@ class GrpcPolledFdWindows {
     // to write everything inline.
     GRPC_CARES_TRACE_LOG("fd:|%s| SendVUDP called", GetName());
     GPR_ASSERT(GRPC_SLICE_LENGTH(write_buf_) == 0);
-    grpc_slice_unref_internal(write_buf_);
+    CSliceUnref(write_buf_);
     write_buf_ = FlattenIovec(iov, iov_count);
     DWORD bytes_sent = 0;
     int wsa_error_code = 0;
     if (SendWriteBuf(&bytes_sent, nullptr, &wsa_error_code) != 0) {
-      grpc_slice_unref_internal(write_buf_);
+      CSliceUnref(write_buf_);
       write_buf_ = grpc_empty_slice();
       wsa_error_ctx->SetWSAError(wsa_error_code);
       char* msg = gpr_format_message(wsa_error_code);
@@ -387,7 +389,7 @@ class GrpcPolledFdWindows {
       case WRITE_IDLE:
         tcp_write_state_ = WRITE_REQUESTED;
         GPR_ASSERT(GRPC_SLICE_LENGTH(write_buf_) == 0);
-        grpc_slice_unref_internal(write_buf_);
+        CSliceUnref(write_buf_);
         write_buf_ = FlattenIovec(iov, iov_count);
         wsa_error_ctx->SetWSAError(WSAEWOULDBLOCK);
         return -1;
@@ -410,7 +412,7 @@ class GrpcPolledFdWindows {
                      GRPC_SLICE_START_PTR(write_buf_)[i]);
           total_sent++;
         }
-        grpc_slice_unref_internal(currently_attempted);
+        CSliceUnref(currently_attempted);
         tcp_write_state_ = WRITE_IDLE;
         return total_sent;
     }
@@ -429,13 +431,13 @@ class GrpcPolledFdWindows {
         "fd:%s InnerOnTcpConnectLocked error:|%s| "
         "pending_register_for_readable:%d"
         " pending_register_for_writeable:%d",
-        GetName(), grpc_error_std_string(error).c_str(),
+        GetName(), StatusToString(error).c_str(),
         pending_continue_register_for_on_readable_locked_,
         pending_continue_register_for_on_writeable_locked_);
     GPR_ASSERT(!connect_done_);
     connect_done_ = true;
     GPR_ASSERT(wsa_connect_error_ == 0);
-    if (GRPC_ERROR_IS_NONE(error)) {
+    if (error.ok()) {
       DWORD transferred_bytes = 0;
       DWORD flags;
       BOOL wsa_success =
@@ -568,7 +570,6 @@ class GrpcPolledFdWindows {
 
   static void OnIocpReadable(void* arg, grpc_error_handle error) {
     GrpcPolledFdWindows* polled_fd = static_cast<GrpcPolledFdWindows*>(arg);
-    (void)GRPC_ERROR_REF(error);
     MutexLock lock(polled_fd->mu_);
     polled_fd->OnIocpReadableLocked(error);
   }
@@ -579,12 +580,12 @@ class GrpcPolledFdWindows {
   // the entire resolution attempt. Doing so will allow the "inject broken
   // nameserver list" test to pass on Windows.
   void OnIocpReadableLocked(grpc_error_handle error) {
-    if (GRPC_ERROR_IS_NONE(error)) {
+    if (error.ok()) {
       if (winsocket_->read_info.wsa_error != 0) {
-        /* WSAEMSGSIZE would be due to receiving more data
-         * than our read buffer's fixed capacity. Assume that
-         * the connection is TCP and read the leftovers
-         * in subsequent c-ares reads. */
+        // WSAEMSGSIZE would be due to receiving more data
+        // than our read buffer's fixed capacity. Assume that
+        // the connection is TCP and read the leftovers
+        // in subsequent c-ares reads.
         if (winsocket_->read_info.wsa_error != WSAEMSGSIZE) {
           error = GRPC_WSA_ERROR(winsocket_->read_info.wsa_error,
                                  "OnIocpReadableInner");
@@ -592,16 +593,16 @@ class GrpcPolledFdWindows {
               "fd:|%s| OnIocpReadableInner winsocket_->read_info.wsa_error "
               "code:|%d| msg:|%s|",
               GetName(), winsocket_->read_info.wsa_error,
-              grpc_error_std_string(error).c_str());
+              StatusToString(error).c_str());
         }
       }
     }
-    if (GRPC_ERROR_IS_NONE(error)) {
+    if (error.ok()) {
       read_buf_ = grpc_slice_sub_no_ref(
           read_buf_, 0, winsocket_->read_info.bytes_transferred);
       read_buf_has_data_ = true;
     } else {
-      grpc_slice_unref_internal(read_buf_);
+      CSliceUnref(read_buf_);
       read_buf_ = grpc_empty_slice();
     }
     GRPC_CARES_TRACE_LOG(
@@ -612,7 +613,6 @@ class GrpcPolledFdWindows {
 
   static void OnIocpWriteable(void* arg, grpc_error_handle error) {
     GrpcPolledFdWindows* polled_fd = static_cast<GrpcPolledFdWindows*>(arg);
-    (void)GRPC_ERROR_REF(error);
     MutexLock lock(polled_fd->mu_);
     polled_fd->OnIocpWriteableLocked(error);
   }
@@ -620,7 +620,7 @@ class GrpcPolledFdWindows {
   void OnIocpWriteableLocked(grpc_error_handle error) {
     GRPC_CARES_TRACE_LOG("OnIocpWriteableInner. fd:|%s|", GetName());
     GPR_ASSERT(socket_type_ == SOCK_STREAM);
-    if (GRPC_ERROR_IS_NONE(error)) {
+    if (error.ok()) {
       if (winsocket_->write_info.wsa_error != 0) {
         error = GRPC_WSA_ERROR(winsocket_->write_info.wsa_error,
                                "OnIocpWriteableInner");
@@ -628,18 +628,18 @@ class GrpcPolledFdWindows {
             "fd:|%s| OnIocpWriteableInner. winsocket_->write_info.wsa_error "
             "code:|%d| msg:|%s|",
             GetName(), winsocket_->write_info.wsa_error,
-            grpc_error_std_string(error).c_str());
+            StatusToString(error).c_str());
       }
     }
     GPR_ASSERT(tcp_write_state_ == WRITE_PENDING);
-    if (GRPC_ERROR_IS_NONE(error)) {
+    if (error.ok()) {
       tcp_write_state_ = WRITE_WAITING_FOR_VERIFICATION_UPON_RETRY;
       write_buf_ = grpc_slice_sub_no_ref(
           write_buf_, 0, winsocket_->write_info.bytes_transferred);
       GRPC_CARES_TRACE_LOG("fd:|%s| OnIocpWriteableInner. bytes transferred:%d",
                            GetName(), winsocket_->write_info.bytes_transferred);
     } else {
-      grpc_slice_unref_internal(write_buf_);
+      CSliceUnref(write_buf_);
       write_buf_ = grpc_empty_slice();
     }
     ScheduleAndNullWriteClosure(error);
@@ -684,11 +684,11 @@ struct SockToPolledFdEntry {
   SockToPolledFdEntry* next = nullptr;
 };
 
-/* A SockToPolledFdMap can make ares_socket_t types (SOCKET's on windows)
- * to GrpcPolledFdWindow's, and is used to find the appropriate
- * GrpcPolledFdWindows to handle a virtual socket call when c-ares makes that
- * socket call on the ares_socket_t type. Instances are owned by and one-to-one
- * with a GrpcPolledFdWindows factory and event driver */
+// A SockToPolledFdMap can make ares_socket_t types (SOCKET's on windows)
+// to GrpcPolledFdWindow's, and is used to find the appropriate
+// GrpcPolledFdWindows to handle a virtual socket call when c-ares makes that
+// socket call on the ares_socket_t type. Instances are owned by and one-to-one
+// with a GrpcPolledFdWindows factory and event driver
 class SockToPolledFdMap {
  public:
   explicit SockToPolledFdMap(Mutex* mu) : mu_(mu) {}
@@ -727,12 +727,12 @@ class SockToPolledFdMap {
     abort();
   }
 
-  /* These virtual socket functions are called from within the c-ares
-   * library. These methods generally dispatch those socket calls to the
-   * appropriate methods. The virtual "socket" and "close" methods are
-   * special and instead create/add and remove/destroy GrpcPolledFdWindows
-   * objects.
-   */
+  // These virtual socket functions are called from within the c-ares
+  // library. These methods generally dispatch those socket calls to the
+  // appropriate methods. The virtual "socket" and "close" methods are
+  // special and instead create/add and remove/destroy GrpcPolledFdWindows
+  // objects.
+  //
   static ares_socket_t Socket(int af, int type, int protocol, void* user_data) {
     if (type != SOCK_DGRAM && type != SOCK_STREAM) {
       GRPC_CARES_TRACE_LOG("Socket called with invalid socket type:%d", type);
@@ -795,7 +795,7 @@ class SockToPolledFdMap {
     // If a gRPC polled fd has not made it in to the driver's list yet, then
     // the driver has not and will never see this socket.
     if (!polled_fd->gotten_into_driver_list()) {
-      polled_fd->ShutdownLocked(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      polled_fd->ShutdownLocked(GRPC_ERROR_CREATE(
           "Shut down c-ares fd before without it ever having made it into the "
           "driver's list"));
     }
@@ -816,9 +816,9 @@ const struct ares_socket_functions custom_ares_sock_funcs = {
     &SockToPolledFdMap::SendV /* sendv */,
 };
 
-/* A thin wrapper over a GrpcPolledFdWindows object but with a shorter
-   lifetime. This object releases it's GrpcPolledFdWindows upon destruction,
-   so that c-ares can close it via usual socket teardown. */
+// A thin wrapper over a GrpcPolledFdWindows object but with a shorter
+// lifetime. This object releases it's GrpcPolledFdWindows upon destruction,
+// so that c-ares can close it via usual socket teardown.
 class GrpcPolledFdWindowsWrapper : public GrpcPolledFd {
  public:
   explicit GrpcPolledFdWindowsWrapper(GrpcPolledFdWindows* wrapped)
@@ -875,9 +875,9 @@ class GrpcPolledFdFactoryWindows : public GrpcPolledFdFactory {
 };
 
 std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(Mutex* mu) {
-  return absl::make_unique<GrpcPolledFdFactoryWindows>(mu);
+  return std::make_unique<GrpcPolledFdFactoryWindows>(mu);
 }
 
 }  // namespace grpc_core
 
-#endif /* GRPC_ARES == 1 && defined(GPR_WINDOWS) */
+#endif  // GRPC_ARES == 1 && defined(GPR_WINDOWS)