grpc 1.51.0 → 1.52.0

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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 2015 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.
+//
+//
 
 #ifndef GRPC_CORE_LIB_IOMGR_SOCKET_UTILS_POSIX_H
 #define GRPC_CORE_LIB_IOMGR_SOCKET_UTILS_POSIX_H
@@ -22,7 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/event_engine/endpoint_config.h>
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/grpc_types.h>
 
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -37,7 +37,7 @@
 #ifndef SO_EE_ORIGIN_ZEROCOPY
 #define SO_EE_ORIGIN_ZEROCOPY 5
 #endif
-#endif /* ifdef GRPC_LINUX_ERRQUEUE */
+#endif  // ifdef GRPC_LINUX_ERRQUEUE
 
 namespace grpc_core {
 
@@ -131,125 +131,125 @@ struct PosixTcpOptions {
 grpc_core::PosixTcpOptions TcpOptionsFromEndpointConfig(
     const grpc_event_engine::experimental::EndpointConfig& config);
 
-/* a wrapper for accept or accept4 */
+// a wrapper for accept or accept4
 int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock,
                  int cloexec);
 
-/* set a socket to use zerocopy */
+// set a socket to use zerocopy
 grpc_error_handle grpc_set_socket_zerocopy(int fd);
 
-/* set a socket to non blocking mode */
+// set a socket to non blocking mode
 grpc_error_handle grpc_set_socket_nonblocking(int fd, int non_blocking);
 
-/* set a socket to close on exec */
+// set a socket to close on exec
 grpc_error_handle grpc_set_socket_cloexec(int fd, int close_on_exec);
 
-/* set a socket to reuse old addresses */
+// set a socket to reuse old addresses
 grpc_error_handle grpc_set_socket_reuse_addr(int fd, int reuse);
 
-/* return true if SO_REUSEPORT is supported */
+// return true if SO_REUSEPORT is supported
 bool grpc_is_socket_reuse_port_supported();
 
-/* disable nagle */
+// disable nagle
 grpc_error_handle grpc_set_socket_low_latency(int fd, int low_latency);
 
-/* set SO_REUSEPORT */
+// set SO_REUSEPORT
 grpc_error_handle grpc_set_socket_reuse_port(int fd, int reuse);
 
-/* Configure the default values for TCP_USER_TIMEOUT */
+// Configure the default values for TCP_USER_TIMEOUT
 void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client);
 
-/* Set TCP_USER_TIMEOUT */
+// Set TCP_USER_TIMEOUT
 grpc_error_handle grpc_set_socket_tcp_user_timeout(
     int fd, const grpc_core::PosixTcpOptions& options, bool is_client);
 
-/* Returns true if this system can create AF_INET6 sockets bound to ::1.
-   The value is probed once, and cached for the life of the process.
+// Returns true if this system can create AF_INET6 sockets bound to ::1.
+// The value is probed once, and cached for the life of the process.
 
-   This is more restrictive than checking for socket(AF_INET6) to succeed,
-   because Linux with "net.ipv6.conf.all.disable_ipv6 = 1" is able to create
-   and bind IPv6 sockets, but cannot connect to a getsockname() of [::]:port
-   without a valid loopback interface.  Rather than expose this half-broken
-   state to library users, we turn off IPv6 sockets. */
+// This is more restrictive than checking for socket(AF_INET6) to succeed,
+// because Linux with "net.ipv6.conf.all.disable_ipv6 = 1" is able to create
+// and bind IPv6 sockets, but cannot connect to a getsockname() of [::]:port
+// without a valid loopback interface.  Rather than expose this half-broken
+// state to library users, we turn off IPv6 sockets.
 int grpc_ipv6_loopback_available(void);
 
-/* Tries to set SO_NOSIGPIPE if available on this platform.
-   If SO_NO_SIGPIPE is not available, returns 1. */
+// Tries to set SO_NOSIGPIPE if available on this platform.
+// If SO_NO_SIGPIPE is not available, returns 1.
 grpc_error_handle grpc_set_socket_no_sigpipe_if_possible(int fd);
 
-/* Tries to set IP_PKTINFO if available on this platform.
-   If IP_PKTINFO is not available, returns 1. */
+// Tries to set IP_PKTINFO if available on this platform.
+// If IP_PKTINFO is not available, returns 1.
 grpc_error_handle grpc_set_socket_ip_pktinfo_if_possible(int fd);
 
-/* Tries to set IPV6_RECVPKTINFO if available on this platform.
-   If IPV6_RECVPKTINFO is not available, returns 1. */
+// Tries to set IPV6_RECVPKTINFO if available on this platform.
+// If IPV6_RECVPKTINFO is not available, returns 1.
 grpc_error_handle grpc_set_socket_ipv6_recvpktinfo_if_possible(int fd);
 
-/* Tries to set the socket's send buffer to given size. */
+// Tries to set the socket's send buffer to given size.
 grpc_error_handle grpc_set_socket_sndbuf(int fd, int buffer_size_bytes);
 
-/* Tries to set the socket's receive buffer to given size. */
+// Tries to set the socket's receive buffer to given size.
 grpc_error_handle grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes);
 
-/* Tries to set the socket using a grpc_socket_mutator */
+// Tries to set the socket using a grpc_socket_mutator
 grpc_error_handle grpc_set_socket_with_mutator(int fd, grpc_fd_usage usage,
                                                grpc_socket_mutator* mutator);
 
-/* Extracts the first socket mutator from config if any and applies on the fd.
- */
+// Extracts the first socket mutator from config if any and applies on the fd.
+//
 grpc_error_handle grpc_apply_socket_mutator_in_args(
     int fd, grpc_fd_usage usage, const grpc_core::PosixTcpOptions& options);
 
-/* An enum to keep track of IPv4/IPv6 socket modes.
+// An enum to keep track of IPv4/IPv6 socket modes.
 
-   Currently, this information is only used when a socket is first created, but
-   in the future we may wish to store it alongside the fd.  This would let calls
-   like sendto() know which family to use without asking the kernel first. */
+// Currently, this information is only used when a socket is first created, but
+// in the future we may wish to store it alongside the fd.  This would let calls
+// like sendto() know which family to use without asking the kernel first.
 typedef enum grpc_dualstack_mode {
-  /* Uninitialized, or a non-IP socket. */
+  // Uninitialized, or a non-IP socket.
   GRPC_DSMODE_NONE,
-  /* AF_INET only. */
+  // AF_INET only.
   GRPC_DSMODE_IPV4,
-  /* AF_INET6 only, because IPV6_V6ONLY could not be cleared. */
+  // AF_INET6 only, because IPV6_V6ONLY could not be cleared.
   GRPC_DSMODE_IPV6,
-  /* AF_INET6, which also supports ::ffff-mapped IPv4 addresses. */
+  // AF_INET6, which also supports ::ffff-mapped IPv4 addresses.
   GRPC_DSMODE_DUALSTACK
 } grpc_dualstack_mode;
 
-/* Only tests should use this flag. */
+// Only tests should use this flag.
 extern int grpc_forbid_dualstack_sockets_for_testing;
 
-/* Tries to set the socket to dualstack. Returns 1 on success. */
+// Tries to set the socket to dualstack. Returns 1 on success.
 int grpc_set_socket_dualstack(int fd);
 
-/* Creates a new socket for connecting to (or listening on) an address.
+// Creates a new socket for connecting to (or listening on) an address.
 
-   If addr is AF_INET6, this creates an IPv6 socket first.  If that fails,
-   and addr is within ::ffff:0.0.0.0/96, then it automatically falls back to
-   an IPv4 socket.
+// If addr is AF_INET6, this creates an IPv6 socket first.  If that fails,
+// and addr is within ::ffff:0.0.0.0/96, then it automatically falls back to
+// an IPv4 socket.
 
-   If addr is AF_INET, AF_UNIX, or anything else, then this is similar to
-   calling socket() directly.
+// If addr is AF_INET, AF_UNIX, or anything else, then this is similar to
+// calling socket() directly.
 
-   Returns an fd on success, otherwise returns -1 with errno set to the result
-   of a failed socket() call.
+// Returns an fd on success, otherwise returns -1 with errno set to the result
+// of a failed socket() call.
 
-   The *dsmode output indicates which address family was actually created.
-   The recommended way to use this is:
-   - First convert to IPv6 using grpc_sockaddr_to_v4mapped().
-   - Create the socket.
-   - If *dsmode is IPV4, use grpc_sockaddr_is_v4mapped() to convert back to
-     IPv4, so that bind() or connect() see the correct family.
-   Also, it's important to distinguish between DUALSTACK and IPV6 when
-   listening on the [::] wildcard address. */
+// The *dsmode output indicates which address family was actually created.
+// The recommended way to use this is:
+// - First convert to IPv6 using grpc_sockaddr_to_v4mapped().
+// - Create the socket.
+// - If *dsmode is IPV4, use grpc_sockaddr_is_v4mapped() to convert back to
+//   IPv4, so that bind() or connect() see the correct family.
+// Also, it's important to distinguish between DUALSTACK and IPV6 when
+// listening on the [::] wildcard address.
 grpc_error_handle grpc_create_dualstack_socket(
     const grpc_resolved_address* addr, int type, int protocol,
     grpc_dualstack_mode* dsmode, int* newfd);
 
-/* Same as grpc_create_dualstack_socket(), but use the given socket factory (if
-   non-null) to create the socket, rather than calling socket() directly. */
+// Same as grpc_create_dualstack_socket(), but use the given socket factory (if
+// non-null) to create the socket, rather than calling socket() directly.
 grpc_error_handle grpc_create_dualstack_socket_using_factory(
     grpc_socket_factory* factory, const grpc_resolved_address* addr, int type,
     int protocol, grpc_dualstack_mode* dsmode, int* newfd);
 
-#endif /* GRPC_CORE_LIB_IOMGR_SOCKET_UTILS_POSIX_H */
+#endif  // GRPC_CORE_LIB_IOMGR_SOCKET_UTILS_POSIX_H

data/src/core/lib/iomgr/socket_utils_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>
 
@@ -24,6 +24,7 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 
@@ -40,8 +41,8 @@ int grpc_inet_pton(int af, const char* src, void* dst) {
 }
 
 const char* grpc_inet_ntop(int af, const void* src, char* dst, size_t size) {
-  /* Windows InetNtopA wants a mutable ip pointer */
+  // Windows InetNtopA wants a mutable ip pointer
   return InetNtopA(af, (void*)src, dst, size);
 }
 
-#endif /* GRPC_WINDOWS_SOCKETUTILS */
+#endif  // GRPC_WINDOWS_SOCKETUTILS

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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 2015 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>
 
@@ -33,6 +33,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/pollset.h"
@@ -57,13 +58,13 @@ SOCKET grpc_winsocket_wrapped_socket(grpc_winsocket* socket) {
   return socket->socket;
 }
 
-/* Schedule a shutdown of the socket operations. Will call the pending
-   operations to abort them. We need to do that this way because of the
-   various callsites of that function, which happens to be in various
-   mutex hold states, and that'd be unsafe to call them directly. */
+// Schedule a shutdown of the socket operations. Will call the pending
+// operations to abort them. We need to do that this way because of the
+// various callsites of that function, which happens to be in various
+// mutex hold states, and that'd be unsafe to call them directly.
 void grpc_winsocket_shutdown(grpc_winsocket* winsocket) {
-  /* Grab the function pointer for DisconnectEx for that specific socket.
-     It may change depending on the interface. */
+  // Grab the function pointer for DisconnectEx for that specific socket.
+  // It may change depending on the interface.
   int status;
   GUID guid = WSAID_DISCONNECTEX;
   LPFN_DISCONNECTEX DisconnectEx;
@@ -113,10 +114,10 @@ void grpc_winsocket_destroy(grpc_winsocket* winsocket) {
   if (should_destroy) destroy(winsocket);
 }
 
-/* Calling notify_on_read or write means either of two things:
--) The IOCP already completed in the background, and we need to call
-the callback now.
--) The IOCP hasn't completed yet, and we're queuing it for later. */
+// Calling notify_on_read or write means either of two things:
+//-) The IOCP already completed in the background, and we need to call
+// the callback now.
+//-) The IOCP hasn't completed yet, and we're queuing it for later.
 static void socket_notify_on_iocp(grpc_winsocket* socket, grpc_closure* closure,
                                   grpc_winsocket_callback_info* info) {
   GPR_ASSERT(info->closure == NULL);
@@ -166,7 +167,7 @@ static void probe_ipv6_once(void) {
     grpc_sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin6_family = AF_INET6;
-    addr.sin6_addr.s6_addr[15] = 1; /* [::1]:0 */
+    addr.sin6_addr.s6_addr[15] = 1;  // [::1]:0
     if (bind(s, reinterpret_cast<grpc_sockaddr*>(&addr), sizeof(addr)) == 0) {
       g_ipv6_loopback_available = 1;
     } else {
@@ -186,17 +187,17 @@ DWORD grpc_get_default_wsa_socket_flags() { return s_wsa_socket_flags; }
 
 void grpc_wsa_socket_flags_init() {
   s_wsa_socket_flags = WSA_FLAG_OVERLAPPED;
-  /* WSA_FLAG_NO_HANDLE_INHERIT may be not supported on the older Windows
-     versions, see
-     https://msdn.microsoft.com/en-us/library/windows/desktop/ms742212(v=vs.85).aspx
-     for details. */
+  // WSA_FLAG_NO_HANDLE_INHERIT may be not supported on the older Windows
+  // versions, see
+  // https://msdn.microsoft.com/en-us/library/windows/desktop/ms742212(v=vs.85).aspx
+  // for details.
   SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
                           s_wsa_socket_flags | WSA_FLAG_NO_HANDLE_INHERIT);
   if (sock != INVALID_SOCKET) {
-    /* Windows 7, Windows 2008 R2 with SP1 or later */
+    // Windows 7, Windows 2008 R2 with SP1 or later
     s_wsa_socket_flags |= WSA_FLAG_NO_HANDLE_INHERIT;
     closesocket(sock);
   }
 }
 
-#endif /* GRPC_WINSOCK_SOCKET */
+#endif  // GRPC_WINSOCK_SOCKET

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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 2015 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.
+//
+//
 
 #ifndef GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H
 #define GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H
@@ -36,42 +36,42 @@
 #define WSA_FLAG_NO_HANDLE_INHERIT 0x80
 #endif
 
-/* This holds the data for an outstanding read or write on a socket.
-   The mutex to protect the concurrent access to that data is the one
-   inside the winsocket wrapper. */
+// This holds the data for an outstanding read or write on a socket.
+// The mutex to protect the concurrent access to that data is the one
+// inside the winsocket wrapper.
 typedef struct grpc_winsocket_callback_info {
-  /* This is supposed to be a WSAOVERLAPPED, but in order to get that
-     definition, we need to include ws2tcpip.h, which needs to be included
-     from the top, otherwise it'll clash with a previous inclusion of
-     windows.h that in turns includes winsock.h. If anyone knows a way
-     to do it properly, feel free to send a patch. */
+  // This is supposed to be a WSAOVERLAPPED, but in order to get that
+  // definition, we need to include ws2tcpip.h, which needs to be included
+  // from the top, otherwise it'll clash with a previous inclusion of
+  // windows.h that in turns includes winsock.h. If anyone knows a way
+  // to do it properly, feel free to send a patch.
   OVERLAPPED overlapped;
-  /* The callback information for the pending operation. May be empty if the
-     caller hasn't registered a callback yet. */
+  // The callback information for the pending operation. May be empty if the
+  // caller hasn't registered a callback yet.
   grpc_closure* closure;
-  /* A boolean to describe if the IO Completion Port got a notification for
-     that operation. This will happen if the operation completed before the
-     called had time to register a callback. We could avoid that behavior
-     altogether by forcing the caller to always register its callback before
-     proceeding queue an operation, but it is frequent for an IO Completion
-     Port to trigger quickly. This way we avoid a context switch for calling
-     the callback. We also simplify the read / write operations to avoid having
-     to hold a mutex for a long amount of time. */
+  // A boolean to describe if the IO Completion Port got a notification for
+  // that operation. This will happen if the operation completed before the
+  // called had time to register a callback. We could avoid that behavior
+  // altogether by forcing the caller to always register its callback before
+  // proceeding queue an operation, but it is frequent for an IO Completion
+  // Port to trigger quickly. This way we avoid a context switch for calling
+  // the callback. We also simplify the read / write operations to avoid having
+  // to hold a mutex for a long amount of time.
   int has_pending_iocp;
-  /* The results of the overlapped operation. */
+  // The results of the overlapped operation.
   DWORD bytes_transferred;
   int wsa_error;
 } grpc_winsocket_callback_info;
 
-/* This is a wrapper to a Windows socket. A socket can have one outstanding
-   read, and one outstanding write. Doing an asynchronous accept means waiting
-   for a read operation. Doing an asynchronous connect means waiting for a
-   write operation. These are completely arbitrary ties between the operation
-   and the kind of event, because we can have one overlapped per pending
-   operation, whichever its nature is. So we could have more dedicated pending
-   operation callbacks for connect and listen. But given the scope of listen
-   and accept, we don't need to go to that extent and waste memory. Also, this
-   is closer to what happens in posix world. */
+// This is a wrapper to a Windows socket. A socket can have one outstanding
+// read, and one outstanding write. Doing an asynchronous accept means waiting
+// for a read operation. Doing an asynchronous connect means waiting for a
+// write operation. These are completely arbitrary ties between the operation
+// and the kind of event, because we can have one overlapped per pending
+// operation, whichever its nature is. So we could have more dedicated pending
+// operation callbacks for connect and listen. But given the scope of listen
+// and accept, we don't need to go to that extent and waste memory. Also, this
+// is closer to what happens in posix world.
 typedef struct grpc_winsocket {
   SOCKET socket;
   bool destroy_called;
@@ -82,25 +82,25 @@ typedef struct grpc_winsocket {
   gpr_mu state_mu;
   bool shutdown_called;
 
-  /* You can't add the same socket twice to the same IO Completion Port.
-     This prevents that. */
+  // You can't add the same socket twice to the same IO Completion Port.
+  // This prevents that.
   int added_to_iocp;
 
-  /* A label for iomgr to track outstanding objects */
+  // A label for iomgr to track outstanding objects
   grpc_iomgr_object iomgr_object;
 } grpc_winsocket;
 
-/* Create a wrapped windows handle. This takes ownership of it, meaning that
-   it will be responsible for closing it. */
+// Create a wrapped windows handle. This takes ownership of it, meaning that
+// it will be responsible for closing it.
 grpc_winsocket* grpc_winsocket_create(SOCKET socket, const char* name);
 
 SOCKET grpc_winsocket_wrapped_socket(grpc_winsocket* socket);
 
-/* Initiate an asynchronous shutdown of the socket. Will call off any pending
-   operation to cancel them. */
+// Initiate an asynchronous shutdown of the socket. Will call off any pending
+// operation to cancel them.
 void grpc_winsocket_shutdown(grpc_winsocket* socket);
 
-/* Destroy a socket. Should only be called if there's no pending operation. */
+// Destroy a socket. Should only be called if there's no pending operation.
 void grpc_winsocket_destroy(grpc_winsocket* socket);
 
 void grpc_socket_notify_on_write(grpc_winsocket* winsocket,
@@ -112,8 +112,8 @@ void grpc_socket_notify_on_read(grpc_winsocket* winsocket,
 void grpc_socket_become_ready(grpc_winsocket* winsocket,
                               grpc_winsocket_callback_info* ci);
 
-/* Returns true if this system can create AF_INET6 sockets bound to ::1.
-   The value is probed once, and cached for the life of the process. */
+// Returns true if this system can create AF_INET6 sockets bound to ::1.
+// The value is probed once, and cached for the life of the process.
 int grpc_ipv6_loopback_available(void);
 
 void grpc_wsa_socket_flags_init();
@@ -122,4 +122,4 @@ DWORD grpc_get_default_wsa_socket_flags();
 
 #endif
 
-#endif /* GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H */
+#endif  // GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H