ipc/ipc_channel_posix.h

   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 #ifndef IPC_IPC_CHANNEL_POSIX_H_
   6 #define IPC_IPC_CHANNEL_POSIX_H_
   7
   8 #include "ipc/ipc_channel.h"
   9
  10 #include <sys/socket.h>  // for CMSG macros
  11
  12 #include <queue>
  13 #include <set>
  14 #include <string>
  15 #include <vector>
  16
  17 #include "base/files/scoped_file.h"
  18 #include "base/message_loop/message_loop.h"
  19 #include "base/process/process.h"
  20 #include "ipc/ipc_channel_reader.h"
  21 #include "ipc/ipc_message_attachment_set.h"
  22
  23 #if !defined(OS_MACOSX)
  24 // On Linux, the seccomp sandbox makes it very expensive to call
  25 // recvmsg() and sendmsg(). The restriction on calling read() and write(), which
  26 // are cheap, is that we can't pass file descriptors over them.
  27 //
  28 // As we cannot anticipate when the sender will provide us with file
  29 // descriptors, we have to make the decision about whether we call read() or
  30 // recvmsg() before we actually make the call. The easiest option is to
  31 // create a dedicated socketpair() for exchanging file descriptors. Any file
  32 // descriptors are split out of a message, with the non-file-descriptor payload
  33 // going over the normal connection, and the file descriptors being sent
  34 // separately over the other channel. When read()ing from a channel, we'll
  35 // notice if the message was supposed to have come with file descriptors and
  36 // use recvmsg on the other socketpair to retrieve them and combine them
  37 // back with the rest of the message.
  38 //
  39 // Mac can also run in IPC_USES_READWRITE mode if necessary, but at this time
  40 // doesn't take a performance hit from recvmsg and sendmsg, so it doesn't
  41 // make sense to waste resources on having the separate dedicated socketpair.
  42 // It is however useful for debugging between Linux and Mac to be able to turn
  43 // this switch 'on' on the Mac as well.
  44 //
  45 // The HELLO message from the client to the server is always sent using
  46 // sendmsg because it will contain the file descriptor that the server
  47 // needs to send file descriptors in later messages.
  48 #define IPC_USES_READWRITE 1
  49 #endif
  50
  51 namespace IPC {
  52
  53 class IPC_EXPORT ChannelPosix : public Channel,
  54                                 public internal::ChannelReader,
  55                                 public base::MessageLoopForIO::Watcher {
  56  public:
  57   ChannelPosix(const IPC::ChannelHandle& channel_handle, Mode mode,
  58                Listener* listener);
  59   ~ChannelPosix() override;
  60
  61   // Channel implementation
  62   bool Connect() override;
  63   void Close() override;
  64   bool Send(Message* message) override;
  65   base::ProcessId GetPeerPID() const override;
  66   base::ProcessId GetSelfPID() const override;
  67   int GetClientFileDescriptor() const override;
  68   base::ScopedFD TakeClientFileDescriptor() override;
  69
  70   // Returns true if the channel supports listening for connections.
  71   bool AcceptsConnections() const;
  72
  73   // Returns true if the channel supports listening for connections and is
  74   // currently connected.
  75   bool HasAcceptedConnection() const;
  76
  77   // Closes any currently connected socket, and returns to a listening state
  78   // for more connections.
  79   void ResetToAcceptingConnectionState();
  80
  81   // Returns true if the peer process' effective user id can be determined, in
  82   // which case the supplied peer_euid is updated with it.
  83   bool GetPeerEuid(uid_t* peer_euid) const;
  84
  85   void CloseClientFileDescriptor();
  86
  87   static bool IsNamedServerInitialized(const std::string& channel_id);
  88 #if defined(OS_LINUX)
  89   static void SetGlobalPid(int pid);
  90 #endif  // OS_LINUX
  91
  92  private:
  93   bool CreatePipe(const IPC::ChannelHandle& channel_handle);
  94
  95   bool ProcessOutgoingMessages();
  96
  97   bool AcceptConnection();
  98   void ClosePipeOnError();
  99   int GetHelloMessageProcId() const;
 100   void QueueHelloMessage();
 101   void CloseFileDescriptors(Message* msg);
 102   void QueueCloseFDMessage(int fd, int hops);
 103
 104   // ChannelReader implementation.
 105   ReadState ReadData(char* buffer, int buffer_len, int* bytes_read) override;
 106   bool WillDispatchInputMessage(Message* msg) override;
 107   bool DidEmptyInputBuffers() override;
 108   void HandleInternalMessage(const Message& msg) override;
 109
 110 #if defined(IPC_USES_READWRITE)
 111   // Reads the next message from the fd_pipe_ and appends them to the
 112   // input_fds_ queue. Returns false if there was a message receiving error.
 113   // True means there was a message and it was processed properly, or there was
 114   // no messages.
 115   bool ReadFileDescriptorsFromFDPipe();
 116 #endif
 117
 118   // Finds the set of file descriptors in the given message.  On success,
 119   // appends the descriptors to the input_fds_ member and returns true
 120   //
 121   // Returns false if the message was truncated. In this case, any handles that
 122   // were sent will be closed.
 123   bool ExtractFileDescriptorsFromMsghdr(msghdr* msg);
 124
 125   // Closes all handles in the input_fds_ list and clears the list. This is
 126   // used to clean up handles in error conditions to avoid leaking the handles.
 127   void ClearInputFDs();
 128
 129   // MessageLoopForIO::Watcher implementation.
 130   void OnFileCanReadWithoutBlocking(int fd) override;
 131   void OnFileCanWriteWithoutBlocking(int fd) override;
 132
 133   Mode mode_;
 134
 135   base::ProcessId peer_pid_;
 136
 137   // After accepting one client connection on our server socket we want to
 138   // stop listening.
 139   base::MessageLoopForIO::FileDescriptorWatcher
 140   server_listen_connection_watcher_;
 141   base::MessageLoopForIO::FileDescriptorWatcher read_watcher_;
 142   base::MessageLoopForIO::FileDescriptorWatcher write_watcher_;
 143
 144   // Indicates whether we're currently blocked waiting for a write to complete.
 145   bool is_blocked_on_write_;
 146   bool waiting_connect_;
 147
 148   // If sending a message blocks then we use this variable
 149   // to keep track of where we are.
 150   size_t message_send_bytes_written_;
 151
 152   // File descriptor we're listening on for new connections if we listen
 153   // for connections.
 154   base::ScopedFD server_listen_pipe_;
 155
 156   // The pipe used for communication.
 157   base::ScopedFD pipe_;
 158
 159   // For a server, the client end of our socketpair() -- the other end of our
 160   // pipe_ that is passed to the client.
 161   base::ScopedFD client_pipe_;
 162   mutable base::Lock client_pipe_lock_;  // Lock that protects |client_pipe_|.
 163
 164 #if defined(IPC_USES_READWRITE)
 165   // Linux/BSD use a dedicated socketpair() for passing file descriptors.
 166   base::ScopedFD fd_pipe_;
 167   base::ScopedFD remote_fd_pipe_;
 168 #endif
 169
 170   // The "name" of our pipe.  On Windows this is the global identifier for
 171   // the pipe.  On POSIX it's used as a key in a local map of file descriptors.
 172   std::string pipe_name_;
 173
 174   // Messages to be sent are queued here.
 175   std::queue<Message*> output_queue_;
 176
 177   // We assume a worst case: kReadBufferSize bytes of messages, where each
 178   // message has no payload and a full complement of descriptors.
 179   static const size_t kMaxReadFDs =
 180       (Channel::kReadBufferSize / sizeof(IPC::Message::Header)) *
 181       MessageAttachmentSet::kMaxDescriptorsPerMessage;
 182
 183   // Buffer size for file descriptors used for recvmsg. On Mac the CMSG macros
 184   // don't seem to be constant so we have to pick a "large enough" value.
 185 #if defined(OS_MACOSX)
 186   static const size_t kMaxReadFDBuffer = 1024;
 187 #else
 188   static const size_t kMaxReadFDBuffer = CMSG_SPACE(sizeof(int) * kMaxReadFDs);
 189 #endif
 190
 191   // Temporary buffer used to receive the file descriptors from recvmsg.
 192   // Code that writes into this should immediately read them out and save
 193   // them to input_fds_, since this buffer will be re-used anytime we call
 194   // recvmsg.
 195   char input_cmsg_buf_[kMaxReadFDBuffer];
 196
 197   // File descriptors extracted from messages coming off of the channel. The
 198   // handles may span messages and come off different channels from the message
 199   // data (in the case of READWRITE), and are processed in FIFO here.
 200   // NOTE: The implementation assumes underlying storage here is contiguous, so
 201   // don't change to something like std::deque<> without changing the
 202   // implementation!
 203   std::vector<int> input_fds_;
 204
 205
 206   void ResetSafely(base::ScopedFD* fd);
 207   bool in_dtor_;
 208
 209 #if defined(OS_MACOSX)
 210   // On OSX, sent FDs must not be closed until we get an ack.
 211   // Keep track of sent FDs here to make sure the remote is not
 212   // trying to bamboozle us.
 213   std::set<int> fds_to_close_;
 214 #endif
 215
 216   // True if we are responsible for unlinking the unix domain socket file.
 217   bool must_unlink_;
 218
 219 #if defined(OS_LINUX)
 220   // If non-zero, overrides the process ID sent in the hello message.
 221   static int global_pid_;
 222 #endif  // OS_LINUX
 223
 224   DISALLOW_IMPLICIT_CONSTRUCTORS(ChannelPosix);
 225 };
 226
 227 }  // namespace IPC
 228
 229 #endif  // IPC_IPC_CHANNEL_POSIX_H_