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.
4
5 #include "chrome/browser/process_singleton.h"
6
7 #include <sys/types.h>
8 #include <sys/wait.h>
9 #include <signal.h>
10 #include <unistd.h>
11 #include <vector>
12 #include <string>
13
14 #include "base/eintr_wrapper.h"
15 #include "base/path_service.h"
16 #include "base/string_util.h"
17 #include "base/test/test_timeouts.h"
18 #include "base/threading/thread.h"
19 #include "base/utf_string_conversions.h"
20 #include "chrome/common/chrome_constants.h"
21 #include "chrome/common/chrome_paths.h"
22 #include "chrome/common/chrome_switches.h"
23 #include "chrome/test/chrome_process_util.h"
24 #include "chrome/test/ui/ui_test.h"
25 #include "net/base/net_util.h"
26 #include "testing/gtest/include/gtest/gtest.h"
27
28 namespace {
29
30 class ProcessSingletonLinuxTest : public UITest {
31 public:
SetUp()32 virtual void SetUp() {
33 UITest::SetUp();
34 lock_path_ = user_data_dir().Append(chrome::kSingletonLockFilename);
35 socket_path_ = user_data_dir().Append(chrome::kSingletonSocketFilename);
36 cookie_path_ = user_data_dir().Append(chrome::kSingletonCookieFilename);
37 }
38
TearDown()39 virtual void TearDown() {
40 UITest::TearDown();
41
42 // Check that the test cleaned up after itself.
43 struct stat statbuf;
44 bool lock_exists = lstat(lock_path_.value().c_str(), &statbuf) == 0;
45 EXPECT_FALSE(lock_exists);
46
47 if (lock_exists) {
48 // Unlink to prevent failing future tests if the lock still exists.
49 EXPECT_EQ(unlink(lock_path_.value().c_str()), 0);
50 }
51 }
52
53 FilePath lock_path_;
54 FilePath socket_path_;
55 FilePath cookie_path_;
56 };
57
CreateProcessSingleton()58 ProcessSingleton* CreateProcessSingleton() {
59 FilePath user_data_dir;
60 PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
61
62 return new ProcessSingleton(user_data_dir);
63 }
64
CommandLineForUrl(const std::string & url)65 CommandLine CommandLineForUrl(const std::string& url) {
66 // Hack: mutate the current process's command line so we don't show a dialog.
67 // Note that this only works if we have no loose values on the command line,
68 // but that's fine for unit tests. In a UI test we disable error dialogs
69 // when spawning Chrome, but this test hits the ProcessSingleton directly.
70 CommandLine* cmd_line = CommandLine::ForCurrentProcess();
71 if (!cmd_line->HasSwitch(switches::kNoProcessSingletonDialog))
72 cmd_line->AppendSwitch(switches::kNoProcessSingletonDialog);
73
74 CommandLine new_cmd_line(*cmd_line);
75 new_cmd_line.AppendArg(url);
76 return new_cmd_line;
77 }
78
79 // A helper method to call ProcessSingleton::NotifyOtherProcess().
80 // |url| will be added to CommandLine for current process, so that it can be
81 // sent to browser process by ProcessSingleton::NotifyOtherProcess().
NotifyOtherProcess(const std::string & url,int timeout_ms)82 ProcessSingleton::NotifyResult NotifyOtherProcess(const std::string& url,
83 int timeout_ms) {
84 scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
85 return process_singleton->NotifyOtherProcessWithTimeout(
86 CommandLineForUrl(url), timeout_ms / 1000, true);
87 }
88
89 // A helper method to call ProcessSingleton::NotifyOtherProcessOrCreate().
90 // |url| will be added to CommandLine for current process, so that it can be
91 // sent to browser process by ProcessSingleton::NotifyOtherProcessOrCreate().
NotifyOtherProcessOrCreate(const std::string & url,int timeout_ms)92 ProcessSingleton::NotifyResult NotifyOtherProcessOrCreate(
93 const std::string& url,
94 int timeout_ms) {
95 scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
96 return process_singleton->NotifyOtherProcessWithTimeoutOrCreate(
97 CommandLineForUrl(url), timeout_ms / 1000);
98 }
99
100 } // namespace
101
102 // Test if the socket file and symbol link created by ProcessSingletonLinux
103 // are valid. When running this test, the ProcessSingleton object is already
104 // initiated by UITest. So we just test against this existing object.
105 // This test is flaky as per http://crbug.com/74554.
TEST_F(ProcessSingletonLinuxTest,FLAKY_CheckSocketFile)106 TEST_F(ProcessSingletonLinuxTest, FLAKY_CheckSocketFile) {
107 struct stat statbuf;
108 ASSERT_EQ(0, lstat(lock_path_.value().c_str(), &statbuf));
109 ASSERT_TRUE(S_ISLNK(statbuf.st_mode));
110 char buf[PATH_MAX];
111 ssize_t len = readlink(lock_path_.value().c_str(), buf, PATH_MAX);
112 ASSERT_GT(len, 0);
113
114 ASSERT_EQ(0, lstat(socket_path_.value().c_str(), &statbuf));
115 ASSERT_TRUE(S_ISLNK(statbuf.st_mode));
116
117 len = readlink(socket_path_.value().c_str(), buf, PATH_MAX);
118 ASSERT_GT(len, 0);
119 FilePath socket_target_path = FilePath(std::string(buf, len));
120
121 ASSERT_EQ(0, lstat(socket_target_path.value().c_str(), &statbuf));
122 ASSERT_TRUE(S_ISSOCK(statbuf.st_mode));
123
124 len = readlink(cookie_path_.value().c_str(), buf, PATH_MAX);
125 ASSERT_GT(len, 0);
126 std::string cookie(buf, len);
127
128 FilePath remote_cookie_path = socket_target_path.DirName().
129 Append(chrome::kSingletonCookieFilename);
130 len = readlink(remote_cookie_path.value().c_str(), buf, PATH_MAX);
131 ASSERT_GT(len, 0);
132 EXPECT_EQ(cookie, std::string(buf, len));
133 }
134
135 #if defined(OS_LINUX) && defined(TOOLKIT_VIEWS)
136 // The following tests in linux/view does not pass without a window manager,
137 // which is true in build/try bots.
138 // See http://crbug.com/30953.
139 #define NotifyOtherProcessSuccess FAILS_NotifyOtherProcessSuccess
140 #define NotifyOtherProcessHostChanged FAILS_NotifyOtherProcessHostChanged
141 #endif
142
143 // TODO(james.su@gmail.com): port following tests to Windows.
144 // Test success case of NotifyOtherProcess().
TEST_F(ProcessSingletonLinuxTest,NotifyOtherProcessSuccess)145 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessSuccess) {
146 std::string url("about:blank");
147 int original_tab_count = GetTabCount();
148
149 EXPECT_EQ(ProcessSingleton::PROCESS_NOTIFIED,
150 NotifyOtherProcess(url, TestTimeouts::action_timeout_ms()));
151 EXPECT_EQ(original_tab_count + 1, GetTabCount());
152 EXPECT_EQ(url, GetActiveTabURL().spec());
153 }
154
155 // Test failure case of NotifyOtherProcess().
TEST_F(ProcessSingletonLinuxTest,NotifyOtherProcessFailure)156 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessFailure) {
157 base::ProcessId pid = browser_process_id();
158
159 ASSERT_GE(pid, 1);
160
161 // Block the browser process, then it'll be killed by
162 // ProcessSingleton::NotifyOtherProcess().
163 kill(pid, SIGSTOP);
164
165 // Wait to make sure the browser process is actually stopped.
166 // It's necessary when running with valgrind.
167 EXPECT_GE(HANDLE_EINTR(waitpid(pid, 0, WUNTRACED)), 0);
168
169 std::string url("about:blank");
170 EXPECT_EQ(ProcessSingleton::PROCESS_NONE,
171 NotifyOtherProcess(url, TestTimeouts::action_timeout_ms()));
172
173 // Wait for a while to make sure the browser process is actually killed.
174 int exit_code = 0;
175 ASSERT_TRUE(launcher_->WaitForBrowserProcessToQuit(
176 TestTimeouts::action_max_timeout_ms(), &exit_code));
177 EXPECT_EQ(-1, exit_code); // Expect unclean shutdown.
178 }
179
180 // Test that we don't kill ourselves by accident if a lockfile with the same pid
181 // happens to exist.
182 // TODO(mattm): This doesn't really need to be a uitest. (We don't use the
183 // uitest created browser process, but we do use some uitest provided stuff like
184 // the user_data_dir and the NotifyOtherProcess function in this file, which
185 // would have to be duplicated or shared if this test was moved into a
186 // unittest.)
TEST_F(ProcessSingletonLinuxTest,NotifyOtherProcessNoSuicide)187 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessNoSuicide) {
188 // Replace lockfile with one containing our own pid.
189 EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
190 std::string symlink_content = StringPrintf(
191 "%s%c%u",
192 net::GetHostName().c_str(),
193 '-',
194 base::GetCurrentProcId());
195 EXPECT_EQ(0, symlink(symlink_content.c_str(), lock_path_.value().c_str()));
196
197 // Remove socket so that we will not be able to notify the existing browser.
198 EXPECT_EQ(0, unlink(socket_path_.value().c_str()));
199
200 std::string url("about:blank");
201 EXPECT_EQ(ProcessSingleton::PROCESS_NONE,
202 NotifyOtherProcess(url, TestTimeouts::action_timeout_ms()));
203 // If we've gotten to this point without killing ourself, the test succeeded.
204 }
205
206 // Test that we can still notify a process on the same host even after the
207 // hostname changed.
TEST_F(ProcessSingletonLinuxTest,NotifyOtherProcessHostChanged)208 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessHostChanged) {
209 EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
210 EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
211
212 int original_tab_count = GetTabCount();
213
214 std::string url("about:blank");
215 EXPECT_EQ(ProcessSingleton::PROCESS_NOTIFIED,
216 NotifyOtherProcess(url, TestTimeouts::action_timeout_ms()));
217 EXPECT_EQ(original_tab_count + 1, GetTabCount());
218 EXPECT_EQ(url, GetActiveTabURL().spec());
219 }
220
221 // Test that we fail when lock says process is on another host and we can't
222 // notify it over the socket.
TEST_F(ProcessSingletonLinuxTest,NotifyOtherProcessDifferingHost)223 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessDifferingHost) {
224 base::ProcessId pid = browser_process_id();
225
226 ASSERT_GE(pid, 1);
227
228 // Kill the browser process, so that it does not respond on the socket.
229 kill(pid, SIGKILL);
230 // Wait for a while to make sure the browser process is actually killed.
231 int exit_code = 0;
232 ASSERT_TRUE(launcher_->WaitForBrowserProcessToQuit(
233 TestTimeouts::action_max_timeout_ms(), &exit_code));
234 EXPECT_EQ(-1, exit_code); // Expect unclean shutdown.
235
236 EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
237 EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
238
239 std::string url("about:blank");
240 EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE,
241 NotifyOtherProcess(url, TestTimeouts::action_timeout_ms()));
242
243 ASSERT_EQ(0, unlink(lock_path_.value().c_str()));
244 }
245
246 // Test that we fail when lock says process is on another host and we can't
247 // notify it over the socket.
TEST_F(ProcessSingletonLinuxTest,NotifyOtherProcessOrCreate_DifferingHost)248 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessOrCreate_DifferingHost) {
249 base::ProcessId pid = browser_process_id();
250
251 ASSERT_GE(pid, 1);
252
253 // Kill the browser process, so that it does not respond on the socket.
254 kill(pid, SIGKILL);
255 // Wait for a while to make sure the browser process is actually killed.
256 int exit_code = 0;
257 ASSERT_TRUE(launcher_->WaitForBrowserProcessToQuit(
258 TestTimeouts::action_max_timeout_ms(), &exit_code));
259 EXPECT_EQ(-1, exit_code); // Expect unclean shutdown.
260
261 EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
262 EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
263
264 std::string url("about:blank");
265 EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE,
266 NotifyOtherProcessOrCreate(url, TestTimeouts::action_timeout_ms()));
267
268 ASSERT_EQ(0, unlink(lock_path_.value().c_str()));
269 }
270
271 // Test that Create fails when another browser is using the profile directory.
TEST_F(ProcessSingletonLinuxTest,CreateFailsWithExistingBrowser)272 TEST_F(ProcessSingletonLinuxTest, CreateFailsWithExistingBrowser) {
273 scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
274 EXPECT_FALSE(process_singleton->Create());
275 }
276
277 // Test that Create fails when another browser is using the profile directory
278 // but with the old socket location.
TEST_F(ProcessSingletonLinuxTest,CreateChecksCompatibilitySocket)279 TEST_F(ProcessSingletonLinuxTest, CreateChecksCompatibilitySocket) {
280 scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
281
282 // Do some surgery so as to look like the old configuration.
283 char buf[PATH_MAX];
284 ssize_t len = readlink(socket_path_.value().c_str(), buf, sizeof(buf));
285 ASSERT_GT(len, 0);
286 FilePath socket_target_path = FilePath(std::string(buf, len));
287 ASSERT_EQ(0, unlink(socket_path_.value().c_str()));
288 ASSERT_EQ(0, rename(socket_target_path.value().c_str(),
289 socket_path_.value().c_str()));
290 ASSERT_EQ(0, unlink(cookie_path_.value().c_str()));
291
292 EXPECT_FALSE(process_singleton->Create());
293 }
294
295 // Test that we fail when lock says process is on another host and we can't
296 // notify it over the socket before of a bad cookie.
TEST_F(ProcessSingletonLinuxTest,NotifyOtherProcessOrCreate_BadCookie)297 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessOrCreate_BadCookie) {
298 // Change the cookie.
299 EXPECT_EQ(0, unlink(cookie_path_.value().c_str()));
300 EXPECT_EQ(0, symlink("INCORRECTCOOKIE", cookie_path_.value().c_str()));
301
302 // Also change the hostname, so the remote does not retry.
303 EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
304 EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
305
306 std::string url("about:blank");
307 EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE,
308 NotifyOtherProcessOrCreate(url, TestTimeouts::action_timeout_ms()));
309 }
310