POSIX: Add a macro for handling EINTR.

chrome/common/ipc_channel_posix.cc

 // Copyright (c) 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 "chrome/common/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/un.h>
 
 #include <string>
 #include <map>
 
 #include "base/command_line.h"
+#include "base/eintr_wrappers.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/singleton.h"
 #include "base/stats_counters.h"
 #include "chrome/common/chrome_counters.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/file_descriptor_set_posix.h"
@@ skipping 103 matching lines @@
   }
 
   // Create socket.
   int fd = socket(AF_UNIX, SOCK_STREAM, 0);
   if (fd < 0) {
     return false;
   }
 
   // Make socket non-blocking
   if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
-    close(fd);
+    HANDLE_EINTR(close(fd));
     return false;
   }
 
   // Delete any old FS instances.
   unlink(pipe_name.c_str());
 
   // Create unix_addr structure
   struct sockaddr_un unix_addr;
   memset(&unix_addr, 0, sizeof(unix_addr));
   unix_addr.sun_family = AF_UNIX;
   snprintf(unix_addr.sun_path, kMaxPipeNameLength, "%s", pipe_name.c_str());
   size_t unix_addr_len = offsetof(struct sockaddr_un, sun_path) +
       strlen(unix_addr.sun_path) + 1;
 
   // Bind the socket.
   if (bind(fd, reinterpret_cast<const sockaddr*>(&unix_addr),
            unix_addr_len) != 0) {
-    close(fd);
+    HANDLE_EINTR(close(fd));
     return false;
   }
 
   // Start listening on the socket.
   const int listen_queue_length = 1;
   if (listen(fd, listen_queue_length) != 0) {
-    close(fd);
+    HANDLE_EINTR(close(fd));
     return false;
   }
 
   *server_listen_fd = fd;
   return true;
 }
 
 // Accept a connection on a fifo.
 bool ServerAcceptFifoConnection(int server_listen_fd, int* server_socket) {
   DCHECK(server_socket);
 
-  int accept_fd = accept(server_listen_fd, NULL, 0);
+  int accept_fd = HANDLE_EINTR(accept(server_listen_fd, NULL, 0));
   if (accept_fd < 0)
     return false;
   if (fcntl(accept_fd, F_SETFL, O_NONBLOCK) == -1) {
-    close(accept_fd);
+    HANDLE_EINTR(close(accept_fd));
     return false;
   }
 
   *server_socket = accept_fd;
   return true;
 }
 
 bool ClientConnectToFifo(const std::string &pipe_name, int* client_socket) {
   DCHECK(client_socket);
   DCHECK_LT(pipe_name.length(), kMaxPipeNameLength);
 
   // Create socket.
   int fd = socket(AF_UNIX, SOCK_STREAM, 0);
   if (fd < 0) {
     LOG(ERROR) << "fd is invalid";
     return false;
   }
 
   // Make socket non-blocking
   if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
     LOG(ERROR) << "fcntl failed";
-    close(fd);
+    HANDLE_EINTR(close(fd));
     return false;
   }
 
   // Create server side of socket.
   struct sockaddr_un  server_unix_addr;
   memset(&server_unix_addr, 0, sizeof(server_unix_addr));
   server_unix_addr.sun_family = AF_UNIX;
   snprintf(server_unix_addr.sun_path, kMaxPipeNameLength, "%s",
            pipe_name.c_str());
   size_t server_unix_addr_len = offsetof(struct sockaddr_un, sun_path) +
       strlen(server_unix_addr.sun_path) + 1;
 
-  int ret_val = -1;
-  do {
-    ret_val = connect(fd, reinterpret_cast<sockaddr*>(&server_unix_addr),
-                      server_unix_addr_len);
-  } while (ret_val == -1 && errno == EINTR);
-  if (ret_val != 0) {
-    close(fd);
+  if (HANDLE_EINTR(connect(fd, reinterpret_cast<sockaddr*>(&server_unix_addr),
+                           server_unix_addr_len)) != 0) {
+    HANDLE_EINTR(close(fd));
     return false;
   }
 
   *client_socket = fd;
   return true;
 }
 
 }  // namespace
 //------------------------------------------------------------------------------
 
@@ skipping 48 matching lines @@
   } else {
     // socketpair()
     if (mode == MODE_SERVER) {
       int pipe_fds[2];
       if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds) != 0) {
         return false;
       }
       // Set both ends to be non-blocking.
       if (fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK) == -1 ||
           fcntl(pipe_fds[1], F_SETFL, O_NONBLOCK) == -1) {
-        close(pipe_fds[0]);
-        close(pipe_fds[1]);
+        HANDLE_EINTR(close(pipe_fds[0]));
+        HANDLE_EINTR(close(pipe_fds[1]));
         return false;
       }
       pipe_ = pipe_fds[0];
       client_pipe_ = pipe_fds[1];
 
       Singleton<PipeMap>()->Insert(pipe_name_, client_pipe_);
     } else {
       pipe_ = ChannelNameToClientFD(pipe_name_);
       DCHECK(pipe_ > 0);
       waiting_connect_ = false;
@@ skipping 55 matching lines @@
   for (;;) {
     msg.msg_controllen = sizeof(input_cmsg_buf_);
 
     if (bytes_read == 0) {
       if (pipe_ == -1)
         return false;
 
       // Read from pipe.
       // recvmsg() returns 0 if the connection has closed or EAGAIN if no data
       // is waiting on the pipe.
-      do {
-        bytes_read = recvmsg(pipe_, &msg, MSG_DONTWAIT);
-      } while (bytes_read == -1 && errno == EINTR);
+      bytes_read = HANDLE_EINTR(recvmsg(pipe_, &msg, MSG_DONTWAIT));
 
       if (bytes_read < 0) {
         if (errno == EAGAIN) {
           return true;
         } else {
           LOG(ERROR) << "pipe error (" << pipe_ << "): " << strerror(errno);
           return false;
         }
       } else if (bytes_read == 0) {
         // The pipe has closed...
         Close();
         return false;
       }
     }
     DCHECK(bytes_read);
 
     if (client_pipe_ != -1) {
       Singleton<PipeMap>()->Remove(pipe_name_);
-      close(client_pipe_);
+      HANDLE_EINTR(close(client_pipe_));
       client_pipe_ = -1;
     }
 
     // a pointer to an array of |num_wire_fds| file descriptors from the read
     const int* wire_fds = NULL;
     unsigned num_wire_fds = 0;
 
     // walk the list of control messages and, if we find an array of file
     // descriptors, save a pointer to the array
 
@@ skipping 18 matching lines @@
           const unsigned payload_len = cmsg->cmsg_len - CMSG_LEN(0);
           DCHECK(payload_len % sizeof(int) == 0);
           wire_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
           num_wire_fds = payload_len / 4;
 
           if (msg.msg_flags & MSG_CTRUNC) {
             LOG(ERROR) << "SCM_RIGHTS message was truncated"
                        << " cmsg_len:" << cmsg->cmsg_len
                        << " fd:" << pipe_;
             for (unsigned i = 0; i < num_wire_fds; ++i)
-              close(wire_fds[i]);
+              HANDLE_EINTR(close(wire_fds[i]));
             return false;
           }
           break;
         }
       }
     }
 
     // Process messages from input buffer.
     const char *p;
     const char *end;
@@ skipping 52 matching lines @@
 
           if (error) {
             LOG(WARNING) << error
                          << " channel:" << this
                          << " message-type:" << m.type()
                          << " header()->num_fds:" << m.header()->num_fds
                          << " num_fds:" << num_fds
                          << " fds_i:" << fds_i;
             // close the existing file descriptors so that we don't leak them
             for (unsigned i = fds_i; i < num_fds; ++i)
-              close(fds[i]);
+              HANDLE_EINTR(close(fds[i]));
             input_overflow_fds_.clear();
             // abort the connection
             return false;
           }
 
           m.file_descriptor_set()->SetDescriptors(
               &fds[fds_i], m.header()->num_fds);
           fds_i += m.header()->num_fds;
         }
 #ifdef IPC_MESSAGE_DEBUG_EXTRA
@@ skipping 43 matching lines @@
 
   // Write out all the messages we can till the write blocks or there are no
   // more outgoing messages.
   while (!output_queue_.empty()) {
     Message* msg = output_queue_.front();
 
     size_t amt_to_write = msg->size() - message_send_bytes_written_;
     DCHECK(amt_to_write != 0);
     const char *out_bytes = reinterpret_cast<const char*>(msg->data()) +
         message_send_bytes_written_;
-    ssize_t bytes_written = -1;
-    do {
-      struct msghdr msgh = {0};
-      struct iovec iov = {const_cast<char*>(out_bytes), amt_to_write};
-      msgh.msg_iov = &iov;
-      msgh.msg_iovlen = 1;
-      char buf[CMSG_SPACE(
-          sizeof(int[FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE]))];
 
-      if (message_send_bytes_written_ == 0 &&
-          !msg->file_descriptor_set()->empty()) {
-        // This is the first chunk of a message which has descriptors to send
-        struct cmsghdr *cmsg;
-        const unsigned num_fds = msg->file_descriptor_set()->size();
+    struct msghdr msgh = {0};
+    struct iovec iov = {const_cast<char*>(out_bytes), amt_to_write};
+    msgh.msg_iov = &iov;
+    msgh.msg_iovlen = 1;
+    char buf[CMSG_SPACE(
+        sizeof(int[FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE]))];
 
-        DCHECK_LE(num_fds, FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE);
+    if (message_send_bytes_written_ == 0 &&
+        !msg->file_descriptor_set()->empty()) {
+      // This is the first chunk of a message which has descriptors to send
+      struct cmsghdr *cmsg;
+      const unsigned num_fds = msg->file_descriptor_set()->size();
 
-        msgh.msg_control = buf;
-        msgh.msg_controllen = CMSG_SPACE(sizeof(int) * num_fds);
-        cmsg = CMSG_FIRSTHDR(&msgh);
-        cmsg->cmsg_level = SOL_SOCKET;
-        cmsg->cmsg_type = SCM_RIGHTS;
-        cmsg->cmsg_len = CMSG_LEN(sizeof(int) * num_fds);
-        msg->file_descriptor_set()->GetDescriptors(
-            reinterpret_cast<int*>(CMSG_DATA(cmsg)));
-        msgh.msg_controllen = cmsg->cmsg_len;
+      DCHECK_LE(num_fds, FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE);
 
-        msg->header()->num_fds = num_fds;
-      }
+      msgh.msg_control = buf;
+      msgh.msg_controllen = CMSG_SPACE(sizeof(int) * num_fds);
+      cmsg = CMSG_FIRSTHDR(&msgh);
+      cmsg->cmsg_level = SOL_SOCKET;
+      cmsg->cmsg_type = SCM_RIGHTS;
+      cmsg->cmsg_len = CMSG_LEN(sizeof(int) * num_fds);
+      msg->file_descriptor_set()->GetDescriptors(
+          reinterpret_cast<int*>(CMSG_DATA(cmsg)));
+      msgh.msg_controllen = cmsg->cmsg_len;
 
-      bytes_written = sendmsg(pipe_, &msgh, MSG_DONTWAIT);
-      if (bytes_written > 0)
-        msg->file_descriptor_set()->CommitAll();
-    } while (bytes_written == -1 && errno == EINTR);
+      msg->header()->num_fds = num_fds;
+    }
+
+    ssize_t bytes_written = HANDLE_EINTR(sendmsg(pipe_, &msgh, MSG_DONTWAIT));
+    if (bytes_written > 0)
+      msg->file_descriptor_set()->CommitAll();
 
     if (bytes_written < 0 && errno != EAGAIN) {
       LOG(ERROR) << "pipe error: " << strerror(errno);
       return false;
     }
 
     if (static_cast<size_t>(bytes_written) != amt_to_write) {
       if (bytes_written > 0) {
         // If write() fails with EAGAIN then bytes_written will be -1.
         message_send_bytes_written_ += bytes_written;
@@ skipping 113 matching lines @@
 }
 
 void Channel::ChannelImpl::Close() {
   // Close can be called multiple time, so we need to make sure we're
   // idempotent.
 
   // Unregister libevent for the listening socket and close it.
   server_listen_connection_watcher_.StopWatchingFileDescriptor();
 
   if (server_listen_pipe_ != -1) {
-    close(server_listen_pipe_);
+    HANDLE_EINTR(close(server_listen_pipe_));
     server_listen_pipe_ = -1;
   }
 
   // Unregister libevent for the FIFO and close it.
   read_watcher_.StopWatchingFileDescriptor();
   write_watcher_.StopWatchingFileDescriptor();
   if (pipe_ != -1) {
-    close(pipe_);
+    HANDLE_EINTR(close(pipe_));
     pipe_ = -1;
   }
   if (client_pipe_ != -1) {
     Singleton<PipeMap>()->Remove(pipe_name_);
-    close(client_pipe_);
+    HANDLE_EINTR(close(client_pipe_));
     client_pipe_ = -1;
   }
 
   // Unlink the FIFO
   unlink(pipe_name_.c_str());
 
   while (!output_queue_.empty()) {
     Message* m = output_queue_.front();
     output_queue_.pop();
     delete m;
   }
 
   // Close any outstanding, received file descriptors
   for (std::vector<int>::iterator
        i = input_overflow_fds_.begin(); i != input_overflow_fds_.end(); ++i) {
-    close(*i);
+    HANDLE_EINTR(close(*i));
   }
   input_overflow_fds_.clear();
 }
 
 //------------------------------------------------------------------------------
 // Channel's methods simply call through to ChannelImpl.
 Channel::Channel(const std::wstring& channel_id, Mode mode,
                  Listener* listener)
     : channel_impl_(new ChannelImpl(channel_id, mode, listener)) {
 }
@@ skipping 21 matching lines @@
 void Channel::GetClientFileDescriptorMapping(int *src_fd, int *dest_fd) const {
   return channel_impl_->GetClientFileDescriptorMapping(src_fd, dest_fd);
 }
 
 void Channel::OnClientConnected() {
   return channel_impl_->OnClientConnected();
 }
 
 
 }  // namespace IPC