[dart:io] Adds a finalizer to _NativeSocket to avoid socket leaks

runtime/bin/socket.h

 // 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.
 
 #ifndef RUNTIME_BIN_SOCKET_H_
 #define RUNTIME_BIN_SOCKET_H_
 
 #if defined(DART_IO_DISABLED)
 #error "socket.h can only be included on builds with IO enabled"
 #endif
 
 #include "platform/globals.h"
 // Declare the OS-specific types ahead of defining the generic class.
 #if defined(HOST_OS_ANDROID)
 #include "bin/socket_android.h"
 #elif defined(HOST_OS_FUCHSIA)
 #include "bin/socket_fuchsia.h"
 #elif defined(HOST_OS_LINUX)
 #include "bin/socket_linux.h"
 #elif defined(HOST_OS_MACOS)
 #include "bin/socket_macos.h"
 #elif defined(HOST_OS_WINDOWS)
 #include "bin/socket_win.h"
 #else
 #error Unknown target os.
 #endif
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
+#include "bin/reference_counting.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "platform/hashmap.h"
 
 namespace dart {
 namespace bin {
 
 union RawAddr {
   struct sockaddr_in in;
   struct sockaddr_in6 in6;
@@ skipping 200 matching lines @@
   void SetAt(intptr_t i, T* addr) { addresses_[i] = addr; }
 
  private:
   const intptr_t count_;
   T** addresses_;
 
   DISALLOW_COPY_AND_ASSIGN(AddressList);
 };
 
 
-class Socket {
+// We write Sockets into the native field of the _NativeSocket object
+// on the Dart side. They are allocated in SetSocketIdNativeField(), and are
+// deallocated either from the finalizer attached to _NativeSockets there, or
+// from the eventhandler, whichever drops the last reference.
+class Socket : public ReferenceCounted<Socket> {
  public:
   enum SocketRequest {
     kLookupRequest = 0,
     kListInterfacesRequest = 1,
     kReverseLookupRequest = 2,
   };
 
+  explicit Socket(intptr_t fd);
+
+  intptr_t fd() const { return fd_; }
+  void SetClosedFd();
+
+  Dart_Port port() const { return port_; }
+  void set_port(Dart_Port port) { port_ = port; }
+
+  // TODO(dart:io): Convert these to instance methods where possible.
   static bool Initialize();
   static intptr_t Available(intptr_t fd);
   static intptr_t Read(intptr_t fd, void* buffer, intptr_t num_bytes);
   static intptr_t Write(intptr_t fd, const void* buffer, intptr_t num_bytes);
   // Send data on a socket. The port to send to is specified in the port
   // component of the passed RawAddr structure. The RawAddr structure is only
   // used for datagram sockets.
   static intptr_t SendTo(intptr_t fd,
                          const void* buffer,
                          intptr_t num_bytes,
@@ skipping 58 matching lines @@
   static AddressList<InterfaceSocketAddress>* ListInterfaces(
       int type,
       OSError** os_error);
 
   static CObject* LookupRequest(const CObjectArray& request);
   static CObject* ListInterfacesRequest(const CObjectArray& request);
   static CObject* ReverseLookupRequest(const CObjectArray& request);
 
   static Dart_Port GetServicePort();
 
-  static void SetSocketIdNativeField(Dart_Handle socket, intptr_t id);
-  static intptr_t GetSocketIdNativeField(Dart_Handle socket);
+  static void SetSocketIdNativeField(Dart_Handle handle,
+                                     intptr_t id,
+                                     bool listening);
+  static void ReuseSocketIdNativeField(Dart_Handle handle,
+                                       Socket* socket,
+                                       bool listening);
+  static Socket* GetSocketIdNativeField(Dart_Handle socket);
 
  private:
-  DISALLOW_ALLOCATION();
-  DISALLOW_IMPLICIT_CONSTRUCTORS(Socket);
+  ~Socket() { ASSERT(fd_ == kClosedFd); }
+
+  static const int kClosedFd = -1;
+
+  intptr_t fd_;
+  Dart_Port port_;
+
+  friend class ReferenceCounted<Socket>;
+  DISALLOW_COPY_AND_ASSIGN(Socket);
 };
 
 
 class ServerSocket {
  public:
   static const intptr_t kTemporaryFailure = -2;
 
   static intptr_t Accept(intptr_t fd);
 
   // Creates a socket which is bound and listens. The port to listen on is
@@ skipping 46 matching lines @@
                                bool shared);
 
   // This should be called from the event handler for every kCloseEvent it gets
   // on listening sockets.
   //
   // Returns `true` if the last reference has been dropped and the underlying
   // socket can be closed.
   //
   // The caller is responsible for obtaining the mutex first, before calling
   // this function.
-  bool CloseSafe(intptr_t socketfd);
+  bool CloseSafe(Socket* socketfd);
 
   Mutex* mutex() { return mutex_; }
 
  private:
   struct OSSocket {
     RawAddr address;
     int port;
     bool v6_only;
     bool shared;
     int ref_count;
-    intptr_t socketfd;
+    Socket* socketfd;
 
     // Singly linked lists of OSSocket instances which listen on the same port
     // but on different addresses.
     OSSocket* next;
 
     OSSocket(RawAddr address,
              int port,
              bool v6_only,
              bool shared,
-             intptr_t socketfd)
+             Socket* socketfd)
         : address(address),
           port(port),
           v6_only(v6_only),
           shared(shared),
           ref_count(0),
           socketfd(socketfd),
           next(NULL) {}
   };
 
   static const intptr_t kInitialSocketsCount = 8;
 
-  OSSocket* findOSSocketWithAddress(OSSocket* current, const RawAddr& addr) {
+  OSSocket* FindOSSocketWithAddress(OSSocket* current, const RawAddr& addr) {
     while (current != NULL) {
       if (SocketAddress::AreAddressesEqual(current->address, addr)) {
         return current;
       }
       current = current->next;
     }
     return NULL;
   }
 
   static bool SameIntptrValue(void* key1, void* key2) {
     return reinterpret_cast<intptr_t>(key1) == reinterpret_cast<intptr_t>(key2);
   }
 
   static uint32_t GetHashmapHashFromIntptr(intptr_t i) {
     return static_cast<uint32_t>((i + 1) & 0xFFFFFFFF);
   }
 
 
   static void* GetHashmapKeyFromIntptr(intptr_t i) {
     return reinterpret_cast<void*>(i + 1);
   }
 
   OSSocket* LookupByPort(intptr_t port);
   void InsertByPort(intptr_t port, OSSocket* socket);
   void RemoveByPort(intptr_t port);
 
-  OSSocket* LookupByFd(intptr_t fd);
-  void InsertByFd(intptr_t fd, OSSocket* socket);
-  void RemoveByFd(intptr_t fd);
+  OSSocket* LookupByFd(Socket* fd);
+  void InsertByFd(Socket* fd, OSSocket* socket);
+  void RemoveByFd(Socket* fd);
 
   bool CloseOneSafe(OSSocket* os_socket, bool update_hash_maps);
   void CloseAllSafe();
 
   HashMap sockets_by_port_;
   HashMap sockets_by_fd_;
 
   Mutex* mutex_;
 
   DISALLOW_COPY_AND_ASSIGN(ListeningSocketRegistry);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // RUNTIME_BIN_SOCKET_H_