Reland "Introduce optional 'bool shared' parameter to ServerSocket.bind() ..."

dart/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 BIN_SOCKET_H_
 #define BIN_SOCKET_H_
 
+#include <map>
+
 #include "platform/globals.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 // Declare the OS-specific types ahead of defining the generic class.
 #if defined(TARGET_OS_ANDROID)
 #include "bin/socket_android.h"
 #elif defined(TARGET_OS_LINUX)
 #include "bin/socket_linux.h"
 #elif defined(TARGET_OS_MACOS)
@@ skipping 51 matching lines @@
     return addr->ss.ss_family == AF_INET6 ?
         sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
   }
 
   static intptr_t GetInAddrLength(const RawAddr* addr) {
     ASSERT(addr->ss.ss_family == AF_INET || addr->ss.ss_family == AF_INET6);
     return addr->ss.ss_family == AF_INET6 ?
         sizeof(struct in6_addr) : sizeof(struct in_addr);
   }
 
+  static bool AreAddressesEqual(const RawAddr& a, const RawAddr& b) {
+    if (a.ss.ss_family == AF_INET) {
+      if (b.ss.ss_family != AF_INET) return false;
+      return memcmp(&a.in.sin_addr, &b.in.sin_addr, sizeof(a.in.sin_addr)) == 0;
+    } else if (a.ss.ss_family == AF_INET6) {
+      if (b.ss.ss_family != AF_INET6) return false;
+      return memcmp(&a.in6.sin6_addr,
+                    &b.in6.sin6_addr,
+                    sizeof(a.in6.sin6_addr)) == 0;
+    } else {
+      UNREACHABLE();
+      return false;
+    }
+  }
+
   static void GetSockAddr(Dart_Handle obj, RawAddr* addr) {
     Dart_TypedData_Type data_type;
     uint8_t* data = NULL;
     intptr_t len;
     Dart_Handle result = Dart_TypedDataAcquireData(
         obj, &data_type, reinterpret_cast<void**>(&data), &len);
     if (Dart_IsError(result)) Dart_PropagateError(result);
     if (data_type != Dart_TypedData_kUint8 ||
         (len != sizeof(in_addr) && len != sizeof(in6_addr))) {
       Dart_PropagateError(
@@ skipping 124 matching lines @@
 
 class Socket {
  public:
   enum SocketRequest {
     kLookupRequest = 0,
     kListInterfacesRequest = 1,
     kReverseLookupRequest = 2,
   };
 
   static bool Initialize();
+  static bool InitializeOS();
   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);
   static intptr_t SendTo(
       intptr_t fd, const void* buffer, intptr_t num_bytes, RawAddr addr);
   static intptr_t RecvFrom(
       intptr_t fd, void* buffer, intptr_t num_bytes, RawAddr* addr);
   static intptr_t CreateConnect(const RawAddr& addr,
                                 const intptr_t port);
   static intptr_t CreateBindConnect(const RawAddr& addr,
@@ skipping 71 matching lines @@
 
   // Start accepting on a newly created listening socket. If it was unable to
   // start accepting incoming sockets, the fd is invalidated.
   static bool StartAccept(intptr_t fd);
 
  private:
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(ServerSocket);
 };
 
+class ListeningSocketRegistry {
+ private:
+  struct OSSocket {
+    RawAddr address;
+    int port;
+    bool v6_only;
+    bool shared;
+    int ref_count;
+    intptr_t 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)
+        : address(address), port(port), v6_only(v6_only), shared(shared),
+          ref_count(0), socketfd(socketfd), next(NULL) {}
+  };
+
+ public:
+  static bool Initialize();
+
+  static ListeningSocketRegistry *Instance();
+
+  static void Cleanup();
+
+
+  ListeningSocketRegistry() : mutex_(new Mutex()) {}
+
+  ~ListeningSocketRegistry() {
+    delete mutex_;
+    mutex_ = NULL;
+  }
+
+  // This function should be called from a dart runtime call in order to create
+  // a new (potentially shared) socket.
+  Dart_Handle CreateBindListen(Dart_Handle socket_object,
+                               RawAddr addr,
+                               intptr_t port,
+                               intptr_t backlog,
+                               bool v6_only,
+                               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);
+
+  // Mark an existing socket as sharable if it is not already marked as
+  // sharable.
+  //
+  // NOTE: This is a temporary measure until ServerSocketReference's are
+  // removed.
+  Dart_Handle MarkSocketFdAsSharableHack(intptr_t socketfd);
+
+  Mutex *mutex() { return mutex_; }
+
+ private:
+  OSSocket *findOSSocketWithAddress(OSSocket *current, const RawAddr& addr) {
+    while (current != NULL) {
+      if (SocketAddress::AreAddressesEqual(current->address, addr)) {
+        return current;
+      }
+      current = current->next;
+    }
+    return NULL;
+  }
+
+  std::map<intptr_t, OSSocket*> sockets_by_port_;
+  std::map<intptr_t, OSSocket*> sockets_by_fd_;
+  Mutex *mutex_;
+
+  typedef std::map<intptr_t, OSSocket*>::iterator SocketsIterator;
+};
+
+
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_SOCKET_H_