Reafctor to use 'const RawAddr&' or 'RawAddr*' in the eventhandler code

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.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/builtin.h"
 #include "bin/eventhandler.h"
 #include "bin/file.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
 namespace dart {
 namespace bin {
 
 SocketAddress::SocketAddress(struct sockaddr* sockaddr) {
   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);
+  int err = Socket::FormatNumericAddress(*raw, as_string_, INET6_ADDRSTRLEN);
 
   if (err != 0) {
     as_string_[0] = 0;
   }
   memmove(reinterpret_cast<void *>(&addr_),
           sockaddr,
-          SocketAddress::GetAddrLength(raw));
+          SocketAddress::GetAddrLength(*raw));
 }
 
 
-bool Socket::FormatNumericAddress(RawAddr* addr, char* address, int len) {
+bool Socket::FormatNumericAddress(const RawAddr& addr, char* address, int len) {
   socklen_t salen = SocketAddress::GetAddrLength(addr);
   DWORD l = len;
-  return WSAAddressToStringA(&addr->addr,
-                                salen,
-                                NULL,
-                                address,
-                                &l) != 0;
+  RawAddr& raw = const_cast<RawAddr&>(addr);
+  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;
   int err;
@@ skipping 13 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, RawAddr addr) {
+    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, &addr.addr, SocketAddress::GetAddrLength(&addr));
+    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) {
     return 0;
   }
-  return SocketAddress::GetAddrPort(&raw);
+  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;
   socklen_t size = sizeof(raw);
   if (getpeername(socket_handle->socket(),
                   &raw.addr,
                   &size)) {
     return NULL;
   }
-  *port = SocketAddress::GetAddrPort(&raw);
+  *port = SocketAddress::GetAddrPort(raw);
   // Clear the port before calling WSAAddressToString as WSAAddressToString
   // includes the port in the formatted string.
   SocketAddress::SetAddrPort(&raw, 0);
   return new SocketAddress(&raw.addr);
 }
 
 
-static intptr_t Create(RawAddr addr) {
+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),
                           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, RawAddr addr, const intptr_t port, RawAddr bind_addr) {
+    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));
+      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;
   }
 
-  SocketAddress::SetAddrPort(&addr, port);
-
   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);
   DWORD rc;
   if (status != SOCKET_ERROR) {
     handle->EnsureInitialized(EventHandler::delegate());
 
     OverlappedBuffer* overlapped = OverlappedBuffer::AllocateConnectBuffer();
 
     status = connectEx(s,
                        &addr.addr,
-                       SocketAddress::GetAddrLength(&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.
     OverlappedBuffer::DisposeBuffer(overlapped);
   } else {
     rc = WSAGetLastError();
   }
   handle->Close();
   delete handle;
   SetLastError(rc);
   return -1;
 }
 
 
-intptr_t Socket::CreateConnect(const RawAddr& addr, const intptr_t port) {
+intptr_t Socket::CreateConnect(const RawAddr& addr) {
   intptr_t fd = Create(addr);
   if (fd < 0) {
     return fd;
   }
 
   RawAddr bind_addr;
   memset(&bind_addr, 0, sizeof(bind_addr));
   bind_addr.ss.ss_family = addr.ss.ss_family;
   if (addr.ss.ss_family == AF_INET) {
     bind_addr.in.sin_addr.s_addr = INADDR_ANY;
   } else {
     bind_addr.in6.sin6_addr = in6addr_any;
   }
 
-  return Connect(fd, addr, port, bind_addr);
+  return Connect(fd, addr, bind_addr);
 }
 
 
 intptr_t Socket::CreateBindConnect(const RawAddr& addr,
-                                   const intptr_t port,
                                    const RawAddr& source_addr) {
   intptr_t fd = Create(addr);
   if (fd < 0) {
     return fd;
   }
 
-  return Connect(fd, addr, port, source_addr);
+  return Connect(fd, addr, source_addr);
 }
 
 
 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) {
@@ skipping 68 matching lines @@
     if (c->ai_family == AF_INET || c->ai_family == AF_INET6) {
       addresses->SetAt(i, new SocketAddress(c->ai_addr));
       i++;
     }
   }
   freeaddrinfo(info);
   return addresses;
 }
 
 
-bool Socket::ReverseLookup(RawAddr addr,
+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),
+                           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();
@@ skipping 10 matching lines @@
     result = InetPton(AF_INET, system_address, &addr->in.sin_addr);
   } else {
     ASSERT(type == SocketAddress::TYPE_IPV6);
     result = InetPton(AF_INET6, system_address, &addr->in6.sin6_addr);
   }
   free(const_cast<wchar_t*>(system_address));
   return result == 1;
 }
 
 
-intptr_t Socket::CreateBindDatagram(
-    RawAddr* addr, intptr_t port, bool reuseAddress) {
-  SOCKET s = socket(addr->ss.ss_family, SOCK_DGRAM, IPPROTO_UDP);
+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));
     if (status == SOCKET_ERROR) {
       DWORD rc = WSAGetLastError();
       closesocket(s);
       SetLastError(rc);
       return -1;
     }
   }
 
-  SocketAddress::SetAddrPort(addr, port);
-
   status = bind(s,
-                &addr->addr,
+                &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());
@@ skipping 51 matching lines @@
           StringUtils::WideToUtf8(a->FriendlyName),
           a->Ipv6IfIndex));
       i++;
     }
   }
   free(addrs);
   return addresses;
 }
 
 
-intptr_t ServerSocket::CreateBindListen(RawAddr addr,
-                                        intptr_t port,
+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));
   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));
   }
 
-  SocketAddress::SetAddrPort(&addr, port);
   status = bind(s,
                 &addr.addr,
-                SocketAddress::GetAddrLength(&addr));
+                SocketAddress::GetAddrLength(addr));
   if (status == SOCKET_ERROR) {
     DWORD rc = WSAGetLastError();
     closesocket(s);
     SetLastError(rc);
     return -1;
   }
 
   ListenSocket* listen_socket = new ListenSocket(s);
 
   // Test for invalid socket port 65535 (some browsers disallow it).
-  if (port == 0 &&
+  if (SocketAddress::GetAddrPort(addr) == 0 &&
       Socket::GetPort(reinterpret_cast<intptr_t>(listen_socket)) == 65535) {
     // Don't close fd until we have created new. By doing that we ensure another
     // port.
-    intptr_t new_s = CreateBindListen(addr, 0, backlog, v6_only);
+    intptr_t new_s = CreateBindListen(addr, backlog, v6_only);
     DWORD rc = WSAGetLastError();
     closesocket(s);
     delete listen_socket;
     SetLastError(rc);
     return new_s;
   }
 
   status = listen(s, backlog > 0 ? backlog : SOMAXCONN);
   if (status == SOCKET_ERROR) {
     DWORD rc = WSAGetLastError();
@@ skipping 149 matching lines @@
   int on = enabled ? 1 : 0;
   return setsockopt(handle->socket(),
                     SOL_SOCKET,
                     SO_BROADCAST,
                     reinterpret_cast<char *>(&on),
                     sizeof(on)) == 0;
 }
 
 
 bool Socket::JoinMulticast(
-    intptr_t fd, RawAddr* addr, RawAddr*, int interfaceIndex) {
+    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;
+  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));
+  memmove(&mreq.gr_group, &addr.ss, SocketAddress::GetAddrLength(addr));
   return setsockopt(handle->socket(),
                     proto,
                     MCAST_JOIN_GROUP,
                     reinterpret_cast<char *>(&mreq),
                     sizeof(mreq)) == 0;
 }
 
 
 bool Socket::LeaveMulticast(
-    intptr_t fd, RawAddr* addr, RawAddr*, int interfaceIndex) {
+    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;
+  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));
+  memmove(&mreq.gr_group, &addr.ss, SocketAddress::GetAddrLength(addr));
   return setsockopt(handle->socket(),
                     proto,
                     MCAST_LEAVE_GROUP,
                     reinterpret_cast<char *>(&mreq),
                     sizeof(mreq)) == 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)