base/sync_socket_posix.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/sync_socket.h"
   6
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <limits.h>
  10 #include <stdio.h>
  11 #include <sys/ioctl.h>
  12 #include <sys/socket.h>
  13 #include <sys/types.h>
  14
  15 #if defined(OS_SOLARIS)
  16 #include <sys/filio.h>
  17 #endif
  18
  19 #include "base/file_util.h"
  20 #include "base/logging.h"
  21 #include "base/threading/thread_restrictions.h"
  22
  23 namespace base {
  24
  25 namespace {
  26 // To avoid users sending negative message lengths to Send/Receive
  27 // we clamp message lengths, which are size_t, to no more than INT_MAX.
  28 const size_t kMaxMessageLength = static_cast<size_t>(INT_MAX);
  29
  30 // Writes |length| of |buffer| into |handle|.  Returns the number of bytes
  31 // written or zero on error.  |length| must be greater than 0.
  32 size_t SendHelper(SyncSocket::Handle handle,
  33                   const void* buffer,
  34                   size_t length) {
  35   DCHECK_GT(length, 0u);
  36   DCHECK_LE(length, kMaxMessageLength);
  37   DCHECK_NE(handle, SyncSocket::kInvalidHandle);
  38   const char* charbuffer = static_cast<const char*>(buffer);
  39   const int len = file_util::WriteFileDescriptor(handle, charbuffer, length);
  40   return len < 0 ? 0 : static_cast<size_t>(len);
  41 }
  42
  43 }  // namespace
  44
  45 const SyncSocket::Handle SyncSocket::kInvalidHandle = -1;
  46
  47 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {}
  48
  49 SyncSocket::~SyncSocket() {
  50   Close();
  51 }
  52
  53 // static
  54 bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) {
  55   DCHECK_NE(socket_a, socket_b);
  56   DCHECK_EQ(socket_a->handle_, kInvalidHandle);
  57   DCHECK_EQ(socket_b->handle_, kInvalidHandle);
  58
  59 #if defined(OS_MACOSX)
  60   int nosigpipe = 1;
  61 #endif  // defined(OS_MACOSX)
  62
  63   Handle handles[2] = { kInvalidHandle, kInvalidHandle };
  64   if (socketpair(AF_UNIX, SOCK_STREAM, 0, handles) != 0)
  65     goto cleanup;
  66
  67 #if defined(OS_MACOSX)
  68   // On OSX an attempt to read or write to a closed socket may generate a
  69   // SIGPIPE rather than returning -1.  setsockopt will shut this off.
  70   if (0 != setsockopt(handles[0], SOL_SOCKET, SO_NOSIGPIPE,
  71                       &nosigpipe, sizeof nosigpipe) ||
  72       0 != setsockopt(handles[1], SOL_SOCKET, SO_NOSIGPIPE,
  73                       &nosigpipe, sizeof nosigpipe)) {
  74     goto cleanup;
  75   }
  76 #endif
  77
  78   // Copy the handles out for successful return.
  79   socket_a->handle_ = handles[0];
  80   socket_b->handle_ = handles[1];
  81
  82   return true;
  83
  84  cleanup:
  85   if (handles[0] != kInvalidHandle) {
  86     if (HANDLE_EINTR(close(handles[0])) < 0)
  87       DPLOG(ERROR) << "close";
  88   }
  89   if (handles[1] != kInvalidHandle) {
  90     if (HANDLE_EINTR(close(handles[1])) < 0)
  91       DPLOG(ERROR) << "close";
  92   }
  93
  94   return false;
  95 }
  96
  97 bool SyncSocket::Close() {
  98   if (handle_ == kInvalidHandle)
  99     return true;
 100   const int retval = HANDLE_EINTR(close(handle_));
 101   DPLOG_IF(ERROR, retval < 0) << "close";
 102   handle_ = kInvalidHandle;
 103   return retval == 0;
 104 }
 105
 106 size_t SyncSocket::Send(const void* buffer, size_t length) {
 107   ThreadRestrictions::AssertIOAllowed();
 108   return SendHelper(handle_, buffer, length);
 109 }
 110
 111 size_t SyncSocket::Receive(void* buffer, size_t length) {
 112   ThreadRestrictions::AssertIOAllowed();
 113   DCHECK_GT(length, 0u);
 114   DCHECK_LE(length, kMaxMessageLength);
 115   DCHECK_NE(handle_, kInvalidHandle);
 116   char* charbuffer = static_cast<char*>(buffer);
 117   if (file_util::ReadFromFD(handle_, charbuffer, length))
 118     return length;
 119   return 0;
 120 }
 121
 122 size_t SyncSocket::ReceiveWithTimeout(void* buffer,
 123                                       size_t length,
 124                                       TimeDelta timeout) {
 125   ThreadRestrictions::AssertIOAllowed();
 126   DCHECK_GT(length, 0u);
 127   DCHECK_LE(length, kMaxMessageLength);
 128   DCHECK_NE(handle_, kInvalidHandle);
 129   DCHECK_LT(handle_, FD_SETSIZE);
 130
 131   // Only timeouts greater than zero and less than one second are allowed.
 132   DCHECK_GT(timeout.InMicroseconds(), 0);
 133   DCHECK_LT(timeout.InMicroseconds(),
 134             base::TimeDelta::FromSeconds(1).InMicroseconds());
 135
 136   // Track the start time so we can reduce the timeout as data is read.
 137   TimeTicks start_time = TimeTicks::Now();
 138   const TimeTicks finish_time = start_time + timeout;
 139
 140   fd_set read_fds;
 141   size_t bytes_read_total;
 142   for (bytes_read_total = 0;
 143        bytes_read_total < length && timeout.InMicroseconds() > 0;
 144        timeout = finish_time - base::TimeTicks::Now()) {
 145     FD_ZERO(&read_fds);
 146     FD_SET(handle_, &read_fds);
 147
 148     // Wait for data to become available.
 149     struct timeval timeout_struct =
 150         { 0, static_cast<suseconds_t>(timeout.InMicroseconds()) };
 151     const int select_result =
 152         select(handle_ + 1, &read_fds, NULL, NULL, &timeout_struct);
 153     // Handle EINTR manually since we need to update the timeout value.
 154     if (select_result == -1 && errno == EINTR)
 155       continue;
 156     if (select_result <= 0)
 157       return bytes_read_total;
 158
 159     // select() only tells us that data is ready for reading, not how much.  We
 160     // must Peek() for the amount ready for reading to avoid blocking.
 161     DCHECK(FD_ISSET(handle_, &read_fds));
 162     const size_t bytes_to_read = std::min(Peek(), length - bytes_read_total);
 163
 164     // There may be zero bytes to read if the socket at the other end closed.
 165     if (!bytes_to_read)
 166       return bytes_read_total;
 167
 168     const size_t bytes_received =
 169         Receive(static_cast<char*>(buffer) + bytes_read_total, bytes_to_read);
 170     bytes_read_total += bytes_received;
 171     if (bytes_received != bytes_to_read)
 172       return bytes_read_total;
 173   }
 174
 175   return bytes_read_total;
 176 }
 177
 178 size_t SyncSocket::Peek() {
 179   DCHECK_NE(handle_, kInvalidHandle);
 180   int number_chars = 0;
 181   if (ioctl(handle_, FIONREAD, &number_chars) == -1) {
 182     // If there is an error in ioctl, signal that the channel would block.
 183     return 0;
 184   }
 185   DCHECK_GE(number_chars, 0);
 186   return number_chars;
 187 }
 188
 189 CancelableSyncSocket::CancelableSyncSocket() {}
 190 CancelableSyncSocket::CancelableSyncSocket(Handle handle)
 191     : SyncSocket(handle) {
 192 }
 193
 194 bool CancelableSyncSocket::Shutdown() {
 195   DCHECK_NE(handle_, kInvalidHandle);
 196   return HANDLE_EINTR(shutdown(handle_, SHUT_RDWR)) >= 0;
 197 }
 198
 199 size_t CancelableSyncSocket::Send(const void* buffer, size_t length) {
 200   DCHECK_GT(length, 0u);
 201   DCHECK_LE(length, kMaxMessageLength);
 202   DCHECK_NE(handle_, kInvalidHandle);
 203
 204   const long flags = fcntl(handle_, F_GETFL, NULL);
 205   if (flags != -1 && (flags & O_NONBLOCK) == 0) {
 206     // Set the socket to non-blocking mode for sending if its original mode
 207     // is blocking.
 208     fcntl(handle_, F_SETFL, flags | O_NONBLOCK);
 209   }
 210
 211   const size_t len = SendHelper(handle_, buffer, length);
 212
 213   if (flags != -1 && (flags & O_NONBLOCK) == 0) {
 214     // Restore the original flags.
 215     fcntl(handle_, F_SETFL, flags);
 216   }
 217
 218   return len;
 219 }
 220
 221 // static
 222 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
 223                                       CancelableSyncSocket* socket_b) {
 224   return SyncSocket::CreatePair(socket_a, socket_b);
 225 }
 226
 227 }  // namespace base