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.
5 #ifndef IPC_IPC_CHANNEL_POSIX_H_
6 #define IPC_IPC_CHANNEL_POSIX_H_
8 #include "ipc/ipc_channel.h"
10 #include <sys/socket.h> // for CMSG macros
17 #include "base/files/scoped_file.h"
18 #include "base/message_loop/message_loop.h"
19 #include "base/process/process.h"
20 #include "ipc/file_descriptor_set_posix.h"
21 #include "ipc/ipc_channel_reader.h"
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.
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.
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.
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
53 class IPC_EXPORT ChannelPosix
: public Channel
,
54 public internal::ChannelReader
,
55 public base::MessageLoopForIO::Watcher
{
57 ChannelPosix(const IPC::ChannelHandle
& channel_handle
, Mode mode
,
59 virtual ~ChannelPosix();
61 // Channel implementation
62 virtual bool Connect() override
;
63 virtual void Close() override
;
64 virtual bool Send(Message
* message
) override
;
65 virtual base::ProcessId
GetPeerPID() const override
;
66 virtual base::ProcessId
GetSelfPID() const override
;
67 virtual int GetClientFileDescriptor() const override
;
68 virtual int TakeClientFileDescriptor() override
;
70 // Returns true if the channel supports listening for connections.
71 bool AcceptsConnections() const;
73 // Returns true if the channel supports listening for connections and is
74 // currently connected.
75 bool HasAcceptedConnection() const;
77 // Closes any currently connected socket, and returns to a listening state
78 // for more connections.
79 void ResetToAcceptingConnectionState();
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;
85 void CloseClientFileDescriptor();
87 static bool IsNamedServerInitialized(const std::string
& channel_id
);
89 static void SetGlobalPid(int pid
);
93 bool CreatePipe(const IPC::ChannelHandle
& channel_handle
);
95 bool ProcessOutgoingMessages();
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
);
104 // ChannelReader implementation.
105 virtual ReadState
ReadData(char* buffer
,
107 int* bytes_read
) override
;
108 virtual bool WillDispatchInputMessage(Message
* msg
) override
;
109 virtual bool DidEmptyInputBuffers() override
;
110 virtual void HandleInternalMessage(const Message
& msg
) override
;
112 #if defined(IPC_USES_READWRITE)
113 // Reads the next message from the fd_pipe_ and appends them to the
114 // input_fds_ queue. Returns false if there was a message receiving error.
115 // True means there was a message and it was processed properly, or there was
117 bool ReadFileDescriptorsFromFDPipe();
120 // Finds the set of file descriptors in the given message. On success,
121 // appends the descriptors to the input_fds_ member and returns true
123 // Returns false if the message was truncated. In this case, any handles that
124 // were sent will be closed.
125 bool ExtractFileDescriptorsFromMsghdr(msghdr
* msg
);
127 // Closes all handles in the input_fds_ list and clears the list. This is
128 // used to clean up handles in error conditions to avoid leaking the handles.
129 void ClearInputFDs();
131 // MessageLoopForIO::Watcher implementation.
132 virtual void OnFileCanReadWithoutBlocking(int fd
) override
;
133 virtual void OnFileCanWriteWithoutBlocking(int fd
) override
;
137 base::ProcessId peer_pid_
;
139 // After accepting one client connection on our server socket we want to
141 base::MessageLoopForIO::FileDescriptorWatcher
142 server_listen_connection_watcher_
;
143 base::MessageLoopForIO::FileDescriptorWatcher read_watcher_
;
144 base::MessageLoopForIO::FileDescriptorWatcher write_watcher_
;
146 // Indicates whether we're currently blocked waiting for a write to complete.
147 bool is_blocked_on_write_
;
148 bool waiting_connect_
;
150 // If sending a message blocks then we use this variable
151 // to keep track of where we are.
152 size_t message_send_bytes_written_
;
154 // File descriptor we're listening on for new connections if we listen
156 base::ScopedFD server_listen_pipe_
;
158 // The pipe used for communication.
159 base::ScopedFD pipe_
;
161 // For a server, the client end of our socketpair() -- the other end of our
162 // pipe_ that is passed to the client.
163 base::ScopedFD client_pipe_
;
164 mutable base::Lock client_pipe_lock_
; // Lock that protects |client_pipe_|.
166 #if defined(IPC_USES_READWRITE)
167 // Linux/BSD use a dedicated socketpair() for passing file descriptors.
168 base::ScopedFD fd_pipe_
;
169 base::ScopedFD remote_fd_pipe_
;
172 // The "name" of our pipe. On Windows this is the global identifier for
173 // the pipe. On POSIX it's used as a key in a local map of file descriptors.
174 std::string pipe_name_
;
176 // Messages to be sent are queued here.
177 std::queue
<Message
*> output_queue_
;
179 // We assume a worst case: kReadBufferSize bytes of messages, where each
180 // message has no payload and a full complement of descriptors.
181 static const size_t kMaxReadFDs
=
182 (Channel::kReadBufferSize
/ sizeof(IPC::Message::Header
)) *
183 FileDescriptorSet::kMaxDescriptorsPerMessage
;
185 // Buffer size for file descriptors used for recvmsg. On Mac the CMSG macros
186 // don't seem to be constant so we have to pick a "large enough" value.
187 #if defined(OS_MACOSX)
188 static const size_t kMaxReadFDBuffer
= 1024;
190 static const size_t kMaxReadFDBuffer
= CMSG_SPACE(sizeof(int) * kMaxReadFDs
);
193 // Temporary buffer used to receive the file descriptors from recvmsg.
194 // Code that writes into this should immediately read them out and save
195 // them to input_fds_, since this buffer will be re-used anytime we call
197 char input_cmsg_buf_
[kMaxReadFDBuffer
];
199 // File descriptors extracted from messages coming off of the channel. The
200 // handles may span messages and come off different channels from the message
201 // data (in the case of READWRITE), and are processed in FIFO here.
202 // NOTE: The implementation assumes underlying storage here is contiguous, so
203 // don't change to something like std::deque<> without changing the
205 std::vector
<int> input_fds_
;
207 #if defined(OS_MACOSX)
208 // On OSX, sent FDs must not be closed until we get an ack.
209 // Keep track of sent FDs here to make sure the remote is not
210 // trying to bamboozle us.
211 std::set
<int> fds_to_close_
;
214 // True if we are responsible for unlinking the unix domain socket file.
217 #if defined(OS_LINUX)
218 // If non-zero, overrides the process ID sent in the hello message.
219 static int global_pid_
;
222 DISALLOW_IMPLICIT_CONSTRUCTORS(ChannelPosix
);
227 #endif // IPC_IPC_CHANNEL_POSIX_H_