• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <poll.h>
11 #include <stddef.h>
12 #include <stdio.h>
13 #include <sys/ioctl.h>
14 #include <sys/socket.h>
15 #include <sys/types.h>
16 
17 #if defined(OS_SOLARIS)
18 #include <sys/filio.h>
19 #endif
20 
21 #include "base/files/file_util.h"
22 #include "base/logging.h"
23 #include "base/threading/thread_restrictions.h"
24 #include "build/build_config.h"
25 
26 namespace base {
27 
28 namespace {
29 // To avoid users sending negative message lengths to Send/Receive
30 // we clamp message lengths, which are size_t, to no more than INT_MAX.
31 const size_t kMaxMessageLength = static_cast<size_t>(INT_MAX);
32 
33 // Writes |length| of |buffer| into |handle|.  Returns the number of bytes
34 // written or zero on error.  |length| must be greater than 0.
SendHelper(SyncSocket::Handle handle,const void * buffer,size_t length)35 size_t SendHelper(SyncSocket::Handle handle,
36                   const void* buffer,
37                   size_t length) {
38   DCHECK_GT(length, 0u);
39   DCHECK_LE(length, kMaxMessageLength);
40   DCHECK_NE(handle, SyncSocket::kInvalidHandle);
41   const char* charbuffer = static_cast<const char*>(buffer);
42   return WriteFileDescriptor(handle, charbuffer, length)
43              ? static_cast<size_t>(length)
44              : 0;
45 }
46 
CloseHandle(SyncSocket::Handle handle)47 bool CloseHandle(SyncSocket::Handle handle) {
48   if (handle != SyncSocket::kInvalidHandle && close(handle) < 0) {
49     DPLOG(ERROR) << "close";
50     return false;
51   }
52 
53   return true;
54 }
55 
56 }  // namespace
57 
58 const SyncSocket::Handle SyncSocket::kInvalidHandle = -1;
59 
SyncSocket()60 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {}
61 
~SyncSocket()62 SyncSocket::~SyncSocket() {
63   Close();
64 }
65 
66 // static
CreatePair(SyncSocket * socket_a,SyncSocket * socket_b)67 bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) {
68   DCHECK_NE(socket_a, socket_b);
69   DCHECK_EQ(socket_a->handle_, kInvalidHandle);
70   DCHECK_EQ(socket_b->handle_, kInvalidHandle);
71 
72 #if defined(OS_MACOSX)
73   int nosigpipe = 1;
74 #endif  // defined(OS_MACOSX)
75 
76   Handle handles[2] = { kInvalidHandle, kInvalidHandle };
77   if (socketpair(AF_UNIX, SOCK_STREAM, 0, handles) != 0) {
78     CloseHandle(handles[0]);
79     CloseHandle(handles[1]);
80     return false;
81   }
82 
83 #if defined(OS_MACOSX)
84   // On OSX an attempt to read or write to a closed socket may generate a
85   // SIGPIPE rather than returning -1.  setsockopt will shut this off.
86   if (0 != setsockopt(handles[0], SOL_SOCKET, SO_NOSIGPIPE,
87                       &nosigpipe, sizeof nosigpipe) ||
88       0 != setsockopt(handles[1], SOL_SOCKET, SO_NOSIGPIPE,
89                       &nosigpipe, sizeof nosigpipe)) {
90     CloseHandle(handles[0]);
91     CloseHandle(handles[1]);
92     return false;
93   }
94 #endif
95 
96   // Copy the handles out for successful return.
97   socket_a->handle_ = handles[0];
98   socket_b->handle_ = handles[1];
99 
100   return true;
101 }
102 
103 // static
UnwrapHandle(const TransitDescriptor & descriptor)104 SyncSocket::Handle SyncSocket::UnwrapHandle(
105     const TransitDescriptor& descriptor) {
106   return descriptor.fd;
107 }
108 
PrepareTransitDescriptor(ProcessHandle peer_process_handle,TransitDescriptor * descriptor)109 bool SyncSocket::PrepareTransitDescriptor(ProcessHandle peer_process_handle,
110                                           TransitDescriptor* descriptor) {
111   descriptor->fd = handle();
112   descriptor->auto_close = false;
113   return descriptor->fd != kInvalidHandle;
114 }
115 
Close()116 bool SyncSocket::Close() {
117   const bool retval = CloseHandle(handle_);
118   handle_ = kInvalidHandle;
119   return retval;
120 }
121 
Send(const void * buffer,size_t length)122 size_t SyncSocket::Send(const void* buffer, size_t length) {
123   AssertBlockingAllowed();
124   return SendHelper(handle_, buffer, length);
125 }
126 
Receive(void * buffer,size_t length)127 size_t SyncSocket::Receive(void* buffer, size_t length) {
128   AssertBlockingAllowed();
129   DCHECK_GT(length, 0u);
130   DCHECK_LE(length, kMaxMessageLength);
131   DCHECK_NE(handle_, kInvalidHandle);
132   char* charbuffer = static_cast<char*>(buffer);
133   if (ReadFromFD(handle_, charbuffer, length))
134     return length;
135   return 0;
136 }
137 
ReceiveWithTimeout(void * buffer,size_t length,TimeDelta timeout)138 size_t SyncSocket::ReceiveWithTimeout(void* buffer,
139                                       size_t length,
140                                       TimeDelta timeout) {
141   AssertBlockingAllowed();
142   DCHECK_GT(length, 0u);
143   DCHECK_LE(length, kMaxMessageLength);
144   DCHECK_NE(handle_, kInvalidHandle);
145 
146   // Only timeouts greater than zero and less than one second are allowed.
147   DCHECK_GT(timeout.InMicroseconds(), 0);
148   DCHECK_LT(timeout.InMicroseconds(),
149             TimeDelta::FromSeconds(1).InMicroseconds());
150 
151   // Track the start time so we can reduce the timeout as data is read.
152   TimeTicks start_time = TimeTicks::Now();
153   const TimeTicks finish_time = start_time + timeout;
154 
155   struct pollfd pollfd;
156   pollfd.fd = handle_;
157   pollfd.events = POLLIN;
158   pollfd.revents = 0;
159 
160   size_t bytes_read_total = 0;
161   while (bytes_read_total < length) {
162     const TimeDelta this_timeout = finish_time - TimeTicks::Now();
163     const int timeout_ms =
164         static_cast<int>(this_timeout.InMillisecondsRoundedUp());
165     if (timeout_ms <= 0)
166       break;
167     const int poll_result = poll(&pollfd, 1, timeout_ms);
168     // Handle EINTR manually since we need to update the timeout value.
169     if (poll_result == -1 && errno == EINTR)
170       continue;
171     // Return if other type of error or a timeout.
172     if (poll_result <= 0)
173       return bytes_read_total;
174 
175     // poll() only tells us that data is ready for reading, not how much.  We
176     // must Peek() for the amount ready for reading to avoid blocking.
177     // At hang up (POLLHUP), the write end has been closed and there might still
178     // be data to be read.
179     // No special handling is needed for error (POLLERR); we can let any of the
180     // following operations fail and handle it there.
181     DCHECK(pollfd.revents & (POLLIN | POLLHUP | POLLERR)) << pollfd.revents;
182     const size_t bytes_to_read = std::min(Peek(), length - bytes_read_total);
183 
184     // There may be zero bytes to read if the socket at the other end closed.
185     if (!bytes_to_read)
186       return bytes_read_total;
187 
188     const size_t bytes_received =
189         Receive(static_cast<char*>(buffer) + bytes_read_total, bytes_to_read);
190     bytes_read_total += bytes_received;
191     if (bytes_received != bytes_to_read)
192       return bytes_read_total;
193   }
194 
195   return bytes_read_total;
196 }
197 
Peek()198 size_t SyncSocket::Peek() {
199   DCHECK_NE(handle_, kInvalidHandle);
200   int number_chars = 0;
201   if (ioctl(handle_, FIONREAD, &number_chars) == -1) {
202     // If there is an error in ioctl, signal that the channel would block.
203     return 0;
204   }
205   DCHECK_GE(number_chars, 0);
206   return number_chars;
207 }
208 
Release()209 SyncSocket::Handle SyncSocket::Release() {
210   Handle r = handle_;
211   handle_ = kInvalidHandle;
212   return r;
213 }
214 
215 CancelableSyncSocket::CancelableSyncSocket() = default;
CancelableSyncSocket(Handle handle)216 CancelableSyncSocket::CancelableSyncSocket(Handle handle)
217     : SyncSocket(handle) {
218 }
219 
Shutdown()220 bool CancelableSyncSocket::Shutdown() {
221   DCHECK_NE(handle_, kInvalidHandle);
222   return HANDLE_EINTR(shutdown(handle_, SHUT_RDWR)) >= 0;
223 }
224 
Send(const void * buffer,size_t length)225 size_t CancelableSyncSocket::Send(const void* buffer, size_t length) {
226   DCHECK_GT(length, 0u);
227   DCHECK_LE(length, kMaxMessageLength);
228   DCHECK_NE(handle_, kInvalidHandle);
229 
230   const int flags = fcntl(handle_, F_GETFL);
231   if (flags != -1 && (flags & O_NONBLOCK) == 0) {
232     // Set the socket to non-blocking mode for sending if its original mode
233     // is blocking.
234     fcntl(handle_, F_SETFL, flags | O_NONBLOCK);
235   }
236 
237   const size_t len = SendHelper(handle_, buffer, length);
238 
239   if (flags != -1 && (flags & O_NONBLOCK) == 0) {
240     // Restore the original flags.
241     fcntl(handle_, F_SETFL, flags);
242   }
243 
244   return len;
245 }
246 
247 // static
CreatePair(CancelableSyncSocket * socket_a,CancelableSyncSocket * socket_b)248 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
249                                       CancelableSyncSocket* socket_b) {
250   return SyncSocket::CreatePair(socket_a, socket_b);
251 }
252 
253 }  // namespace base
254