Extract LoginPerformer to chromeos/auth
[chromium-blink-merge.git] / ipc / ipc_channel_posix_unittest.cc
blob786623b80622102288d4217037326e83d11f752c
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 // These tests are POSIX only.
7 #include "ipc/ipc_channel_posix.h"
9 #include <fcntl.h>
10 #include <sys/socket.h>
11 #include <sys/un.h>
12 #include <unistd.h>
14 #include "base/basictypes.h"
15 #include "base/files/file_path.h"
16 #include "base/files/file_util.h"
17 #include "base/memory/scoped_ptr.h"
18 #include "base/message_loop/message_loop.h"
19 #include "base/path_service.h"
20 #include "base/posix/eintr_wrapper.h"
21 #include "base/process/kill.h"
22 #include "base/test/multiprocess_test.h"
23 #include "base/test/test_timeouts.h"
24 #include "ipc/ipc_listener.h"
25 #include "ipc/unix_domain_socket_util.h"
26 #include "testing/multiprocess_func_list.h"
28 namespace {
30 static const uint32 kQuitMessage = 47;
32 class IPCChannelPosixTestListener : public IPC::Listener {
33 public:
34 enum STATUS {
35 DISCONNECTED,
36 MESSAGE_RECEIVED,
37 CHANNEL_ERROR,
38 CONNECTED,
39 DENIED,
40 LISTEN_ERROR
43 IPCChannelPosixTestListener(bool quit_only_on_message)
44 : status_(DISCONNECTED),
45 quit_only_on_message_(quit_only_on_message) {
48 ~IPCChannelPosixTestListener() override {}
50 bool OnMessageReceived(const IPC::Message& message) override {
51 EXPECT_EQ(message.type(), kQuitMessage);
52 status_ = MESSAGE_RECEIVED;
53 QuitRunLoop();
54 return true;
57 void OnChannelConnected(int32 peer_pid) override {
58 status_ = CONNECTED;
59 if (!quit_only_on_message_) {
60 QuitRunLoop();
64 void OnChannelError() override {
65 status_ = CHANNEL_ERROR;
66 QuitRunLoop();
69 void OnChannelDenied() override {
70 status_ = DENIED;
71 if (!quit_only_on_message_) {
72 QuitRunLoop();
76 void OnChannelListenError() override {
77 status_ = LISTEN_ERROR;
78 if (!quit_only_on_message_) {
79 QuitRunLoop();
83 STATUS status() { return status_; }
85 void QuitRunLoop() {
86 base::MessageLoopForIO* loop = base::MessageLoopForIO::current();
87 if (loop->is_running()) {
88 loop->QuitNow();
89 } else {
90 // Die as soon as Run is called.
91 loop->PostTask(FROM_HERE, loop->QuitClosure());
95 private:
96 // The current status of the listener.
97 STATUS status_;
98 // If |quit_only_on_message_| then the listener will only break out of
99 // the run loop when kQuitMessage is received.
100 bool quit_only_on_message_;
103 class IPCChannelPosixTest : public base::MultiProcessTest {
104 public:
105 static void SetUpSocket(IPC::ChannelHandle *handle,
106 IPC::Channel::Mode mode);
107 static void SpinRunLoop(base::TimeDelta delay);
108 static const std::string GetConnectionSocketName();
109 static const std::string GetChannelDirName();
111 protected:
112 virtual void SetUp();
113 virtual void TearDown();
115 private:
116 scoped_ptr<base::MessageLoopForIO> message_loop_;
119 const std::string IPCChannelPosixTest::GetChannelDirName() {
120 #if defined(OS_ANDROID)
121 base::FilePath tmp_dir;
122 PathService::Get(base::DIR_CACHE, &tmp_dir);
123 return tmp_dir.value();
124 #else
125 return "/var/tmp";
126 #endif
129 const std::string IPCChannelPosixTest::GetConnectionSocketName() {
130 return GetChannelDirName() + "/chrome_IPCChannelPosixTest__ConnectionSocket";
133 void IPCChannelPosixTest::SetUp() {
134 MultiProcessTest::SetUp();
135 // Construct a fresh IO Message loop for the duration of each test.
136 message_loop_.reset(new base::MessageLoopForIO());
139 void IPCChannelPosixTest::TearDown() {
140 message_loop_.reset(NULL);
141 MultiProcessTest::TearDown();
144 // Create up a socket and bind and listen to it, or connect it
145 // depending on the |mode|.
146 void IPCChannelPosixTest::SetUpSocket(IPC::ChannelHandle *handle,
147 IPC::Channel::Mode mode) {
148 const std::string& name = handle->name;
150 int socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
151 ASSERT_GE(socket_fd, 0) << name;
152 ASSERT_GE(fcntl(socket_fd, F_SETFL, O_NONBLOCK), 0);
153 struct sockaddr_un server_address = { 0 };
154 memset(&server_address, 0, sizeof(server_address));
155 server_address.sun_family = AF_UNIX;
156 int path_len = snprintf(server_address.sun_path, IPC::kMaxSocketNameLength,
157 "%s", name.c_str());
158 DCHECK_EQ(static_cast<int>(name.length()), path_len);
159 size_t server_address_len = offsetof(struct sockaddr_un,
160 sun_path) + path_len + 1;
162 if (mode == IPC::Channel::MODE_NAMED_SERVER) {
163 // Only one server at a time. Cleanup garbage if it exists.
164 unlink(name.c_str());
165 // Make sure the path we need exists.
166 base::FilePath path(name);
167 base::FilePath dir_path = path.DirName();
168 ASSERT_TRUE(base::CreateDirectory(dir_path));
169 ASSERT_GE(bind(socket_fd,
170 reinterpret_cast<struct sockaddr *>(&server_address),
171 server_address_len), 0) << server_address.sun_path
172 << ": " << strerror(errno)
173 << "(" << errno << ")";
174 ASSERT_GE(listen(socket_fd, SOMAXCONN), 0) << server_address.sun_path
175 << ": " << strerror(errno)
176 << "(" << errno << ")";
177 } else if (mode == IPC::Channel::MODE_NAMED_CLIENT) {
178 ASSERT_GE(connect(socket_fd,
179 reinterpret_cast<struct sockaddr *>(&server_address),
180 server_address_len), 0) << server_address.sun_path
181 << ": " << strerror(errno)
182 << "(" << errno << ")";
183 } else {
184 FAIL() << "Unknown mode " << mode;
186 handle->socket.fd = socket_fd;
189 void IPCChannelPosixTest::SpinRunLoop(base::TimeDelta delay) {
190 base::MessageLoopForIO* loop = base::MessageLoopForIO::current();
191 // Post a quit task so that this loop eventually ends and we don't hang
192 // in the case of a bad test. Usually, the run loop will quit sooner than
193 // that because all tests use a IPCChannelPosixTestListener which quits the
194 // current run loop on any channel activity.
195 loop->PostDelayedTask(FROM_HERE, loop->QuitClosure(), delay);
196 loop->Run();
199 TEST_F(IPCChannelPosixTest, BasicListen) {
200 const std::string kChannelName =
201 GetChannelDirName() + "/IPCChannelPosixTest_BasicListen";
203 // Test creating a socket that is listening.
204 IPC::ChannelHandle handle(kChannelName);
205 SetUpSocket(&handle, IPC::Channel::MODE_NAMED_SERVER);
206 unlink(handle.name.c_str());
207 scoped_ptr<IPC::ChannelPosix> channel(
208 new IPC::ChannelPosix(handle, IPC::Channel::MODE_NAMED_SERVER, NULL));
209 ASSERT_TRUE(channel->Connect());
210 ASSERT_TRUE(channel->AcceptsConnections());
211 ASSERT_FALSE(channel->HasAcceptedConnection());
212 channel->ResetToAcceptingConnectionState();
213 ASSERT_FALSE(channel->HasAcceptedConnection());
216 TEST_F(IPCChannelPosixTest, BasicConnected) {
217 // Test creating a socket that is connected.
218 int pipe_fds[2];
219 ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds));
220 std::string socket_name("/var/tmp/IPCChannelPosixTest_BasicConnected");
221 ASSERT_GE(fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK), 0);
223 base::FileDescriptor fd(pipe_fds[0], false);
224 IPC::ChannelHandle handle(socket_name, fd);
225 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
226 handle, IPC::Channel::MODE_SERVER, NULL));
227 ASSERT_TRUE(channel->Connect());
228 ASSERT_FALSE(channel->AcceptsConnections());
229 channel->Close();
230 ASSERT_TRUE(IGNORE_EINTR(close(pipe_fds[1])) == 0);
232 // Make sure that we can use the socket that is created for us by
233 // a standard channel.
234 scoped_ptr<IPC::ChannelPosix> channel2(new IPC::ChannelPosix(
235 socket_name, IPC::Channel::MODE_SERVER, NULL));
236 ASSERT_TRUE(channel2->Connect());
237 ASSERT_FALSE(channel2->AcceptsConnections());
240 // If a connection closes right before a Send() call, we may end up closing
241 // the connection without notifying the listener, which can cause hangs in
242 // sync_message_filter and others. Make sure the listener is notified.
243 TEST_F(IPCChannelPosixTest, SendHangTest) {
244 IPCChannelPosixTestListener out_listener(true);
245 IPCChannelPosixTestListener in_listener(true);
246 IPC::ChannelHandle in_handle("IN");
247 scoped_ptr<IPC::ChannelPosix> in_chan(new IPC::ChannelPosix(
248 in_handle, IPC::Channel::MODE_SERVER, &in_listener));
249 IPC::ChannelHandle out_handle(
250 "OUT", base::FileDescriptor(in_chan->TakeClientFileDescriptor()));
251 scoped_ptr<IPC::ChannelPosix> out_chan(new IPC::ChannelPosix(
252 out_handle, IPC::Channel::MODE_CLIENT, &out_listener));
253 ASSERT_TRUE(in_chan->Connect());
254 ASSERT_TRUE(out_chan->Connect());
255 in_chan->Close(); // simulate remote process dying at an unfortunate time.
256 // Send will fail, because it cannot write the message.
257 ASSERT_FALSE(out_chan->Send(new IPC::Message(
258 0, // routing_id
259 kQuitMessage, // message type
260 IPC::Message::PRIORITY_NORMAL)));
261 SpinRunLoop(TestTimeouts::action_max_timeout());
262 ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, out_listener.status());
265 // If a connection closes right before a Connect() call, we may end up closing
266 // the connection without notifying the listener, which can cause hangs in
267 // sync_message_filter and others. Make sure the listener is notified.
268 TEST_F(IPCChannelPosixTest, AcceptHangTest) {
269 IPCChannelPosixTestListener out_listener(true);
270 IPCChannelPosixTestListener in_listener(true);
271 IPC::ChannelHandle in_handle("IN");
272 scoped_ptr<IPC::ChannelPosix> in_chan(new IPC::ChannelPosix(
273 in_handle, IPC::Channel::MODE_SERVER, &in_listener));
274 IPC::ChannelHandle out_handle(
275 "OUT", base::FileDescriptor(in_chan->TakeClientFileDescriptor()));
276 scoped_ptr<IPC::ChannelPosix> out_chan(new IPC::ChannelPosix(
277 out_handle, IPC::Channel::MODE_CLIENT, &out_listener));
278 ASSERT_TRUE(in_chan->Connect());
279 in_chan->Close(); // simulate remote process dying at an unfortunate time.
280 ASSERT_FALSE(out_chan->Connect());
281 SpinRunLoop(TestTimeouts::action_max_timeout());
282 ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, out_listener.status());
285 TEST_F(IPCChannelPosixTest, AdvancedConnected) {
286 // Test creating a connection to an external process.
287 IPCChannelPosixTestListener listener(false);
288 IPC::ChannelHandle chan_handle(GetConnectionSocketName());
289 SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
290 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
291 chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener));
292 ASSERT_TRUE(channel->Connect());
293 ASSERT_TRUE(channel->AcceptsConnections());
294 ASSERT_FALSE(channel->HasAcceptedConnection());
296 base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
297 ASSERT_TRUE(handle);
298 SpinRunLoop(TestTimeouts::action_max_timeout());
299 ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
300 ASSERT_TRUE(channel->HasAcceptedConnection());
301 IPC::Message* message = new IPC::Message(0, // routing_id
302 kQuitMessage, // message type
303 IPC::Message::PRIORITY_NORMAL);
304 channel->Send(message);
305 SpinRunLoop(TestTimeouts::action_timeout());
306 int exit_code = 0;
307 EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
308 EXPECT_EQ(0, exit_code);
309 ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
310 ASSERT_FALSE(channel->HasAcceptedConnection());
313 TEST_F(IPCChannelPosixTest, ResetState) {
314 // Test creating a connection to an external process. Close the connection,
315 // but continue to listen and make sure another external process can connect
316 // to us.
317 IPCChannelPosixTestListener listener(false);
318 IPC::ChannelHandle chan_handle(GetConnectionSocketName());
319 SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
320 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
321 chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener));
322 ASSERT_TRUE(channel->Connect());
323 ASSERT_TRUE(channel->AcceptsConnections());
324 ASSERT_FALSE(channel->HasAcceptedConnection());
326 base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
327 ASSERT_TRUE(handle);
328 SpinRunLoop(TestTimeouts::action_max_timeout());
329 ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
330 ASSERT_TRUE(channel->HasAcceptedConnection());
331 channel->ResetToAcceptingConnectionState();
332 ASSERT_FALSE(channel->HasAcceptedConnection());
334 base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixTestConnectionProc");
335 ASSERT_TRUE(handle2);
336 SpinRunLoop(TestTimeouts::action_max_timeout());
337 ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
338 ASSERT_TRUE(channel->HasAcceptedConnection());
339 IPC::Message* message = new IPC::Message(0, // routing_id
340 kQuitMessage, // message type
341 IPC::Message::PRIORITY_NORMAL);
342 channel->Send(message);
343 SpinRunLoop(TestTimeouts::action_timeout());
344 EXPECT_TRUE(base::KillProcess(handle, 0, false));
345 int exit_code = 0;
346 EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
347 EXPECT_EQ(0, exit_code);
348 ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
349 ASSERT_FALSE(channel->HasAcceptedConnection());
352 TEST_F(IPCChannelPosixTest, BadChannelName) {
353 // Test empty name
354 IPC::ChannelHandle handle("");
355 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
356 handle, IPC::Channel::MODE_NAMED_SERVER, NULL));
357 ASSERT_FALSE(channel->Connect());
359 // Test name that is too long.
360 const char *kTooLongName = "This_is_a_very_long_name_to_proactively_implement"
361 "client-centered_synergy_through_top-line"
362 "platforms_Phosfluorescently_disintermediate_"
363 "clicks-and-mortar_best_practices_without_"
364 "future-proof_growth_strategies_Continually"
365 "pontificate_proactive_potentialities_before"
366 "leading-edge_processes";
367 EXPECT_GE(strlen(kTooLongName), IPC::kMaxSocketNameLength);
368 IPC::ChannelHandle handle2(kTooLongName);
369 scoped_ptr<IPC::ChannelPosix> channel2(new IPC::ChannelPosix(
370 handle2, IPC::Channel::MODE_NAMED_SERVER, NULL));
371 EXPECT_FALSE(channel2->Connect());
374 TEST_F(IPCChannelPosixTest, MultiConnection) {
375 // Test setting up a connection to an external process, and then have
376 // another external process attempt to connect to us.
377 IPCChannelPosixTestListener listener(false);
378 IPC::ChannelHandle chan_handle(GetConnectionSocketName());
379 SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
380 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
381 chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener));
382 ASSERT_TRUE(channel->Connect());
383 ASSERT_TRUE(channel->AcceptsConnections());
384 ASSERT_FALSE(channel->HasAcceptedConnection());
386 base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
387 ASSERT_TRUE(handle);
388 SpinRunLoop(TestTimeouts::action_max_timeout());
389 ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
390 ASSERT_TRUE(channel->HasAcceptedConnection());
391 base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixFailConnectionProc");
392 ASSERT_TRUE(handle2);
393 SpinRunLoop(TestTimeouts::action_max_timeout());
394 int exit_code = 0;
395 EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
396 EXPECT_EQ(exit_code, 0);
397 ASSERT_EQ(IPCChannelPosixTestListener::DENIED, listener.status());
398 ASSERT_TRUE(channel->HasAcceptedConnection());
399 IPC::Message* message = new IPC::Message(0, // routing_id
400 kQuitMessage, // message type
401 IPC::Message::PRIORITY_NORMAL);
402 channel->Send(message);
403 SpinRunLoop(TestTimeouts::action_timeout());
404 EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
405 EXPECT_EQ(exit_code, 0);
406 ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
407 ASSERT_FALSE(channel->HasAcceptedConnection());
410 TEST_F(IPCChannelPosixTest, DoubleServer) {
411 // Test setting up two servers with the same name.
412 IPCChannelPosixTestListener listener(false);
413 IPCChannelPosixTestListener listener2(false);
414 IPC::ChannelHandle chan_handle(GetConnectionSocketName());
415 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
416 chan_handle, IPC::Channel::MODE_SERVER, &listener));
417 scoped_ptr<IPC::ChannelPosix> channel2(new IPC::ChannelPosix(
418 chan_handle, IPC::Channel::MODE_SERVER, &listener2));
419 ASSERT_TRUE(channel->Connect());
420 ASSERT_FALSE(channel2->Connect());
423 TEST_F(IPCChannelPosixTest, BadMode) {
424 // Test setting up two servers with a bad mode.
425 IPCChannelPosixTestListener listener(false);
426 IPC::ChannelHandle chan_handle(GetConnectionSocketName());
427 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
428 chan_handle, IPC::Channel::MODE_NONE, &listener));
429 ASSERT_FALSE(channel->Connect());
432 TEST_F(IPCChannelPosixTest, IsNamedServerInitialized) {
433 const std::string& connection_socket_name = GetConnectionSocketName();
434 IPCChannelPosixTestListener listener(false);
435 IPC::ChannelHandle chan_handle(connection_socket_name);
436 ASSERT_TRUE(base::DeleteFile(base::FilePath(connection_socket_name), false));
437 ASSERT_FALSE(IPC::Channel::IsNamedServerInitialized(
438 connection_socket_name));
439 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
440 chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener));
441 ASSERT_TRUE(IPC::Channel::IsNamedServerInitialized(
442 connection_socket_name));
443 channel->Close();
444 ASSERT_FALSE(IPC::Channel::IsNamedServerInitialized(
445 connection_socket_name));
448 // A long running process that connects to us
449 MULTIPROCESS_TEST_MAIN(IPCChannelPosixTestConnectionProc) {
450 base::MessageLoopForIO message_loop;
451 IPCChannelPosixTestListener listener(true);
452 IPC::ChannelHandle handle(IPCChannelPosixTest::GetConnectionSocketName());
453 IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
454 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
455 handle, IPC::Channel::MODE_NAMED_CLIENT, &listener));
456 EXPECT_TRUE(channel->Connect());
457 IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout());
458 EXPECT_EQ(IPCChannelPosixTestListener::MESSAGE_RECEIVED, listener.status());
459 return 0;
462 // Simple external process that shouldn't be able to connect to us.
463 MULTIPROCESS_TEST_MAIN(IPCChannelPosixFailConnectionProc) {
464 base::MessageLoopForIO message_loop;
465 IPCChannelPosixTestListener listener(false);
466 IPC::ChannelHandle handle(IPCChannelPosixTest::GetConnectionSocketName());
467 IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
468 scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
469 handle, IPC::Channel::MODE_NAMED_CLIENT, &listener));
471 // In this case connect may succeed or fail depending on if the packet
472 // actually gets sent at sendmsg. Since we never delay on send, we may not
473 // see the error. However even if connect succeeds, eventually we will get an
474 // error back since the channel will be closed when we attempt to read from
475 // it.
476 bool connected = channel->Connect();
477 if (connected) {
478 IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout());
479 EXPECT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
480 } else {
481 EXPECT_EQ(IPCChannelPosixTestListener::DISCONNECTED, listener.status());
483 return 0;
486 } // namespace