[dart:io] Don't close stdin with a socket finalizer

runtime/bin/socket.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 "bin/socket.h"
 
 #include "bin/dartutils.h"
 #include "bin/eventhandler.h"
@@ skipping 129 matching lines @@
         // created the socket. We therefore increment the refcount and reuse
         // the file descriptor.
         os_socket->ref_count++;
 
         // The same Socket is used by a second Dart _NativeSocket object.
         // It Retains a reference.
         os_socket->socketfd->Retain();
         // We set as a side-effect the file descriptor on the dart
         // socket_object.
         Socket::ReuseSocketIdNativeField(socket_object, os_socket->socketfd,
-                                         true);
+                                         Socket::kFinalizerListening);
 
         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);
@@ skipping 31 matching lines @@
   Socket* socketfd = new Socket(fd);
   OSSocket* os_socket =
       new OSSocket(addr, allocated_port, v6_only, shared, socketfd);
   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, true);
+  Socket::ReuseSocketIdNativeField(socket_object, socketfd,
+                                   Socket::kFinalizerListening);
 
   return Dart_True();
 }
 
 
 bool ListeningSocketRegistry::CloseOneSafe(OSSocket* os_socket,
                                            bool update_hash_maps) {
   ASSERT(!mutex_->TryLock());
   ASSERT(os_socket != NULL);
   ASSERT(os_socket->ref_count > 0);
@@ skipping 85 matching lines @@
 void FUNCTION_NAME(Socket_CreateConnect)(Dart_NativeArguments args) {
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
   int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
   SocketAddress::SetAddrPort(&addr, static_cast<intptr_t>(port));
   intptr_t socket = Socket::CreateConnect(addr);
   OSError error;
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket,
-                                   false);
+                                   Socket::kFinalizerNormal);
     Dart_SetReturnValue(args, Dart_True());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
   }
 }
 
 
 void FUNCTION_NAME(Socket_CreateBindConnect)(Dart_NativeArguments args) {
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
   int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
   SocketAddress::SetAddrPort(&addr, static_cast<intptr_t>(port));
   RawAddr sourceAddr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 3), &sourceAddr);
   intptr_t socket = Socket::CreateBindConnect(addr, sourceAddr);
   OSError error;
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket,
-                                   false);
+                                   Socket::kFinalizerNormal);
     Dart_SetReturnValue(args, Dart_True());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
   }
 }
 
 void FUNCTION_NAME(Socket_IsBindError)(Dart_NativeArguments args) {
   intptr_t error_number =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 1));
   bool is_bind_error = Socket::IsBindError(error_number);
   Dart_SetReturnValue(args, is_bind_error ? Dart_True() : Dart_False());
 }
 
 void FUNCTION_NAME(Socket_CreateBindDatagram)(Dart_NativeArguments args) {
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
   int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
   SocketAddress::SetAddrPort(&addr, port);
   bool reuse_addr = DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 3));
   intptr_t socket = Socket::CreateBindDatagram(addr, reuse_addr);
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket,
-                                   false);
+                                   Socket::kFinalizerNormal);
     Dart_SetReturnValue(args, Dart_True());
   } else {
     OSError error;
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
   }
 }
 
 
 void FUNCTION_NAME(Socket_Available)(Dart_NativeArguments args) {
   Socket* socket =
@@ skipping 258 matching lines @@
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
 void FUNCTION_NAME(Socket_GetStdioHandle)(Dart_NativeArguments args) {
   int64_t num =
       DartUtils::GetInt64ValueCheckRange(Dart_GetNativeArgument(args, 1), 0, 2);
   intptr_t socket = Socket::GetStdioHandle(num);
   Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket,
-                                 false);
+                                 Socket::kFinalizerStdio);
   Dart_SetReturnValue(args, Dart_NewBoolean(socket >= 0));
 }
 
 
 void FUNCTION_NAME(Socket_GetSocketId)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   intptr_t id = reinterpret_cast<intptr_t>(socket);
   Dart_SetReturnValue(args, Dart_NewInteger(id));
 }
 
 
 void FUNCTION_NAME(Socket_SetSocketId)(Dart_NativeArguments args) {
   intptr_t id = DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 1));
-  Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), id, false);
+  Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), id,
+                                 Socket::kFinalizerNormal);
 }
 
 
 void FUNCTION_NAME(ServerSocket_CreateBindListen)(Dart_NativeArguments args) {
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   int64_t port = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 2), 0, 65535);
   SocketAddress::SetAddrPort(&addr, port);
   int64_t backlog = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 3), 0, 65535);
   bool v6_only = DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 4));
   bool shared = DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 5));
 
   Dart_Handle socket_object = Dart_GetNativeArgument(args, 0);
   Dart_Handle result = ListeningSocketRegistry::Instance()->CreateBindListen(
       socket_object, addr, backlog, v6_only, shared);
   Dart_SetReturnValue(args, result);
 }
 
 
 void FUNCTION_NAME(ServerSocket_Accept)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   intptr_t new_socket = ServerSocket::Accept(socket->fd());
   if (new_socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 1), new_socket,
-                                   false);
+                                   Socket::kFinalizerNormal);
     Dart_SetReturnValue(args, Dart_True());
   } else if (new_socket == ServerSocket::kTemporaryFailure) {
     Dart_SetReturnValue(args, Dart_False());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
 CObject* Socket::LookupRequest(const CObjectArray& request) {
@@ skipping 252 matching lines @@
   int interfaceIndex =
       DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 3));
   if (Socket::LeaveMulticast(socket->fd(), addr, interface, interfaceIndex)) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
-static void SocketFinalizer(void* isolate_data,
-                            Dart_WeakPersistentHandle handle,
-                            void* data) {
+static void NormalSocketFinalizer(void* isolate_data,
+                                  Dart_WeakPersistentHandle handle,
+                                  void* data) {
   Socket* socket = reinterpret_cast<Socket*>(data);
   if (socket->fd() >= 0) {
     const int64_t flags = 1 << kCloseCommand;
     socket->Retain();
     EventHandler::SendFromNative(reinterpret_cast<intptr_t>(socket),
                                  socket->port(), flags);
   }
   socket->Release();
 }
 
 
 static void ListeningSocketFinalizer(void* isolate_data,
                                      Dart_WeakPersistentHandle handle,
                                      void* data) {
   Socket* socket = reinterpret_cast<Socket*>(data);
   if (socket->fd() >= 0) {
     const int64_t flags = (1 << kListeningSocket) | (1 << kCloseCommand);
     socket->Retain();
     EventHandler::SendFromNative(reinterpret_cast<intptr_t>(socket),
                                  socket->port(), flags);
   }
   socket->Release();
 }
 
 
+static void StdioSocketFinalizer(void* isolate_data,
+                                 Dart_WeakPersistentHandle handle,
+                                 void* data) {
+  Socket* socket = reinterpret_cast<Socket*>(data);
+  if (socket->fd() >= 0) {
+    socket->SetClosedFd();
+  }
+  socket->Release();
+}
+
+
 void Socket::ReuseSocketIdNativeField(Dart_Handle handle,
                                       Socket* socket,
-                                      bool listening) {
+                                      SocketFinalizer finalizer) {
   Dart_Handle err = Dart_SetNativeInstanceField(
       handle, kSocketIdNativeField, reinterpret_cast<intptr_t>(socket));
   if (Dart_IsError(err)) {
     Dart_PropagateError(err);
   }
-  if (listening) {
+  Dart_WeakPersistentHandleFinalizer callback;
+  switch (finalizer) {
+    case kFinalizerNormal:
+      callback = NormalSocketFinalizer;
+      break;
+    case kFinalizerListening:
+      callback = ListeningSocketFinalizer;
+      break;
+    case kFinalizerStdio:
+      callback = StdioSocketFinalizer;
+      break;
+    default:
+      callback = NULL;
+      UNREACHABLE();
+      break;
+  }
+  if (callback != NULL) {
     Dart_NewWeakPersistentHandle(handle, reinterpret_cast<void*>(socket),
-                                 sizeof(Socket), ListeningSocketFinalizer);
-  } else {
-    Dart_NewWeakPersistentHandle(handle, reinterpret_cast<void*>(socket),
-                                 sizeof(Socket), SocketFinalizer);
+                                 sizeof(Socket), callback);
   }
 }
 
 
 void Socket::SetSocketIdNativeField(Dart_Handle handle,
                                     intptr_t id,
-                                    bool listening) {
+                                    SocketFinalizer finalizer) {
   Socket* socket = new Socket(id);
-  ReuseSocketIdNativeField(handle, socket, listening);
+  ReuseSocketIdNativeField(handle, socket, finalizer);
 }
 
 
 Socket* Socket::GetSocketIdNativeField(Dart_Handle socket_obj) {
   intptr_t id;
   Dart_Handle err =
       Dart_GetNativeInstanceField(socket_obj, kSocketIdNativeField, &id);
   if (Dart_IsError(err)) {
     Dart_PropagateError(err);
   }
   Socket* socket = reinterpret_cast<Socket*>(id);
   return socket;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // !defined(DART_IO_DISABLED)