dart::bin::ListeningSocketRegistry Class Reference

#include <socket.h>

Public Member Functions
	ListeningSocketRegistry ()
	~ListeningSocketRegistry ()
Dart_Handle	CreateBindListen (Dart_Handle socket_object, RawAddr addr, intptr_t backlog, bool v6_only, bool shared)
Dart_Handle	CreateUnixDomainBindListen (Dart_Handle socket_object, Namespace *namespc, const char *path, intptr_t backlog, bool shared)
bool	CloseSafe (Socket *socketfd)
Mutex *	mutex ()

Static Public Member Functions
static void	Initialize ()
static ListeningSocketRegistry *	Instance ()
static void	Cleanup ()

Detailed Description

Definition at line 165 of file socket.h.

Constructor & Destructor Documentation

ListeningSocketRegistry()

dart::bin::ListeningSocketRegistry::ListeningSocketRegistry ( )

inline

Definition at line 167 of file socket.h.

      : sockets_by_port_(SameIntptrValue, kInitialSocketsCount),
        sockets_by_fd_(SameIntptrValue, kInitialSocketsCount),
        unix_domain_sockets_(nullptr),
        mutex_() {}

~ListeningSocketRegistry()

dart::bin::ListeningSocketRegistry::~ListeningSocketRegistry ( )

inline

Definition at line 173 of file socket.h.

{ CloseAllSafe(); }

Member Function Documentation

Cleanup()

void dart::bin::ListeningSocketRegistry::Cleanup ( )

static

Definition at line 42 of file socket.cc.

                                      {
  delete globalTcpListeningSocketRegistry;
  globalTcpListeningSocketRegistry = nullptr;
}

CloseSafe()

bool dart::bin::ListeningSocketRegistry::CloseSafe

(

Socket *

socketfd

)

Definition at line 350 of file socket.cc.

                                                        {
  ASSERT(!mutex_.TryLock());
  OSSocket* os_socket = LookupByFd(socketfd);
  if (os_socket != nullptr) {
    return CloseOneSafe(os_socket, socketfd);
  } else {
    // A finalizer may direct the event handler to close a listening socket
    // that it has never seen before. In this case, we return true to direct
    // the eventhandler to clean up the socket.
    return true;
  }
}

CreateBindListen()

Dart_Handle dart::bin::ListeningSocketRegistry::CreateBindListen	(	Dart_Handle	socket_object,
		RawAddr	addr,
		intptr_t	backlog,
		bool	v6_only,
		bool	shared
	)

Definition at line 94 of file socket.cc.

                                                                   {
  MutexLocker ml(&mutex_);
 
  OSSocket* first_os_socket = nullptr;
  intptr_t port = SocketAddress::GetAddrPort(addr);
  if (port > 0) {
    first_os_socket = LookupByPort(port);
    if (first_os_socket != nullptr) {
      // There is already a socket listening on this port. We need to ensure
      // that if there is one also listening on the same address, it was created
      // with `shared = true`, ...
      OSSocket* os_socket = first_os_socket;
      OSSocket* os_socket_same_addr = FindOSSocketWithAddress(os_socket, addr);
 
      if (os_socket_same_addr != nullptr) {
        if (!os_socket_same_addr->shared || !shared) {
          OSError os_error(-1,
                           "The shared flag to bind() needs to be `true` if "
                           "binding multiple times on the same (address, port) "
                           "combination.",
                           OSError::kUnknown);
          return DartUtils::NewDartOSError(&os_error);
        }
        if (os_socket_same_addr->v6_only != v6_only) {
          OSError os_error(-1,
                           "The v6Only flag to bind() needs to be the same if "
                           "binding multiple times on the same (address, port) "
                           "combination.",
                           OSError::kUnknown);
          return DartUtils::NewDartOSError(&os_error);
        }
 
        // This socket creation is the exact same as the one which originally
        // created the socket. Feed same fd and store it into native field
        // of dart socket_object. Sockets here will share same fd but contain a
        // different port() through EventHandler_SendData.
        Socket* socketfd = new Socket(os_socket_same_addr->fd);
        os_socket_same_addr->ref_count++;
        // We set as a side-effect the file descriptor on the dart
        // socket_object.
        Socket::ReuseSocketIdNativeField(socket_object, socketfd,
                                         Socket::kFinalizerListening);
        InsertByFd(socketfd, os_socket_same_addr);
        return Dart_True();
      }
    }
  }
 
  // There is no socket listening on that (address, port), so we create new one.
  intptr_t fd = ServerSocket::CreateBindListen(addr, backlog, v6_only);
  if (fd == -5) {
    OSError os_error(-1, "Invalid host", OSError::kUnknown);
    return DartUtils::NewDartOSError(&os_error);
  }
  if (fd < 0) {
    OSError error;
    return DartUtils::NewDartOSError(&error);
  }
  if (!ServerSocket::StartAccept(fd)) {
    OSError os_error(-1, "Failed to start accept", OSError::kUnknown);
    return DartUtils::NewDartOSError(&os_error);
  }
  intptr_t allocated_port = SocketBase::GetPort(fd);
  ASSERT(allocated_port > 0);
 
  if (allocated_port != port) {
    // There are two cases to consider:
    //
    //   a) The user requested (address, port) where port != 0 which means
    //      we re-use an existing socket if available (and it is shared) or we
    //      create a new one. The new socket is guaranteed to have that
    //      selected port.
    //
    //   b) The user requested (address, 0). This will make us *always* create a
    //      new socket. The OS will assign it a new `allocated_port` and we will
    //      insert into our data structures. *BUT* There might already be an
    //      existing (address2, `allocated_port`) where address != address2. So
    //      we need to do another `LookupByPort(allocated_port)` and link them
    //      via `OSSocket->next`.
    ASSERT(port == 0);
    first_os_socket = LookupByPort(allocated_port);
  }
 
  Socket* socketfd = new Socket(fd);
  OSSocket* os_socket =
      new OSSocket(addr, allocated_port, v6_only, shared, socketfd, nullptr);
  os_socket->ref_count = 1;
  os_socket->next = first_os_socket;
 
  InsertByPort(allocated_port, os_socket);
  InsertByFd(socketfd, os_socket);
 
  // We set as a side-effect the port on the dart socket_object.
  Socket::ReuseSocketIdNativeField(socket_object, socketfd,
                                   Socket::kFinalizerListening);
 
  return Dart_True();
}

CreateUnixDomainBindListen()

Dart_Handle dart::bin::ListeningSocketRegistry::CreateUnixDomainBindListen	(	Dart_Handle	socket_object,
		Namespace *	namespc,
		const char *	path,
		intptr_t	backlog,
		bool	shared
	)

Definition at line 197 of file socket.cc.

                 {
  MutexLocker ml(&mutex_);
 
  RawAddr addr;
  Dart_Handle result =
      SocketAddress::GetUnixDomainSockAddr(path, namespc, &addr);
  if (!Dart_IsNull(result)) {
    return result;
  }
 
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_ANDROID)
  // Abstract unix domain socket doesn't exist in file system.
  if (File::Exists(namespc, addr.un.sun_path) && path[0] != '@') {
#else
  if (File::Exists(namespc, addr.un.sun_path)) {
#endif  // defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_ANDROID)
    if (unix_domain_sockets_ != nullptr) {
      // If there is a socket listening on this file. Ensure
      // that it was created with `shared` mode and current `shared`
      // is also true.
      OSSocket* os_socket = unix_domain_sockets_;
      OSSocket* os_socket_same_addr =
          FindOSSocketWithPath(os_socket, namespc, addr.un.sun_path);
      if (os_socket_same_addr != nullptr) {
        if (!os_socket_same_addr->shared || !shared) {
          OSError os_error(-1,
                           "The shared flag to bind() needs to be `true` if "
                           "binding multiple times on the same path.",
                           OSError::kUnknown);
          return DartUtils::NewDartOSError(&os_error);
        }
 
        // This socket creation is the exact same as the one which originally
        // created the socket. Feed the same fd and store it into the native
        // field of dart socket_object. Sockets here will share same fd but
        // contain a different port() through EventHandler_SendData.
        Socket* socketfd = new Socket(os_socket_same_addr->fd);
        os_socket_same_addr->ref_count++;
        // We set as a side-effect the file descriptor on the dart
        // socket_object.
        Socket::ReuseSocketIdNativeField(socket_object, socketfd,
                                         Socket::kFinalizerListening);
        InsertByFd(socketfd, os_socket_same_addr);
        return Dart_True();
      }
    }
    // Unix domain socket by default doesn't allow binding to an existing file.
    // An error (EADDRINUSE) will be returned back. However, hanging is noticed
    // on Android so we throw an exception for all platforms.
    OSError os_error(-1, "File exists with given unix domain address",
                     OSError::kUnknown);
    return DartUtils::NewDartOSError(&os_error);
  }
 
  // There is no socket listening on that path, so we create new one.
  intptr_t fd = ServerSocket::CreateUnixDomainBindListen(addr, backlog);
 
  if (fd < 0) {
    return DartUtils::NewDartOSError();
  }
 
  Socket* socketfd = new Socket(fd);
  OSSocket* os_socket =
      new OSSocket(addr, -1, false, shared, socketfd, namespc);
  os_socket->ref_count = 1;
  os_socket->next = unix_domain_sockets_;
  unix_domain_sockets_ = os_socket;
  InsertByFd(socketfd, os_socket);
 
  Socket::ReuseSocketIdNativeField(socket_object, socketfd,
                                   Socket::kFinalizerListening);
 
  return Dart_True();
}

Initialize()

void dart::bin::ListeningSocketRegistry::Initialize ( )

static

Definition at line 33 of file socket.cc.

                                         {
  ASSERT(globalTcpListeningSocketRegistry == nullptr);
  globalTcpListeningSocketRegistry = new ListeningSocketRegistry();
}

Instance()

ListeningSocketRegistry * dart::bin::ListeningSocketRegistry::Instance ( )

static

Definition at line 38 of file socket.cc.

                                                           {
  return globalTcpListeningSocketRegistry;
}

mutex()

Mutex * dart::bin::ListeningSocketRegistry::mutex ( )

inline

Definition at line 210 of file socket.h.

{ return &mutex_; }

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/bin/socket.h
• third_party/dart-lang/sdk/runtime/bin/socket.cc