clang-format runtime/bin

runtime/bin/socket_win.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/socket.h"
@@ skipping 15 matching lines @@
   ASSERT(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN);
   RawAddr* raw = reinterpret_cast<RawAddr*>(sockaddr);
 
   // Clear the port before calling WSAAddressToString as WSAAddressToString
   // includes the port in the formatted string.
   int err = Socket::FormatNumericAddress(*raw, as_string_, INET6_ADDRSTRLEN);
 
   if (err != 0) {
     as_string_[0] = 0;
   }
-  memmove(reinterpret_cast<void *>(&addr_),
-          sockaddr,
+  memmove(reinterpret_cast<void*>(&addr_), sockaddr,
           SocketAddress::GetAddrLength(*raw));
 }
 
 
 bool Socket::FormatNumericAddress(const RawAddr& addr, char* address, int len) {
   socklen_t salen = SocketAddress::GetAddrLength(addr);
   DWORD l = len;
   RawAddr& raw = const_cast<RawAddr&>(addr);
-  return WSAAddressToStringA(&raw.addr,
-                             salen,
-                             NULL,
-                             address,
-                             &l) != 0;
+  return WSAAddressToStringA(&raw.addr, salen, NULL, address, &l) != 0;
 }
 
 
 static Mutex* init_mutex = new Mutex();
 static bool socket_initialized = false;
 
 bool Socket::Initialize() {
   MutexLocker lock(init_mutex);
   if (socket_initialized) {
     return true;
@@ skipping 15 matching lines @@
   return client_socket->Available();
 }
 
 
 intptr_t Socket::Read(intptr_t fd, void* buffer, intptr_t num_bytes) {
   Handle* handle = reinterpret_cast<Handle*>(fd);
   return handle->Read(buffer, num_bytes);
 }
 
 
-intptr_t Socket::RecvFrom(
-    intptr_t fd, void* buffer, intptr_t num_bytes, RawAddr* addr) {
+intptr_t Socket::RecvFrom(intptr_t fd,
+                          void* buffer,
+                          intptr_t num_bytes,
+                          RawAddr* addr) {
   Handle* handle = reinterpret_cast<Handle*>(fd);
   socklen_t addr_len = sizeof(addr->ss);
   return handle->RecvFrom(buffer, num_bytes, &addr->addr, addr_len);
 }
 
 
 intptr_t Socket::Write(intptr_t fd, const void* buffer, intptr_t num_bytes) {
   Handle* handle = reinterpret_cast<Handle*>(fd);
   return handle->Write(buffer, num_bytes);
 }
 
 
-intptr_t Socket::SendTo(
-    intptr_t fd, const void* buffer, intptr_t num_bytes, const RawAddr& addr) {
+intptr_t Socket::SendTo(intptr_t fd,
+                        const void* buffer,
+                        intptr_t num_bytes,
+                        const RawAddr& addr) {
   Handle* handle = reinterpret_cast<Handle*>(fd);
   RawAddr& raw = const_cast<RawAddr&>(addr);
-  return handle->SendTo(
-    buffer, num_bytes, &raw.addr, SocketAddress::GetAddrLength(addr));
+  return handle->SendTo(buffer, num_bytes, &raw.addr,
+                        SocketAddress::GetAddrLength(addr));
 }
 
 
 intptr_t Socket::GetPort(intptr_t fd) {
   ASSERT(reinterpret_cast<Handle*>(fd)->is_socket());
   SocketHandle* socket_handle = reinterpret_cast<SocketHandle*>(fd);
   RawAddr raw;
   socklen_t size = sizeof(raw);
-  if (getsockname(socket_handle->socket(),  &raw.addr, &size) == SOCKET_ERROR) {
+  if (getsockname(socket_handle->socket(), &raw.addr, &size) == SOCKET_ERROR) {
     return 0;
   }
   return SocketAddress::GetAddrPort(raw);
 }
 
 
 SocketAddress* Socket::GetRemotePeer(intptr_t fd, intptr_t* port) {
   ASSERT(reinterpret_cast<Handle*>(fd)->is_socket());
   SocketHandle* socket_handle = reinterpret_cast<SocketHandle*>(fd);
   RawAddr raw;
@@ skipping 11 matching lines @@
 
 static intptr_t Create(const RawAddr& addr) {
   SOCKET s = socket(addr.ss.ss_family, SOCK_STREAM, 0);
   if (s == INVALID_SOCKET) {
     return -1;
   }
 
   linger l;
   l.l_onoff = 1;
   l.l_linger = 10;
-  int status = setsockopt(s,
-                          SOL_SOCKET,
-                          SO_LINGER,
-                          reinterpret_cast<char*>(&l),
+  int status = setsockopt(s, SOL_SOCKET, SO_LINGER, reinterpret_cast<char*>(&l),
                           sizeof(l));
   if (status != NO_ERROR) {
     FATAL("Failed setting SO_LINGER on socket");
   }
 
   ClientSocket* client_socket = new ClientSocket(s);
   return reinterpret_cast<intptr_t>(client_socket);
 }
 
 
-static intptr_t Connect(
-    intptr_t fd, const RawAddr& addr, const RawAddr& bind_addr) {
+static intptr_t Connect(intptr_t fd,
+                        const RawAddr& addr,
+                        const RawAddr& bind_addr) {
   ASSERT(reinterpret_cast<Handle*>(fd)->is_client_socket());
   ClientSocket* handle = reinterpret_cast<ClientSocket*>(fd);
   SOCKET s = handle->socket();
 
-  int status = bind(
-      s, &bind_addr.addr, SocketAddress::GetAddrLength(bind_addr));
+  int status =
+      bind(s, &bind_addr.addr, SocketAddress::GetAddrLength(bind_addr));
   if (status != NO_ERROR) {
     int rc = WSAGetLastError();
     handle->mark_closed();  // Destructor asserts that socket is marked closed.
     delete handle;
     closesocket(s);
     SetLastError(rc);
     return -1;
   }
 
   LPFN_CONNECTEX connectEx = NULL;
   GUID guid_connect_ex = WSAID_CONNECTEX;
   DWORD bytes;
-  status = WSAIoctl(s,
-                    SIO_GET_EXTENSION_FUNCTION_POINTER,
-                    &guid_connect_ex,
-                    sizeof(guid_connect_ex),
-                    &connectEx,
-                    sizeof(connectEx),
-                    &bytes,
-                    NULL,
-                    NULL);
+  status = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid_connect_ex,
+                    sizeof(guid_connect_ex), &connectEx, sizeof(connectEx),
+                    &bytes, NULL, NULL);
   DWORD rc;
   if (status != SOCKET_ERROR) {
     handle->EnsureInitialized(EventHandler::delegate());
 
     OverlappedBuffer* overlapped = OverlappedBuffer::AllocateConnectBuffer();
 
-    status = connectEx(s,
-                       &addr.addr,
-                       SocketAddress::GetAddrLength(addr),
-                       NULL,
-                       0,
-                       NULL,
-                       overlapped->GetCleanOverlapped());
+    status = connectEx(s, &addr.addr, SocketAddress::GetAddrLength(addr), NULL,
+                       0, NULL, overlapped->GetCleanOverlapped());
 
 
     if (status == TRUE) {
       handle->ConnectComplete(overlapped);
       return fd;
     } else if (WSAGetLastError() == ERROR_IO_PENDING) {
       return fd;
     }
     rc = WSAGetLastError();
     // Cleanup in case of error.
@@ skipping 33 matching lines @@
   if (fd < 0) {
     return fd;
   }
 
   return Connect(fd, addr, source_addr);
 }
 
 
 bool Socket::IsBindError(intptr_t error_number) {
   return error_number == WSAEADDRINUSE || error_number == WSAEADDRNOTAVAIL ||
-      error_number == WSAEINVAL;
+         error_number == WSAEINVAL;
 }
 
 
 void Socket::GetError(intptr_t fd, OSError* os_error) {
   Handle* handle = reinterpret_cast<Handle*>(fd);
   os_error->SetCodeAndMessage(OSError::kSystem, handle->last_error());
 }
 
 
 int Socket::GetType(intptr_t fd) {
   Handle* handle = reinterpret_cast<Handle*>(fd);
   switch (GetFileType(handle->handle())) {
-    case FILE_TYPE_CHAR: return File::kTerminal;
-    case FILE_TYPE_PIPE: return File::kPipe;
-    case FILE_TYPE_DISK: return File::kFile;
-    default: return GetLastError == NO_ERROR ? File::kOther : -1;
+    case FILE_TYPE_CHAR:
+      return File::kTerminal;
+    case FILE_TYPE_PIPE:
+      return File::kPipe;
+    case FILE_TYPE_DISK:
+      return File::kFile;
+    default:
+      return GetLastError == NO_ERROR ? File::kOther : -1;
   }
 }
 
 
 intptr_t Socket::GetStdioHandle(intptr_t num) {
   if (num != 0) {
     return -1;
   }
   HANDLE handle = GetStdHandle(STD_INPUT_HANDLE);
   if (handle == INVALID_HANDLE_VALUE) {
@@ skipping 61 matching lines @@
   freeaddrinfo(info);
   return addresses;
 }
 
 
 bool Socket::ReverseLookup(const RawAddr& addr,
                            char* host,
                            intptr_t host_len,
                            OSError** os_error) {
   ASSERT(host_len >= NI_MAXHOST);
-  int status = getnameinfo(&addr.addr,
-                           SocketAddress::GetAddrLength(addr),
-                           host,
-                           host_len,
-                           NULL,
-                           0,
-                           NI_NAMEREQD);
+  int status = getnameinfo(&addr.addr, SocketAddress::GetAddrLength(addr), host,
+                           host_len, NULL, 0, NI_NAMEREQD);
   if (status != 0) {
     ASSERT(*os_error == NULL);
     DWORD error_code = WSAGetLastError();
     SetLastError(error_code);
     *os_error = new OSError();
     return false;
   }
   return true;
 }
 
@@ skipping 13 matching lines @@
 
 intptr_t Socket::CreateBindDatagram(const RawAddr& addr, bool reuseAddress) {
   SOCKET s = socket(addr.ss.ss_family, SOCK_DGRAM, IPPROTO_UDP);
   if (s == INVALID_SOCKET) {
     return -1;
   }
 
   int status;
   if (reuseAddress) {
     BOOL optval = true;
-    status = setsockopt(s,
-                        SOL_SOCKET,
-                        SO_REUSEADDR,
-                        reinterpret_cast<const char*>(&optval),
-                        sizeof(optval));
+    status = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
+                        reinterpret_cast<const char*>(&optval), sizeof(optval));
     if (status == SOCKET_ERROR) {
       DWORD rc = WSAGetLastError();
       closesocket(s);
       SetLastError(rc);
       return -1;
     }
   }
 
-  status = bind(s, &addr.addr,  SocketAddress::GetAddrLength(addr));
+  status = bind(s, &addr.addr, SocketAddress::GetAddrLength(addr));
   if (status == SOCKET_ERROR) {
     DWORD rc = WSAGetLastError();
     closesocket(s);
     SetLastError(rc);
     return -1;
   }
 
   DatagramSocket* datagram_socket = new DatagramSocket(s);
   datagram_socket->EnsureInitialized(EventHandler::delegate());
   return reinterpret_cast<intptr_t>(datagram_socket);
 }
 
 
 bool Socket::ListInterfacesSupported() {
   return true;
 }
 
 
 AddressList<InterfaceSocketAddress>* Socket::ListInterfaces(
     int type,
     OSError** os_error) {
   Initialize();
 
   ULONG size = 0;
-  DWORD flags = GAA_FLAG_SKIP_ANYCAST |
-                GAA_FLAG_SKIP_MULTICAST |
+  DWORD flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
                 GAA_FLAG_SKIP_DNS_SERVER;
   // Query the size needed.
-  int status = GetAdaptersAddresses(SocketAddress::FromType(type),
-                                    flags,
-                                    NULL,
-                                    NULL,
-                                    &size);
+  int status = GetAdaptersAddresses(SocketAddress::FromType(type), flags, NULL,
+                                    NULL, &size);
   IP_ADAPTER_ADDRESSES* addrs = NULL;
   if (status == ERROR_BUFFER_OVERFLOW) {
     addrs = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(malloc(size));
     // Get the addresses now we have the right buffer.
-    status = GetAdaptersAddresses(SocketAddress::FromType(type),
-                                  flags,
-                                  NULL,
-                                  addrs,
-                                  &size);
+    status = GetAdaptersAddresses(SocketAddress::FromType(type), flags, NULL,
+                                  addrs, &size);
   }
   if (status != NO_ERROR) {
     ASSERT(*os_error == NULL);
     DWORD error_code = WSAGetLastError();
     SetLastError(error_code);
     *os_error = new OSError();
     return NULL;
   }
   intptr_t count = 0;
   for (IP_ADAPTER_ADDRESSES* a = addrs; a != NULL; a = a->Next) {
-    for (IP_ADAPTER_UNICAST_ADDRESS* u = a->FirstUnicastAddress;
-         u != NULL; u = u->Next) {
+    for (IP_ADAPTER_UNICAST_ADDRESS* u = a->FirstUnicastAddress; u != NULL;
+         u = u->Next) {
       count++;
     }
   }
   AddressList<InterfaceSocketAddress>* addresses =
       new AddressList<InterfaceSocketAddress>(count);
   intptr_t i = 0;
   for (IP_ADAPTER_ADDRESSES* a = addrs; a != NULL; a = a->Next) {
-    for (IP_ADAPTER_UNICAST_ADDRESS* u = a->FirstUnicastAddress;
-         u != NULL; u = u->Next) {
-      addresses->SetAt(i, new InterfaceSocketAddress(
-          u->Address.lpSockaddr,
-          StringUtilsWin::WideToUtf8(a->FriendlyName),
-          a->Ipv6IfIndex));
+    for (IP_ADAPTER_UNICAST_ADDRESS* u = a->FirstUnicastAddress; u != NULL;
+         u = u->Next) {
+      addresses->SetAt(
+          i, new InterfaceSocketAddress(
+                 u->Address.lpSockaddr,
+                 StringUtilsWin::WideToUtf8(a->FriendlyName), a->Ipv6IfIndex));
       i++;
     }
   }
   free(addrs);
   return addresses;
 }
 
 
 intptr_t ServerSocket::CreateBindListen(const RawAddr& addr,
                                         intptr_t backlog,
                                         bool v6_only) {
   SOCKET s = socket(addr.ss.ss_family, SOCK_STREAM, IPPROTO_TCP);
   if (s == INVALID_SOCKET) {
     return -1;
   }
 
   BOOL optval = true;
-  int status = setsockopt(s,
-                          SOL_SOCKET,
-                          SO_EXCLUSIVEADDRUSE,
-                          reinterpret_cast<const char*>(&optval),
-                          sizeof(optval));
+  int status =
+      setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
+                 reinterpret_cast<const char*>(&optval), sizeof(optval));
   if (status == SOCKET_ERROR) {
     DWORD rc = WSAGetLastError();
     closesocket(s);
     SetLastError(rc);
     return -1;
   }
 
   if (addr.ss.ss_family == AF_INET6) {
     optval = v6_only;
-    setsockopt(s,
-               IPPROTO_IPV6,
-               IPV6_V6ONLY,
-               reinterpret_cast<const char*>(&optval),
-               sizeof(optval));
+    setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
+               reinterpret_cast<const char*>(&optval), sizeof(optval));
   }
 
   status = bind(s, &addr.addr, SocketAddress::GetAddrLength(addr));
   if (status == SOCKET_ERROR) {
     DWORD rc = WSAGetLastError();
     closesocket(s);
     SetLastError(rc);
     return -1;
   }
 
@@ skipping 49 matching lines @@
 void Socket::Close(intptr_t fd) {
   ClientSocket* client_socket = reinterpret_cast<ClientSocket*>(fd);
   client_socket->Close();
 }
 
 
 bool Socket::GetNoDelay(intptr_t fd, bool* enabled) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   int on;
   socklen_t len = sizeof(on);
-  int err = getsockopt(handle->socket(),
-                       IPPROTO_TCP,
-                       TCP_NODELAY,
-                       reinterpret_cast<char *>(&on),
-                       &len);
+  int err = getsockopt(handle->socket(), IPPROTO_TCP, TCP_NODELAY,
+                       reinterpret_cast<char*>(&on), &len);
   if (err == 0) {
     *enabled = (on == 1);
   }
   return (err == 0);
 }
 
 
 bool Socket::SetNoDelay(intptr_t fd, bool enabled) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   int on = enabled ? 1 : 0;
-  return setsockopt(handle->socket(),
-                    IPPROTO_TCP,
-                    TCP_NODELAY,
-                    reinterpret_cast<char *>(&on),
-                    sizeof(on)) == 0;
+  return setsockopt(handle->socket(), IPPROTO_TCP, TCP_NODELAY,
+                    reinterpret_cast<char*>(&on), sizeof(on)) == 0;
 }
 
 
 bool Socket::GetMulticastLoop(intptr_t fd, intptr_t protocol, bool* enabled) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   uint8_t on;
   socklen_t len = sizeof(on);
   int level = protocol == SocketAddress::TYPE_IPV4 ? IPPROTO_IP : IPPROTO_IPV6;
-  int optname = protocol == SocketAddress::TYPE_IPV4
-      ? IP_MULTICAST_LOOP : IPV6_MULTICAST_LOOP;
-  if (getsockopt(handle->socket(),
-                 level,
-                 optname,
-                 reinterpret_cast<char *>(&on),
+  int optname = protocol == SocketAddress::TYPE_IPV4 ? IP_MULTICAST_LOOP
+                                                     : IPV6_MULTICAST_LOOP;
+  if (getsockopt(handle->socket(), level, optname, reinterpret_cast<char*>(&on),
                  &len) == 0) {
     *enabled = (on == 1);
     return true;
   }
   return false;
 }
 
 
 bool Socket::SetMulticastLoop(intptr_t fd, intptr_t protocol, bool enabled) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   int on = enabled ? 1 : 0;
   int level = protocol == SocketAddress::TYPE_IPV4 ? IPPROTO_IP : IPPROTO_IPV6;
-  int optname = protocol == SocketAddress::TYPE_IPV4
-      ? IP_MULTICAST_LOOP : IPV6_MULTICAST_LOOP;
-  return setsockopt(handle->socket(),
-                    level,
-                    optname,
-                    reinterpret_cast<char *>(&on),
-                    sizeof(on)) == 0;
+  int optname = protocol == SocketAddress::TYPE_IPV4 ? IP_MULTICAST_LOOP
+                                                     : IPV6_MULTICAST_LOOP;
+  return setsockopt(handle->socket(), level, optname,
+                    reinterpret_cast<char*>(&on), sizeof(on)) == 0;
 }
 
 
 bool Socket::GetMulticastHops(intptr_t fd, intptr_t protocol, int* value) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   uint8_t v;
   socklen_t len = sizeof(v);
   int level = protocol == SocketAddress::TYPE_IPV4 ? IPPROTO_IP : IPPROTO_IPV6;
-  int optname = protocol == SocketAddress::TYPE_IPV4
-      ? IP_MULTICAST_TTL : IPV6_MULTICAST_HOPS;
-  if (getsockopt(handle->socket(),
-                 level,
-                 optname,
-                 reinterpret_cast<char *>(&v),
+  int optname = protocol == SocketAddress::TYPE_IPV4 ? IP_MULTICAST_TTL
+                                                     : IPV6_MULTICAST_HOPS;
+  if (getsockopt(handle->socket(), level, optname, reinterpret_cast<char*>(&v),
                  &len) == 0) {
     *value = v;
     return true;
   }
   return false;
 }
 
 
 bool Socket::SetMulticastHops(intptr_t fd, intptr_t protocol, int value) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   int v = value;
   int level = protocol == SocketAddress::TYPE_IPV4 ? IPPROTO_IP : IPPROTO_IPV6;
-  int optname = protocol == SocketAddress::TYPE_IPV4
-      ? IP_MULTICAST_TTL : IPV6_MULTICAST_HOPS;
-  return setsockopt(handle->socket(),
-                    level,
-                    optname,
-                    reinterpret_cast<char *>(&v),
-                    sizeof(v)) == 0;
+  int optname = protocol == SocketAddress::TYPE_IPV4 ? IP_MULTICAST_TTL
+                                                     : IPV6_MULTICAST_HOPS;
+  return setsockopt(handle->socket(), level, optname,
+                    reinterpret_cast<char*>(&v), sizeof(v)) == 0;
 }
 
 
 bool Socket::GetBroadcast(intptr_t fd, bool* enabled) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   int on;
   socklen_t len = sizeof(on);
-  int err = getsockopt(handle->socket(),
-                       SOL_SOCKET,
-                       SO_BROADCAST,
-                       reinterpret_cast<char *>(&on),
-                       &len);
+  int err = getsockopt(handle->socket(), SOL_SOCKET, SO_BROADCAST,
+                       reinterpret_cast<char*>(&on), &len);
   if (err == 0) {
     *enabled = (on == 1);
   }
   return (err == 0);
 }
 
 
 bool Socket::SetBroadcast(intptr_t fd, bool enabled) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   int on = enabled ? 1 : 0;
-  return setsockopt(handle->socket(),
-                    SOL_SOCKET,
-                    SO_BROADCAST,
-                    reinterpret_cast<char *>(&on),
-                    sizeof(on)) == 0;
+  return setsockopt(handle->socket(), SOL_SOCKET, SO_BROADCAST,
+                    reinterpret_cast<char*>(&on), sizeof(on)) == 0;
 }
 
 
-bool Socket::JoinMulticast(
-    intptr_t fd, const RawAddr& addr, const RawAddr&, int interfaceIndex) {
+bool Socket::JoinMulticast(intptr_t fd,
+                           const RawAddr& addr,
+                           const RawAddr&,
+                           int interfaceIndex) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   int proto = addr.addr.sa_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
   struct group_req mreq;
   mreq.gr_interface = interfaceIndex;
   memmove(&mreq.gr_group, &addr.ss, SocketAddress::GetAddrLength(addr));
-  return setsockopt(handle->socket(),
-                    proto,
-                    MCAST_JOIN_GROUP,
-                    reinterpret_cast<char *>(&mreq),
-                    sizeof(mreq)) == 0;
+  return setsockopt(handle->socket(), proto, MCAST_JOIN_GROUP,
+                    reinterpret_cast<char*>(&mreq), sizeof(mreq)) == 0;
 }
 
 
-bool Socket::LeaveMulticast(
-    intptr_t fd, const RawAddr& addr, const RawAddr&, int interfaceIndex) {
+bool Socket::LeaveMulticast(intptr_t fd,
+                            const RawAddr& addr,
+                            const RawAddr&,
+                            int interfaceIndex) {
   SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
   int proto = addr.addr.sa_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
   struct group_req mreq;
   mreq.gr_interface = interfaceIndex;
   memmove(&mreq.gr_group, &addr.ss, SocketAddress::GetAddrLength(addr));
-  return setsockopt(handle->socket(),
-                    proto,
-                    MCAST_LEAVE_GROUP,
-                    reinterpret_cast<char *>(&mreq),
-                    sizeof(mreq)) == 0;
+  return setsockopt(handle->socket(), proto, MCAST_LEAVE_GROUP,
+                    reinterpret_cast<char*>(&mreq), sizeof(mreq)) == 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)
 
 #endif  // !defined(DART_IO_DISABLED)