POSIX: Add a macro for handling EINTR.

net/base/listen_socket.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 // winsock2.h must be included first in order to ensure it is included before
 // windows.h.
 #include <winsock2.h>
 #elif defined(OS_POSIX)
 #include <errno.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include "net/base/net_errors.h"
 #include "third_party/libevent/event.h"
 #endif
 
+#include "base/eintr_wrappers.h"
 #include "net/base/net_util.h"
 #include "net/base/listen_socket.h"
 
 #if defined(OS_WIN)
 #define socklen_t int
 #elif defined(OS_POSIX)
 const int INVALID_SOCKET = -1; // Used same name as in Windows to avoid #ifdef
 const int SOCKET_ERROR = -1;
 #endif
 
@@ skipping 57 matching lines @@
   listen(socket_, backlog);
   // TODO(erikkay): error handling
 #if defined(OS_POSIX)
   WatchSocket(WAITING_ACCEPT);
 #endif
 }
 
 SOCKET ListenSocket::Accept(SOCKET s) {
   sockaddr_in from;
   socklen_t from_len = sizeof(from);
-  SOCKET conn = accept(s, reinterpret_cast<sockaddr*>(&from), &from_len);
+  SOCKET conn =
+      HANDLE_EINTR(accept(s, reinterpret_cast<sockaddr*>(&from), &from_len));
   if (conn != INVALID_SOCKET) {
     net::SetNonBlocking(conn);
   }
   return conn;
 }
 
 void ListenSocket::Accept() {
   SOCKET conn = Accept(socket_);
   if (conn != INVALID_SOCKET) {
     scoped_refptr<ListenSocket> sock =
         new ListenSocket(conn, socket_delegate_);
     // it's up to the delegate to AddRef if it wants to keep it around
 #if defined(OS_POSIX)
     sock->WatchSocket(WAITING_READ);
 #endif
     socket_delegate_->DidAccept(this, sock);
   } else {
     // TODO(ibrar): some error handling required here
   }
 }
 
 void ListenSocket::Read() {
   char buf[kReadBufSize + 1]; // +1 for null termination
   int len;
   do {
-    len = recv(socket_, buf, kReadBufSize, 0);
+    len = HANDLE_EINTR(recv(socket_, buf, kReadBufSize, 0));
     if (len == SOCKET_ERROR) {
 #if defined(OS_WIN)
       int err = WSAGetLastError();
       if (err == WSAEWOULDBLOCK) {
 #elif defined(OS_POSIX)
       if (errno == EWOULDBLOCK || errno == EAGAIN) {
 #endif
         break;
       } else {
         // TODO(ibrar): some error handling required here
@@ skipping 48 matching lines @@
   watcher_.StartWatching(socket_event_, this);
 #elif defined(OS_POSIX)
   // Implicitly calls StartWatchingFileDescriptor().
   MessageLoopForIO::current()->WatchFileDescriptor(
       socket_, true, MessageLoopForIO::WATCH_READ, &watcher_, this);
   wait_state_ = state;
 #endif
 }
 
 void ListenSocket::SendInternal(const char* bytes, int len) {
-  int sent = send(socket_, bytes, len, 0);
+  int sent = HANDLE_EINTR(send(socket_, bytes, len, 0));
   if (sent == SOCKET_ERROR) {
 #if defined(OS_WIN)
   int err = WSAGetLastError();
   if (err == WSAEWOULDBLOCK) {
 #elif defined(OS_POSIX)
     if (errno == EWOULDBLOCK || errno == EAGAIN) {
 #endif
     // TODO (ibrar): there should be logic here to handle this because
     // it is not an error
     }
@@ skipping 55 matching lines @@
   }
 }
 
 void ListenSocket::OnFileCanWriteWithoutBlocking(int fd) {
   // MessagePumpLibevent callback, we don't listen for write events
   // so we shouldn't ever reach here.
   NOTREACHED();
 }
 
 #endif