ipc: remove IPC_USES_READWRITE

ipc/ipc_channel_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 "ipc/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
@@ skipping 229 matching lines @@
   // 3) It's for a client that we implement ourself. This is used
   //    in single-process unittesting.
   // 4) It's the initial IPC channel:
   //   4a) Client side: Pull the pipe out of the GlobalDescriptors set.
   //   4b) Server side: create the pipe.
 
   base::ScopedFD local_pipe;
   if (channel_handle.socket.fd != -1) {
     // Case 1 from comment above.
     local_pipe.reset(channel_handle.socket.fd);
-#if defined(IPC_USES_READWRITE)
-    // Test the socket passed into us to make sure it is nonblocking.
-    // We don't want to call read/write on a blocking socket.
-    int value = fcntl(local_pipe.get(), F_GETFL);
-    if (value == -1) {
-      PLOG(ERROR) << "fcntl(F_GETFL) " << pipe_name_;
-      return false;
-    }
-    if (!(value & O_NONBLOCK)) {
-      LOG(ERROR) << "Socket " << pipe_name_ << " must be O_NONBLOCK";
-      return false;
-    }
-#endif   // IPC_USES_READWRITE
   } else if (mode_ & MODE_NAMED_FLAG) {
 #if defined(OS_NACL_NONSFI)
     LOG(FATAL)
         << "IPC channels in nacl_helper_nonsfi should not be in NAMED mode.";
 #else
     // Case 2 from comment above.
     int local_pipe_fd = -1;
 
     if (mode_ & MODE_SERVER_FLAG) {
       if (!CreateServerUnixDomainSocket(base::FilePath(pipe_name_),
@@ skipping 52 matching lines @@
       if (!SocketPair(&local_pipe_fd, &client_pipe_fd))
         return false;
       local_pipe.reset(local_pipe_fd);
       client_pipe_.reset(client_pipe_fd);
       PipeMap::GetInstance()->Insert(pipe_name_, client_pipe_fd);
     } else {
       LOG(ERROR) << "Bad mode: " << mode_;
       return false;
     }
   }
 

[hidehiko, 2015/05/18 04:54:05]

nit: unnecessary empty line?

[mdempsky, 2015/05/18 17:58:37]

Done.

-#if defined(IPC_USES_READWRITE)
-  // Create a dedicated socketpair() for exchanging file descriptors.
-  // See comments for IPC_USES_READWRITE for details.
-  if (mode_ & MODE_CLIENT_FLAG) {
-    int fd_pipe_fd = 1, remote_fd_pipe_fd = -1;
-    if (!SocketPair(&fd_pipe_fd, &remote_fd_pipe_fd)) {
-      return false;
-    }
-
-    fd_pipe_.reset(fd_pipe_fd);
-    remote_fd_pipe_.reset(remote_fd_pipe_fd);
-  }
-#endif  // IPC_USES_READWRITE
 
   if ((mode_ & MODE_SERVER_FLAG) && (mode_ & MODE_NAMED_FLAG)) {
 #if defined(OS_NACL_NONSFI)
     LOG(FATAL) << "IPC channels in nacl_helper_nonsfi "
                << "should not be in NAMED or SERVER mode.";
 #else
     server_listen_pipe_.reset(local_pipe.release());
 #endif
   } else {
     pipe_.reset(local_pipe.release());
@@ skipping 100 matching lines @@
       cmsg->cmsg_level = SOL_SOCKET;
       cmsg->cmsg_type = SCM_RIGHTS;
       cmsg->cmsg_len = CMSG_LEN(sizeof(int) * num_fds);
       msg->attachment_set()->PeekDescriptors(
           reinterpret_cast<int*>(CMSG_DATA(cmsg)));
       msgh.msg_controllen = cmsg->cmsg_len;
 
       // DCHECK_LE above already checks that
       // num_fds < kMaxDescriptorsPerMessage so no danger of overflow.
       msg->header()->num_fds = static_cast<uint16>(num_fds);
 

[hidehiko, 2015/05/18 04:54:05]

nit: unnecessary empty line?

[mdempsky, 2015/05/18 17:58:36]

Done.

-#if defined(IPC_USES_READWRITE)
-      if (!IsHelloMessage(*msg)) {
-        // 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_.get();
-        bytes_written =
-            HANDLE_EINTR(sendmsg(fd_pipe_.get(), &msgh, MSG_DONTWAIT));
-        msgh.msg_iov = &iov;
-        msgh.msg_controllen = 0;
-        if (bytes_written > 0) {
-          CloseFileDescriptors(msg);
-        }
-      }
-#endif  // IPC_USES_READWRITE
     }
 
     if (bytes_written == 1) {
       fd_written = pipe_.get();
-#if defined(IPC_USES_READWRITE)
-      if ((mode_ & MODE_CLIENT_FLAG) && IsHelloMessage(*msg)) {
-        DCHECK_EQ(msg->attachment_set()->size(), 1U);
-      }
-      if (!msgh.msg_controllen) {
-        bytes_written =
-            HANDLE_EINTR(write(pipe_.get(), out_bytes, amt_to_write));
-      } else
-#endif  // IPC_USES_READWRITE
       {

[hidehiko, 2015/05/18 04:54:05]

nit: you do not need this brace pair.

[mdempsky, 2015/05/18 17:58:37]

Done.

         bytes_written = HANDLE_EINTR(sendmsg(pipe_.get(), &msgh, MSG_DONTWAIT));
       }
     }
     if (bytes_written > 0)
       CloseFileDescriptors(msg);
 
     if (bytes_written < 0 && !SocketWriteErrorIsRecoverable()) {
       // We can't close the pipe here, because calling OnChannelError
       // may destroy this object, and that would be bad if we are
       // called from Send(). Instead, we return false and hope the
@@ skipping 98 matching lines @@
   DCHECK(!(mode_ & MODE_SERVER) || HasAcceptedConnection());
   return IPC::GetPeerEuid(pipe_.get(), peer_euid);
 }
 #endif
 
 void ChannelPosix::ResetToAcceptingConnectionState() {
   // Unregister libevent for the unix domain socket and close it.
   read_watcher_.StopWatchingFileDescriptor();
   write_watcher_.StopWatchingFileDescriptor();
   ResetSafely(&pipe_);
-#if defined(IPC_USES_READWRITE)
-  fd_pipe_.reset();
-  remote_fd_pipe_.reset();
-#endif  // IPC_USES_READWRITE
 
   while (!output_queue_.empty()) {
     Message* m = output_queue_.front();
     output_queue_.pop();
     delete m;
   }
 
   // Close any outstanding, received file descriptors.
   ClearInputFDs();
 
@@ skipping 158 matching lines @@
 }
 
 void ChannelPosix::QueueHelloMessage() {
   // Create the Hello message
   scoped_ptr<Message> msg(new Message(MSG_ROUTING_NONE,
                                       HELLO_MESSAGE_TYPE,
                                       IPC::Message::PRIORITY_NORMAL));
   if (!msg->WriteInt(GetHelloMessageProcId())) {
     NOTREACHED() << "Unable to pickle hello message proc id";
   }
-#if defined(IPC_USES_READWRITE)
-  scoped_ptr<Message> hello;
-  if (remote_fd_pipe_.is_valid()) {
-    if (!msg->WriteAttachment(
-            new internal::PlatformFileAttachment(remote_fd_pipe_.get()))) {
-      NOTREACHED() << "Unable to pickle hello message file descriptors";
-    }
-    DCHECK_EQ(msg->attachment_set()->size(), 1U);
-  }
-#endif  // IPC_USES_READWRITE
   output_queue_.push(msg.release());
 }
 
 ChannelPosix::ReadState ChannelPosix::ReadData(
     char* buffer,
     int buffer_len,
     int* bytes_read) {
   if (!pipe_.is_valid())
     return READ_FAILED;
 
   struct msghdr msg = {0};
 
   struct iovec iov = {buffer, static_cast<size_t>(buffer_len)};
   msg.msg_iov = &iov;
   msg.msg_iovlen = 1;
 
   msg.msg_control = input_cmsg_buf_;
 
   // recvmsg() returns 0 if the connection has closed or EAGAIN if no data
   // is waiting on the pipe.
-#if defined(IPC_USES_READWRITE)
-  if (fd_pipe_.is_valid()) {
-    *bytes_read = HANDLE_EINTR(read(pipe_.get(), buffer, buffer_len));
-    msg.msg_controllen = 0;
-  } else
-#endif  // IPC_USES_READWRITE
   {

[hidehiko, 2015/05/18 04:54:05]

nit, you do not need this brace pair.

[mdempsky, 2015/05/18 17:58:36]

Done.

     msg.msg_controllen = sizeof(input_cmsg_buf_);
     *bytes_read = HANDLE_EINTR(recvmsg(pipe_.get(), &msg, MSG_DONTWAIT));
   }
   if (*bytes_read < 0) {
     if (errno == EAGAIN) {
       return READ_PENDING;
 #if defined(OS_MACOSX)
     } else if (errno == EPERM) {
       // On OSX, reading from a pipe with no listener returns EPERM
       // treat this as a special case to prevent spurious error messages
@@ skipping 13 matching lines @@
   DCHECK(*bytes_read);
 
   CloseClientFileDescriptor();
 
   // Read any file descriptors from the message.
   if (!ExtractFileDescriptorsFromMsghdr(&msg))
     return READ_FAILED;
   return READ_SUCCEEDED;
 }
 
-#if defined(IPC_USES_READWRITE)
-bool ChannelPosix::ReadFileDescriptorsFromFDPipe() {
-  char dummy;
-  struct iovec fd_pipe_iov = { &dummy, 1 };
-
-  struct msghdr msg = { 0 };
-  msg.msg_iov = &fd_pipe_iov;
-  msg.msg_iovlen = 1;
-  msg.msg_control = input_cmsg_buf_;
-  msg.msg_controllen = sizeof(input_cmsg_buf_);
-  ssize_t bytes_received =
-      HANDLE_EINTR(recvmsg(fd_pipe_.get(), &msg, MSG_DONTWAIT));
-
-  if (bytes_received != 1)
-    return true;  // No message waiting.
-
-  if (!ExtractFileDescriptorsFromMsghdr(&msg))
-    return false;
-  return true;
-}
-#endif
 
 // On Posix, we need to fix up the file descriptors before the input message
 // is dispatched.
 //
 // This will read from the input_fds_ (READWRITE mode only) and read more
 // handles from the FD pipe if necessary.
 bool ChannelPosix::WillDispatchInputMessage(Message* msg) {
   uint16 header_fds = msg->header()->num_fds;
   if (!header_fds)
     return true;  // Nothing to do.
 
   // The message has file descriptors.
   const char* error = NULL;
   if (header_fds > input_fds_.size()) {
     // The message has been completely received, but we didn't get
     // enough file descriptors.
-#if defined(IPC_USES_READWRITE)
-    if (!ReadFileDescriptorsFromFDPipe())
-      return false;
-    if (header_fds > input_fds_.size())
-#endif  // IPC_USES_READWRITE
       error = "Message needs unreceived descriptors";

[hidehiko, 2015/05/18 04:54:05]

nit: indent?

[mdempsky, 2015/05/18 17:58:37]

Done.

   }
 
   if (header_fds > MessageAttachmentSet::kMaxDescriptorsPerMessage)
     error = "Message requires an excessive number of descriptors";
 
   if (error) {
     LOG(WARNING) << error
                  << " channel:" << this
                  << " message-type:" << msg->type()
                  << " header()->num_fds:" << header_fds;
@@ skipping 86 matching lines @@
   switch (msg.type()) {
     default:
       NOTREACHED();
       break;
 
     case Channel::HELLO_MESSAGE_TYPE:
       int pid;
       if (!iter.ReadInt(&pid))
         NOTREACHED();
 
-#if defined(IPC_USES_READWRITE)
-      if (mode_ & MODE_SERVER_FLAG) {
-        // With IPC_USES_READWRITE, 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(msg.attachment_set()->size(), 1U);
-        scoped_refptr<MessageAttachment> attachment;
-        if (!msg.ReadAttachment(&iter, &attachment)) {
-          NOTREACHED();
-        }
-        fd_pipe_.reset(attachment->TakePlatformFile());
-      }
-#endif  // IPC_USES_READWRITE
       peer_pid_ = pid;
       listener()->OnChannelConnected(pid);
       break;
 
 #if defined(OS_MACOSX)
     case Channel::CLOSE_FD_MESSAGE_TYPE:
       int fd, hops;
       if (!iter.ReadInt(&hops))
         NOTREACHED();
       if (!iter.ReadInt(&fd))
@@ skipping 93 matching lines @@
 }
 
 #if defined(OS_LINUX)
 // static
 void Channel::SetGlobalPid(int pid) {
   ChannelPosix::SetGlobalPid(pid);
 }
 #endif  // OS_LINUX
 
 }  // namespace IPC