Clang: Do not ignore result of HANDLE_EINTR.

ipc/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 "ipc/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/types.h>
@@ skipping 75 matching lines @@
     return i->second;
   }
 
   // Remove the mapping for the given channel id. No error is signaled if the
   // channel_id doesn't exist
   void RemoveAndClose(const std::string& channel_id) {
     AutoLock locked(lock_);
 
     ChannelToFDMap::iterator i = map_.find(channel_id);
     if (i != map_.end()) {
-      HANDLE_EINTR(close(i->second));
+      if (HANDLE_EINTR(close(i->second)) < 0)
+        PLOG(ERROR) << "close";
       map_.erase(i);
     }
   }
 
   // Insert a mapping from @channel_id to @fd. It's a fatal error to insert a
   // mapping if one already exists for the given channel_id
   void Insert(const std::string& channel_id, int fd) {
     AutoLock locked(lock_);
     DCHECK(fd != -1);
 
@@ skipping 41 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) {
-    HANDLE_EINTR(close(fd));
+    if (HANDLE_EINTR(close(fd)) < 0)
+      PLOG(ERROR) << "close";
     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) {
-    HANDLE_EINTR(close(fd));
+    if (HANDLE_EINTR(close(fd)) < 0)
+      PLOG(ERROR) << "close";
     return false;
   }
 
   // Start listening on the socket.
   const int listen_queue_length = 1;
   if (listen(fd, listen_queue_length) != 0) {
-    HANDLE_EINTR(close(fd));
+    if (HANDLE_EINTR(close(fd)) < 0)
+      PLOG(ERROR) << "close";
     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 = HANDLE_EINTR(accept(server_listen_fd, NULL, 0));
   if (accept_fd < 0)
     return false;
   if (fcntl(accept_fd, F_SETFL, O_NONBLOCK) == -1) {
-    HANDLE_EINTR(close(accept_fd));
+    if (HANDLE_EINTR(close(accept_fd)) < 0)
+      PLOG(ERROR) << "close";
     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";
-    HANDLE_EINTR(close(fd));
+    if (HANDLE_EINTR(close(fd)) < 0)
+      PLOG(ERROR) << "close";
     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;
 
   if (HANDLE_EINTR(connect(fd, reinterpret_cast<sockaddr*>(&server_unix_addr),
                            server_unix_addr_len)) != 0) {
-    HANDLE_EINTR(close(fd));
+    if (HANDLE_EINTR(close(fd)) < 0)
+      PLOG(ERROR) << "close";
     return false;
   }
 
   *client_socket = fd;
   return true;
 }
 
 bool SocketWriteErrorIsRecoverable() {
 #if defined(OS_MACOSX)
   // On OS X if sendmsg() is trying to send fds between processes and there
@@ skipping 61 matching lines @@
   int pipe_fds[2];
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds) != 0) {
     PLOG(ERROR) << "socketpair()";
     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) {
     PLOG(ERROR) << "fcntl(O_NONBLOCK)";
-    HANDLE_EINTR(close(pipe_fds[0]));
-    HANDLE_EINTR(close(pipe_fds[1]));
+    if (HANDLE_EINTR(close(pipe_fds[0])) < 0)
+      PLOG(ERROR) << "close";
+    if (HANDLE_EINTR(close(pipe_fds[1])) < 0)
+      PLOG(ERROR) << "close";
     return false;
   }
 
   *fd1 = pipe_fds[0];
   *fd2 = pipe_fds[1];
 
   return true;
 }
 
 bool Channel::ChannelImpl::CreatePipe(const std::string& channel_id,
@@ skipping 197 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)
-              HANDLE_EINTR(close(wire_fds[i]));
+              if (HANDLE_EINTR(close(wire_fds[i])) < 0)
+                PLOG(ERROR) << "close" << i;
             return false;
           }
           break;
         }
       }
     }
 
     // Process messages from input buffer.
     const char *p;
     const char *end;
@@ skipping 59 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)
-                        HANDLE_EINTR(close(wire_fds[i]));
+                        if (HANDLE_EINTR(close(wire_fds[i])) < 0)
+                          PLOG(ERROR) << "close" << i;
                       return false;
                     }
                     break;
                   }
                 }
                 if (input_overflow_fds_.empty()) {
                   fds = wire_fds;
                   num_fds = num_wire_fds;
                 } else {
                   if (num_wire_fds > 0) {
@@ skipping 25 matching lines @@
                          << " header()->num_fds:" << m.header()->num_fds
                          << " num_fds:" << num_fds
                          << " fds_i:" << fds_i;
 #if defined(CHROMIUM_SELINUX)
             LOG(WARNING) << "In the case of SELinux this can be caused when "
                             "using a --user-data-dir to which the default "
                             "policy doesn't give the renderer access to. ";
 #endif
             // close the existing file descriptors so that we don't leak them
             for (unsigned i = fds_i; i < num_fds; ++i)
-              HANDLE_EINTR(close(fds[i]));
+              if (HANDLE_EINTR(close(fds[i])) < 0)
+                PLOG(ERROR) << "close" << 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 312 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) {
-    HANDLE_EINTR(close(server_listen_pipe_));
+    if (HANDLE_EINTR(close(server_listen_pipe_)) < 0)
+      PLOG(ERROR) << "close";
     server_listen_pipe_ = -1;
   }
 
   // Unregister libevent for the FIFO and close it.
   read_watcher_.StopWatchingFileDescriptor();
   write_watcher_.StopWatchingFileDescriptor();
   if (pipe_ != -1) {
-    HANDLE_EINTR(close(pipe_));
+    if (HANDLE_EINTR(close(pipe_)) < 0)
+      PLOG(ERROR) << "close";
     pipe_ = -1;
   }
   if (client_pipe_ != -1) {
     Singleton<PipeMap>()->RemoveAndClose(pipe_name_);
     client_pipe_ = -1;
   }
 #if !defined(OS_MACOSX)
   if (fd_pipe_ != -1) {
-    HANDLE_EINTR(close(fd_pipe_));
+    if (HANDLE_EINTR(close(fd_pipe_)) < 0)
+      PLOG(ERROR) << "close";
     fd_pipe_ = -1;
   }
   if (remote_fd_pipe_ != -1) {
-    HANDLE_EINTR(close(remote_fd_pipe_));
+    if (HANDLE_EINTR(close(remote_fd_pipe_)) < 0)
+      PLOG(ERROR) << "close";
     remote_fd_pipe_ = -1;
   }
 #endif
 
   if (uses_fifo_) {
     // 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) {
-    HANDLE_EINTR(close(*i));
+    if (HANDLE_EINTR(close(*i)) < 0)
+      PLOG(ERROR) << "close";
   }
   input_overflow_fds_.clear();
 }
 
 //------------------------------------------------------------------------------
 // Channel's methods simply call through to ChannelImpl.
 Channel::Channel(const std::string& channel_id, Mode mode,
                  Listener* listener)
     : channel_impl_(new ChannelImpl(channel_id, mode, listener)) {
 }
@@ skipping 16 matching lines @@
 
 bool Channel::Send(Message* message) {
   return channel_impl_->Send(message);
 }
 
 int Channel::GetClientFileDescriptor() const {
   return channel_impl_->GetClientFileDescriptor();
 }
 
 }  // namespace IPC