Define IPC_USES_READWRITE

ipc/ipc_channel_posix.cc

 // Copyright (c) 2010 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 267 matching lines @@
                                   Listener* listener)
     : mode_(mode),
       is_blocked_on_write_(false),
       message_send_bytes_written_(0),
       uses_fifo_(
           CommandLine::ForCurrentProcess()->HasSwitch(switches::kIPCUseFIFO) ||
           mode == MODE_NAMED_SERVER || mode == MODE_NAMED_CLIENT),
       server_listen_pipe_(-1),
       pipe_(-1),
       client_pipe_(-1),
-#if !defined(OS_MACOSX)
+#if defined(IPC_USES_READWRITE)
       fd_pipe_(-1),
       remote_fd_pipe_(-1),
 #endif
       listener_(listener),
       waiting_connect_(true),
       factory_(this) {
   if (mode_ == MODE_NAMED_SERVER)
     mode_ = MODE_SERVER;
   if (mode_ == MODE_NAMED_CLIENT)
     mode_ = MODE_CLIENT;
@@ skipping 101 matching lines @@
       }
     } else {
       waiting_connect_ = mode == MODE_SERVER;
     }
   }
 
   // Create the Hello message to be sent when Connect is called
   scoped_ptr<Message> msg(new Message(MSG_ROUTING_NONE,
                                       HELLO_MESSAGE_TYPE,
                                       IPC::Message::PRIORITY_NORMAL));
-  #if !defined(OS_MACOSX)
+  #if defined(IPC_USES_READWRITE)
   if (!uses_fifo_) {
-    // On Linux, the seccomp sandbox makes it very expensive to call
-    // recvmsg() and sendmsg(). Often, we are perfectly OK with resorting to
-    // read() and write(), which are cheap.
-    //
-    // As we cannot anticipate, when the sender will provide us with file
-    // handles, we have to make the decision about whether we call read() or
-    // recvmsg() before we actually make the call. The easiest option is to
-    // create a dedicated socketpair() for exchanging file handles.
+    // Create a dedicated socketpair() for exchanging file descriptors.
+    // See comments for IPC_USES_READWRITE for details.
     if (mode == MODE_SERVER) {
       fd_pipe_ = -1;
     } else if (remote_fd_pipe_ == -1) {
       if (!SocketPair(&fd_pipe_, &remote_fd_pipe_)) {
         return false;
       }
     }
   }
   #endif
   if (!msg->WriteInt(base::GetCurrentProcId())) {
@@ skipping 46 matching lines @@
   for (;;) {
     msg.msg_iov = &iov;
 
     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.
-#if !defined(OS_MACOSX)
+#if defined(IPC_USES_READWRITE)
       if (fd_pipe_ >= 0) {
         bytes_read = HANDLE_EINTR(read(pipe_, input_buf_,
                                        Channel::kReadBufferSize));
         msg.msg_controllen = 0;
       } else
 #endif
       {
         msg.msg_controllen = sizeof(input_cmsg_buf_);
         bytes_read = HANDLE_EINTR(recvmsg(pipe_, &msg, MSG_DONTWAIT));
       }
@@ skipping 112 matching lines @@
       if (message_tail) {
         int len = static_cast<int>(message_tail - p);
         Message m(p, len);
 
         if (m.header()->num_fds) {
           // the message has file descriptors
           const char* error = NULL;
           if (m.header()->num_fds > num_fds - fds_i) {
             // the message has been completely received, but we didn't get
             // enough file descriptors.
-#if !defined(OS_MACOSX)
+#if defined(IPC_USES_READWRITE)
             if (!uses_fifo_) {
               char dummy;
               struct iovec fd_pipe_iov = { &dummy, 1 };
               msg.msg_iov = &fd_pipe_iov;
               msg.msg_controllen = sizeof(input_cmsg_buf_);
               ssize_t n = HANDLE_EINTR(recvmsg(fd_pipe_, &msg, MSG_DONTWAIT));
               if (n == 1 && msg.msg_controllen > 0) {
                 for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); cmsg;
                      cmsg = CMSG_NXTHDR(&msg, cmsg)) {
                   if (cmsg->cmsg_level == SOL_SOCKET &&
@@ skipping 69 matching lines @@
         DVLOG(2) << "received message on channel @" << this
                  << " with type " << m.type();
         if (m.routing_id() == MSG_ROUTING_NONE &&
             m.type() == HELLO_MESSAGE_TYPE) {
           // The Hello message contains only the process id.
           void *iter = NULL;
           int pid;
           if (!m.ReadInt(&iter, &pid)) {
             NOTREACHED();
           }
-#if !defined(OS_MACOSX)
+#if defined(IPC_USES_READWRITE)
           if (mode_ == MODE_SERVER && !uses_fifo_) {
             // On non-Mac, the Hello message from the client to the server
             // also contains the fd_pipe_, which  will be used for all
             // subsequent file descriptor passing.
             DCHECK_EQ(m.file_descriptor_set()->size(), 1U);
             base::FileDescriptor descriptor;
             if (!m.ReadFileDescriptor(&iter, &descriptor)) {
               NOTREACHED();
             }
             fd_pipe_ = descriptor.fd;
@@ skipping 42 matching lines @@
 
   if (pipe_ == -1) {
     return false;
   }
 
   // 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();
 
-#if !defined(OS_MACOSX)
+#if defined(IPC_USES_READWRITE)
     scoped_ptr<Message> hello;
     if (remote_fd_pipe_ != -1 &&
         msg->routing_id() == MSG_ROUTING_NONE &&
         msg->type() == HELLO_MESSAGE_TYPE) {
       hello.reset(new Message(MSG_ROUTING_NONE,
                               HELLO_MESSAGE_TYPE,
                               IPC::Message::PRIORITY_NORMAL));
       void* iter = NULL;
       int pid;
       if (!msg->ReadInt(&iter, &pid) ||
@@ skipping 49 matching lines @@
       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 above already checks that
       // num_fds < MAX_DESCRIPTORS_PER_MESSAGE so no danger of overflow.
       msg->header()->num_fds = static_cast<uint16>(num_fds);
 
-#if !defined(OS_MACOSX)
+#if defined(IPC_USES_READWRITE)
       if (!uses_fifo_ &&
           (msg->routing_id() != MSG_ROUTING_NONE ||
            msg->type() != HELLO_MESSAGE_TYPE)) {
         // Only the Hello message sends the file descriptor with the message.
         // Subsequently, we can send file descriptors on the dedicated
         // fd_pipe_ which makes Seccomp sandbox operation more efficient.
         struct iovec fd_pipe_iov = { const_cast<char *>(""), 1 };
         msgh.msg_iov = &fd_pipe_iov;
         fd_written = fd_pipe_;
         bytes_written = HANDLE_EINTR(sendmsg(fd_pipe_, &msgh, MSG_DONTWAIT));
         msgh.msg_iov = &iov;
         msgh.msg_controllen = 0;
         if (bytes_written > 0) {
           msg->file_descriptor_set()->CommitAll();
         }
       }
 #endif
     }
 
     if (bytes_written == 1) {
       fd_written = pipe_;
-#if !defined(OS_MACOSX)
+#if defined(IPC_USES_READWRITE)
       if (mode_ != MODE_SERVER && !uses_fifo_ &&
           msg->routing_id() == MSG_ROUTING_NONE &&
           msg->type() == HELLO_MESSAGE_TYPE) {
         DCHECK_EQ(msg->file_descriptor_set()->size(), 1U);
       }
       if (!uses_fifo_ && !msgh.msg_controllen) {
         bytes_written = HANDLE_EINTR(write(pipe_, out_bytes, amt_to_write));
       } else
 #endif
       {
@@ skipping 148 matching lines @@
   write_watcher_.StopWatchingFileDescriptor();
   if (pipe_ != -1) {
     if (HANDLE_EINTR(close(pipe_)) < 0)
       PLOG(ERROR) << "close";
     pipe_ = -1;
   }
   if (client_pipe_ != -1) {
     PipeMap::GetInstance()->RemoveAndClose(pipe_name_);
     client_pipe_ = -1;
   }
-#if !defined(OS_MACOSX)
+#if defined(IPC_USES_READWRITE)
   if (fd_pipe_ != -1) {
     if (HANDLE_EINTR(close(fd_pipe_)) < 0)
       PLOG(ERROR) << "close";
     fd_pipe_ = -1;
   }
   if (remote_fd_pipe_ != -1) {
     if (HANDLE_EINTR(close(remote_fd_pipe_)) < 0)
       PLOG(ERROR) << "close";
     remote_fd_pipe_ = -1;
   }
@@ skipping 44 matching lines @@
 
 bool Channel::Send(Message* message) {
   return channel_impl_->Send(message);
 }
 
 int Channel::GetClientFileDescriptor() const {
   return channel_impl_->GetClientFileDescriptor();
 }
 
 }  // namespace IPC