Ensure handle_ fits in FD_SETSIZE.

base/sync_socket_posix.cc

 // Copyright (c) 2012 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 "base/sync_socket.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <stdio.h>
@@ skipping 22 matching lines @@
                   const void* buffer,
                   size_t length) {
   DCHECK_GT(length, 0u);
   DCHECK_LE(length, kMaxMessageLength);
   DCHECK_NE(handle, SyncSocket::kInvalidHandle);
   const char* charbuffer = static_cast<const char*>(buffer);
   const int len = file_util::WriteFileDescriptor(handle, charbuffer, length);
   return len < 0 ? 0 : static_cast<size_t>(len);
 }
 
+bool CloseHandle(SyncSocket::Handle handle) {
+  if (handle != SyncSocket::kInvalidHandle && close(handle) < 0) {

[DaleCurtis, 2013/11/01 00:15:59]

Removed the EINTR here per http://crbug.com/269623 too.

+    DPLOG(ERROR) << "close";
+    return false;
+  }
+
+  return true;
+}
+
 }  // namespace
 
 const SyncSocket::Handle SyncSocket::kInvalidHandle = -1;
 
 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {}
 
 SyncSocket::~SyncSocket() {
   Close();
 }
 
 // static
 bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) {
   DCHECK_NE(socket_a, socket_b);
   DCHECK_EQ(socket_a->handle_, kInvalidHandle);
   DCHECK_EQ(socket_b->handle_, kInvalidHandle);
 
 #if defined(OS_MACOSX)
   int nosigpipe = 1;
 #endif  // defined(OS_MACOSX)
 
   Handle handles[2] = { kInvalidHandle, kInvalidHandle };
-  if (socketpair(AF_UNIX, SOCK_STREAM, 0, handles) != 0)
-    goto cleanup;
+  if (socketpair(AF_UNIX, SOCK_STREAM, 0, handles) != 0) {
+    CloseHandle(handles[0]);
+    CloseHandle(handles[1]);
+    return false;
+  }
 
 #if defined(OS_MACOSX)
   // On OSX an attempt to read or write to a closed socket may generate a
   // SIGPIPE rather than returning -1.  setsockopt will shut this off.
   if (0 != setsockopt(handles[0], SOL_SOCKET, SO_NOSIGPIPE,
                       &nosigpipe, sizeof nosigpipe) ||
       0 != setsockopt(handles[1], SOL_SOCKET, SO_NOSIGPIPE,
                       &nosigpipe, sizeof nosigpipe)) {
-    goto cleanup;
+    CloseHandle(handles[0]);
+    CloseHandle(handles[1]);
+    return false;
   }
 #endif
 
   // Copy the handles out for successful return.
   socket_a->handle_ = handles[0];
   socket_b->handle_ = handles[1];
 
   return true;
-
- cleanup:
-  if (handles[0] != kInvalidHandle) {
-    if (HANDLE_EINTR(close(handles[0])) < 0)
-      DPLOG(ERROR) << "close";
-  }
-  if (handles[1] != kInvalidHandle) {
-    if (HANDLE_EINTR(close(handles[1])) < 0)
-      DPLOG(ERROR) << "close";
-  }
-
-  return false;
 }
 
 bool SyncSocket::Close() {
-  if (handle_ == kInvalidHandle)
-    return true;
-  const int retval = HANDLE_EINTR(close(handle_));
-  DPLOG_IF(ERROR, retval < 0) << "close";
+  const bool retval = CloseHandle(handle_);
   handle_ = kInvalidHandle;
-  return retval == 0;
+  return retval;
 }
 
 size_t SyncSocket::Send(const void* buffer, size_t length) {
   ThreadRestrictions::AssertIOAllowed();
   return SendHelper(handle_, buffer, length);
 }
 
 size_t SyncSocket::Receive(void* buffer, size_t length) {
   ThreadRestrictions::AssertIOAllowed();
   DCHECK_GT(length, 0u);
   DCHECK_LE(length, kMaxMessageLength);
   DCHECK_NE(handle_, kInvalidHandle);
   char* charbuffer = static_cast<char*>(buffer);
   if (file_util::ReadFromFD(handle_, charbuffer, length))
     return length;
   return 0;
 }
 
 size_t SyncSocket::ReceiveWithTimeout(void* buffer,
                                       size_t length,
                                       TimeDelta timeout) {
   ThreadRestrictions::AssertIOAllowed();
   DCHECK_GT(length, 0u);
   DCHECK_LE(length, kMaxMessageLength);
   DCHECK_NE(handle_, kInvalidHandle);
-  DCHECK_LT(handle_, FD_SETSIZE);
+  CHECK_LT(handle_, FD_SETSIZE);
 
   // Only timeouts greater than zero and less than one second are allowed.
   DCHECK_GT(timeout.InMicroseconds(), 0);
   DCHECK_LT(timeout.InMicroseconds(),
             base::TimeDelta::FromSeconds(1).InMicroseconds());
 
   // Track the start time so we can reduce the timeout as data is read.
   TimeTicks start_time = TimeTicks::Now();
   const TimeTicks finish_time = start_time + timeout;
 
@@ skipping 78 matching lines @@
   return len;
 }
 
 // static
 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
                                       CancelableSyncSocket* socket_b) {
   return SyncSocket::CreatePair(socket_a, socket_b);
 }
 
 }  // namespace base