Change the handling of closing sockets

runtime/bin/eventhandler_win.cc

 // Copyright (c) 2011, 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 <process.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <mswsock.h>
 
 #include "bin/builtin.h"
@@ skipping 324 matching lines @@
 
   pending_accept_count_++;
 
   return true;
 }
 
 
 void ListenSocket::AcceptComplete(IOBuffer* buffer, HANDLE completion_port) {
   ScopedLock lock(this);
   if (!closing_) {
-    ClientSocket* client_socket = new ClientSocket(buffer->client(), 0);
-    client_socket->CreateCompletionPort(completion_port);
-    if (accepted_head_ == NULL) {
-      accepted_head_ = client_socket;
-      accepted_tail_ = client_socket;
+    // Update the accepted socket to support the full range of API calls.
+    SOCKET s = socket();
+    int rc = setsockopt(buffer->client(),
+                        SOL_SOCKET,
+                        SO_UPDATE_ACCEPT_CONTEXT,
+                        reinterpret_cast<char *>(&s), sizeof(s));

[Mads Ager (google), 2011/11/04 12:21:36]

char * -> char*

[Søren Gjesse, 2011/11/04 12:33:02]

Done.

+    if (rc == NO_ERROR) {
+      // Insert the accepted socket into the list.
+      ClientSocket* client_socket = new ClientSocket(buffer->client(), 0);
+      client_socket->CreateCompletionPort(completion_port);
+      if (accepted_head_ == NULL) {
+        accepted_head_ = client_socket;
+        accepted_tail_ = client_socket;
+      } else {
+        ASSERT(accepted_tail_ != NULL);
+        accepted_tail_->set_next(client_socket);
+        accepted_tail_ = client_socket;
+      }
     } else {
-      ASSERT(accepted_tail_ != NULL);
-      accepted_tail_->set_next(client_socket);
-      accepted_tail_ = client_socket;
+      fprintf(stderr, "setsockopt failed: %d\n", WSAGetLastError());
+      closesocket(buffer->client());
     }
-  } else {
-    closesocket(buffer->client());
   }
+
   pending_accept_count_--;
   IOBuffer::DisposeBuffer(buffer);
 }
 
 
 ClientSocket* ListenSocket::Accept() {
   ScopedLock lock(this);
   if (accepted_head_ == NULL) return NULL;
   ClientSocket* result = accepted_head_;
   accepted_head_ = accepted_head_->next();
   if (accepted_head_ == NULL) accepted_tail_ = NULL;
+  result->set_next(NULL);
   return result;
 }
 
 
 void ListenSocket::EnsureInitialized(
     EventHandlerImplementation* event_handler) {
   ScopedLock lock(this);
   if (AcceptEx_ == NULL) {
     ASSERT(completion_port_ == INVALID_HANDLE_VALUE);
     ASSERT(event_handler_ == NULL);
@@ skipping 47 matching lines @@
   ScopedLock lock(this);
   if (pending_write_ != NULL) return 0;
   if (completion_port_ == INVALID_HANDLE_VALUE) return 0;
   if (num_bytes > 4096) num_bytes = 4096;
   pending_write_ = IOBuffer::AllocateWriteBuffer(num_bytes);
   pending_write_->Write(buffer, num_bytes);
   IssueWrite();
   return num_bytes;
 }
 
+void ClientSocket::Shutdown(int how) {
+  int rc = shutdown(socket(), how);
+  if (rc == SOCKET_ERROR) {
+    fprintf(stderr, "shutdown failed: %d %d\n", socket(), WSAGetLastError());
+  }
+  if (how == SD_RECEIVE) MarkClosedRead();
+  if (how == SD_SEND) MarkClosedWrite();
+  if (how == SD_BOTH) {
+    MarkClosedRead();
+    MarkClosedWrite();
+  }
+}
+
 
 bool ClientSocket::IssueRead() {
   ScopedLock lock(this);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_read_ == NULL);
 
   IOBuffer* buffer = IOBuffer::AllocateReadBuffer(1024);
 
   DWORD flags;
   flags = 0;
@@ skipping 101 matching lines @@
         }
       }
     } else {
       ClientSocket* client_socket =
           reinterpret_cast<ClientSocket*>(socket_desc);
       client_socket->SetPortAndMask(msg->dart_port, msg->data);
       client_socket->EnsureInitialized(this);
 
       Handle::ScopedLock lock(client_socket);
 
-      // If data available callback has been requested and data are
+      // If the data available callback has been requested and data are
       // available post it immediately. Otherwise make sure that a pending
-      // read is issued.
+      // read is issued unless the socket is already closed for read.
       if ((msg->data & (1 << kInEvent)) != 0) {
         if (client_socket->Available() > 0) {
           int event_mask = (1 << kInEvent);
           Dart_PostIntArray(client_socket->port(), 1, &event_mask);
-        } else if (!client_socket->HasPendingRead()) {
+        } else if (!client_socket->HasPendingRead() &&
+                   !client_socket->IsClosedRead()) {
           client_socket->IssueRead();
         }
       }
 
       // If can send callback had been requested and there is no pending
       // send post it immediately.
       if ((msg->data & (1 << kOutEvent)) != 0) {
         if (!client_socket->HasPendingWrite()) {
           int event_mask = (1 << kOutEvent);
           Dart_PostIntArray(client_socket->port(), 1, &event_mask);
         }
       }
 
+      if ((msg->data & (1 << kShutdownReadCommand)) != 0) {
+        client_socket->Shutdown(SD_RECEIVE);
+      }
+
+      if ((msg->data & (1 << kShutdownWriteCommand)) != 0) {
+        client_socket->Shutdown(SD_SEND);
+      }
+
       if ((msg->data & (1 << kCloseCommand)) != 0) {
         client_socket->close();
         if (client_socket->IsClosed()) {
           delete_socket = true;
         }
       }
     }
     if (delete_socket) {
       delete socket_desc;
     }
@@ skipping 26 matching lines @@
     }
   }
 }
 
 
 void EventHandlerImplementation::HandleRead(ClientSocket* client_socket,
                                             int bytes,
                                             IOBuffer* buffer) {
   buffer->set_data_length(bytes);
   client_socket->ReadComplete(buffer);
-
   if (bytes > 0) {
     if (!client_socket->is_closing()) {
       int event_mask = 1 << kInEvent;
       if ((client_socket->mask() & event_mask) != 0) {
         Dart_PostIntArray(client_socket->port(), 1, &event_mask);
       }
     }
   } else {
     ASSERT(bytes == 0);
+    client_socket->MarkClosedRead();
     HandleClosed(client_socket);
   }
 
   if (client_socket->IsClosed()) {
     delete client_socket;
   }
 }
 
 
 void EventHandlerImplementation::HandleWrite(ClientSocket* client_socket,
@@ skipping 148 matching lines @@
       _beginthreadex(NULL, 32 * 1024, EventHandlerThread, this, 0, &tid);
   if (thread_handle == -1) {
     FATAL("Failed to start event handler thread");
   }
 
   // Initialize Winsock32
   if (!Socket::Initialize()) {
     FATAL("Failed to initialized Windows sockets");
   }
 }