1 // Copyright (c) 2011 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_
9 #include "ipc/ipc_channel.h"
11 #include <sys/socket.h> // for CMSG macros
17 #include "base/message_loop.h"
18 #include "ipc/file_descriptor_set_posix.h"
20 #if !defined(OS_MACOSX)
21 // On Linux, the seccomp sandbox makes it very expensive to call
22 // recvmsg() and sendmsg(). The restriction on calling read() and write(), which
23 // are cheap, is that we can't pass file descriptors over them.
25 // As we cannot anticipate when the sender will provide us with file
26 // descriptors, we have to make the decision about whether we call read() or
27 // recvmsg() before we actually make the call. The easiest option is to
28 // create a dedicated socketpair() for exchanging file descriptors. Any file
29 // descriptors are split out of a message, with the non-file-descriptor payload
30 // going over the normal connection, and the file descriptors being sent
31 // separately over the other channel. When read()ing from a channel, we'll
32 // notice if the message was supposed to have come with file descriptors and
33 // use recvmsg on the other socketpair to retrieve them and combine them
34 // back with the rest of the message.
36 // Mac can also run in IPC_USES_READWRITE mode if necessary, but at this time
37 // doesn't take a performance hit from recvmsg and sendmsg, so it doesn't
38 // make sense to waste resources on having the separate dedicated socketpair.
39 // It is however useful for debugging between Linux and Mac to be able to turn
40 // this switch 'on' on the Mac as well.
42 // The HELLO message from the client to the server is always sent using
43 // sendmsg because it will contain the file descriptor that the server
44 // needs to send file descriptors in later messages.
45 #define IPC_USES_READWRITE 1
50 class Channel::ChannelImpl
: public MessageLoopForIO::Watcher
{
52 // Mirror methods of Channel, see ipc_channel.h for description.
53 ChannelImpl(const IPC::ChannelHandle
& channel_handle
, Mode mode
,
55 virtual ~ChannelImpl();
58 void set_listener(Listener
* listener
) { listener_
= listener
; }
59 bool Send(Message
* message
);
60 int GetClientFileDescriptor();
61 int TakeClientFileDescriptor();
62 void CloseClientFileDescriptor();
63 bool AcceptsConnections() const;
64 bool HasAcceptedConnection() const;
65 bool GetClientEuid(uid_t
* client_euid
) const;
66 void ResetToAcceptingConnectionState();
67 static bool IsNamedServerInitialized(const std::string
& channel_id
);
69 static void SetGlobalPid(int pid
);
73 bool CreatePipe(const IPC::ChannelHandle
& channel_handle
);
75 bool ProcessIncomingMessages();
76 bool ProcessOutgoingMessages();
78 bool AcceptConnection();
79 void ClosePipeOnError();
80 int GetHelloMessageProcId();
81 void QueueHelloMessage();
82 bool IsHelloMessage(const Message
* m
) const;
84 // MessageLoopForIO::Watcher implementation.
85 virtual void OnFileCanReadWithoutBlocking(int fd
) OVERRIDE
;
86 virtual void OnFileCanWriteWithoutBlocking(int fd
) OVERRIDE
;
90 // After accepting one client connection on our server socket we want to
92 MessageLoopForIO::FileDescriptorWatcher server_listen_connection_watcher_
;
93 MessageLoopForIO::FileDescriptorWatcher read_watcher_
;
94 MessageLoopForIO::FileDescriptorWatcher write_watcher_
;
96 // Indicates whether we're currently blocked waiting for a write to complete.
97 bool is_blocked_on_write_
;
98 bool waiting_connect_
;
100 // If sending a message blocks then we use this variable
101 // to keep track of where we are.
102 size_t message_send_bytes_written_
;
104 // File descriptor we're listening on for new connections if we listen
106 int server_listen_pipe_
;
108 // The pipe used for communication.
111 // For a server, the client end of our socketpair() -- the other end of our
112 // pipe_ that is passed to the client.
114 base::Lock client_pipe_lock_
; // Lock that protects |client_pipe_|.
116 #if defined(IPC_USES_READWRITE)
117 // Linux/BSD use a dedicated socketpair() for passing file descriptors.
122 // The "name" of our pipe. On Windows this is the global identifier for
123 // the pipe. On POSIX it's used as a key in a local map of file descriptors.
124 std::string pipe_name_
;
128 // Messages to be sent are queued here.
129 std::queue
<Message
*> output_queue_
;
131 // We read from the pipe into this buffer
132 char input_buf_
[Channel::kReadBufferSize
];
134 // We assume a worst case: kReadBufferSize bytes of messages, where each
135 // message has no payload and a full complement of descriptors.
136 static const size_t kMaxReadFDs
=
137 (Channel::kReadBufferSize
/ sizeof(IPC::Message::Header
)) *
138 FileDescriptorSet::kMaxDescriptorsPerMessage
;
140 // This is a control message buffer large enough to hold kMaxReadFDs
141 #if defined(OS_MACOSX)
142 // TODO(agl): OSX appears to have non-constant CMSG macros!
143 char input_cmsg_buf_
[1024];
145 char input_cmsg_buf_
[CMSG_SPACE(sizeof(int) * kMaxReadFDs
)];
148 // Large messages that span multiple pipe buffers, get built-up using
150 std::string input_overflow_buf_
;
151 std::vector
<int> input_overflow_fds_
;
153 // True if we are responsible for unlinking the unix domain socket file.
156 #if defined(OS_LINUX)
157 // If non-zero, overrides the process ID sent in the hello message.
158 static int global_pid_
;
161 DISALLOW_IMPLICIT_CONSTRUCTORS(ChannelImpl
);
164 // The maximum length of the name of a pipe for MODE_NAMED_SERVER or
165 // MODE_NAMED_CLIENT if you want to pass in your own socket.
166 // The standard size on linux is 108, mac is 104. To maintain consistency
167 // across platforms we standardize on the smaller value.
168 static const size_t kMaxPipeNameLength
= 104;
172 #endif // IPC_IPC_CHANNEL_POSIX_H_