Extend dart:io error handling to all socket functions

runtime/bin/eventhandler_macos.cc

 // Copyright (c) 2012, 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 "bin/eventhandler.h"
 
 #include <errno.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
@@ skipping 214 matching lines @@
         delete sd;
       } else {
         // Setup events to wait for.
         sd->SetPortAndMask(msg.dart_port, msg.data);
         UpdateKqueue(kqueue_fd_, sd);
       }
     }
   }
 }
 
-
 #ifdef DEBUG_KQUEUE
 static void PrintEventMask(intptr_t fd, struct kevent* event) {
-  printf("%d ", fd);
+  printf("%d ", static_cast<int>(fd));
   if (event->filter == EVFILT_READ) printf("EVFILT_READ ");
   if (event->filter == EVFILT_WRITE) printf("EVFILT_WRITE ");
   printf("flags: %x: ", event->flags);
   if ((event->flags & EV_EOF) != 0) printf("EV_EOF ");
   if ((event->flags & EV_ERROR) != 0) printf("EV_ERROR ");
-  printf("(available %d) ", FDUtils::AvailableBytes(fd));
+  printf("- fflags: %d ", event->fflags);
+  printf("(available %d) ", static_cast<int>(FDUtils::AvailableBytes(fd)));
   printf("\n");
 }
 #endif
 
 
 intptr_t EventHandlerImplementation::GetEvents(struct kevent* event,
                                                SocketData* sd) {
 #ifdef DEBUG_KQUEUE
   PrintEventMask(sd->fd(), event);
 #endif
   intptr_t event_mask = 0;
   if (sd->IsListeningSocket()) {
     // On a listening socket the READ event means that there are
     // connections ready to be accepted.
     if (event->filter == EVFILT_READ) {
-      if ((event->flags & EV_EOF) != 0) event_mask |= (1 << kCloseEvent);
-      if ((event->flags & EV_ERROR) != 0) event_mask |= (1 << kErrorEvent);
+      if ((event->flags & EV_EOF) != 0) {
+        if (event->fflags != 0) {
+          event_mask |= (1 << kErrorEvent);
+        } else {
+          event_mask |= (1 << kCloseEvent);
+        }
+      }
       if (event_mask == 0) event_mask |= (1 << kInEvent);
     }
   } else {
     // Prioritize data events over close and error events.
     if (event->filter == EVFILT_READ) {
       if (FDUtils::AvailableBytes(sd->fd()) != 0) {
          event_mask = (1 << kInEvent);
       } else if ((event->flags & EV_EOF) != 0) {
-        event_mask = (1 << kCloseEvent);
+        if (event->fflags != 0) {
+          event_mask |= (1 << kErrorEvent);
+        } else {
+          event_mask |= (1 << kCloseEvent);
+        }
         sd->MarkClosedRead();
-      } else if ((event->flags & EV_ERROR) != 0) {
-        event_mask = (1 << kErrorEvent);
       }
     }
 
     if (event->filter == EVFILT_WRITE) {
-      if ((event->flags & EV_ERROR) != 0) {
-        event_mask = (1 << kErrorEvent);
-        sd->MarkClosedWrite();
-      } else if ((event->flags & EV_EOF) != 0) {
+      if ((event->flags & EV_EOF) != 0) {
+        if (event->fflags != 0) {
+          event_mask |= (1 << kErrorEvent);
+        } else {
+          event_mask |= (1 << kCloseEvent);
+        }
         // If the receiver closed for reading, close for writing,
         // update the registration with kqueue, and do not report a
         // write event.
         sd->MarkClosedWrite();
         UpdateKqueue(kqueue_fd_, sd);
       } else {
         event_mask |= (1 << kOutEvent);
       }
     }
   }
 
   return event_mask;
 }
 
 
 void EventHandlerImplementation::HandleEvents(struct kevent* events,
                                               int size) {
   for (int i = 0; i < size; i++) {
+    // If flag EV_ERROR is set it indicates an error in kevent processing.
+    if ((events[i].flags & EV_ERROR) != 0) {
+      FATAL1("kevent failed %s\n", strerror(events[i].data));
+    }
     if (events[i].udata != NULL) {
       SocketData* sd = reinterpret_cast<SocketData*>(events[i].udata);
       intptr_t event_mask = GetEvents(events + i, sd);
       if (event_mask != 0) {
         // Unregister events for the file descriptor. Events will be
         // registered again when the current event has been handled in
         // Dart code.
         RemoveFromKqueue(kqueue_fd_, sd);
         Dart_Port port = sd->port();
         ASSERT(port != 0);
@@ skipping 43 matching lines @@
       ts.tv_nsec = (millis - (ts.tv_sec * 1000)) * 1000000;
       timeout = &ts;
     }
     intptr_t result = TEMP_FAILURE_RETRY(kevent(handler->kqueue_fd_,
                                                 NULL,
                                                 0,
                                                 events,
                                                 kMaxEvents,
                                                 timeout));
     if (result == -1) {
-      perror("kevent failed");
-      FATAL("kevent failed\n");
+      FATAL1("kevent failed %s\n", strerror(errno));
     } else {
       handler->HandleTimeout();
       handler->HandleEvents(events, result);
     }
   }
 }
 
 
 void EventHandlerImplementation::StartEventHandler() {
   int result =
@@ skipping 15 matching lines @@
 void* EventHandlerImplementation::GetHashmapKeyFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return reinterpret_cast<void*>(fd + 1);
 }
 
 
 uint32_t EventHandlerImplementation::GetHashmapHashFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return dart::Utils::WordHash(fd + 1);
 }