Home | History | Annotate | Download | only in browser 
      1 // Copyright 2014 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 // On Linux, when the user tries to launch a second copy of chrome, we check
      6 // for a socket in the user's profile directory.  If the socket file is open we
      7 // send a message to the first chrome browser process with the current
      8 // directory and second process command line flags.  The second process then
      9 // exits.
     10 //
     11 // Because many networked filesystem implementations do not support unix domain
     12 // sockets, we create the socket in a temporary directory and create a symlink
     13 // in the profile. This temporary directory is no longer bound to the profile,
     14 // and may disappear across a reboot or login to a separate session. To bind
     15 // them, we store a unique cookie in the profile directory, which must also be
     16 // present in the remote directory to connect. The cookie is checked both before
     17 // and after the connection. /tmp is sticky, and different Chrome sessions use
     18 // different cookies. Thus, a matching cookie before and after means the
     19 // connection was to a directory with a valid cookie.
     20 //
     21 // We also have a lock file, which is a symlink to a non-existent destination.
     22 // The destination is a string containing the hostname and process id of
     23 // chrome's browser process, eg. "SingletonLock -> example.com-9156".  When the
     24 // first copy of chrome exits it will delete the lock file on shutdown, so that
     25 // a different instance on a different host may then use the profile directory.
     26 //
     27 // If writing to the socket fails, the hostname in the lock is checked to see if
     28 // another instance is running a different host using a shared filesystem (nfs,
     29 // etc.) If the hostname differs an error is displayed and the second process
     30 // exits.  Otherwise the first process (if any) is killed and the second process
     31 // starts as normal.
     32 //
     33 // When the second process sends the current directory and command line flags to
     34 // the first process, it waits for an ACK message back from the first process
     35 // for a certain time. If there is no ACK message back in time, then the first
     36 // process will be considered as hung for some reason. The second process then
     37 // retrieves the process id from the symbol link and kills it by sending
     38 // SIGKILL. Then the second process starts as normal.
     39 
     40 #include "chrome/browser/process_singleton.h"
     41 
     42 #include <errno.h>
     43 #include <fcntl.h>
     44 #include <signal.h>
     45 #include <sys/socket.h>
     46 #include <sys/stat.h>
     47 #include <sys/types.h>
     48 #include <sys/un.h>
     49 #include <unistd.h>
     50 
     51 #include <cstring>
     52 #include <set>
     53 #include <string>
     54 
     55 #include "base/base_paths.h"
     56 #include "base/basictypes.h"
     57 #include "base/bind.h"
     58 #include "base/command_line.h"
     59 #include "base/files/file_path.h"
     60 #include "base/files/file_util.h"
     61 #include "base/logging.h"
     62 #include "base/message_loop/message_loop.h"
     63 #include "base/path_service.h"
     64 #include "base/posix/eintr_wrapper.h"
     65 #include "base/rand_util.h"
     66 #include "base/safe_strerror_posix.h"
     67 #include "base/sequenced_task_runner_helpers.h"
     68 #include "base/stl_util.h"
     69 #include "base/strings/string_number_conversions.h"
     70 #include "base/strings/string_split.h"
     71 #include "base/strings/string_util.h"
     72 #include "base/strings/stringprintf.h"
     73 #include "base/strings/sys_string_conversions.h"
     74 #include "base/strings/utf_string_conversions.h"
     75 #include "base/threading/platform_thread.h"
     76 #include "base/time/time.h"
     77 #include "base/timer/timer.h"
     78 #include "chrome/common/chrome_constants.h"
     79 #include "chrome/grit/chromium_strings.h"
     80 #include "chrome/grit/generated_resources.h"
     81 #include "content/public/browser/browser_thread.h"
     82 #include "net/base/net_util.h"
     83 #include "ui/base/l10n/l10n_util.h"
     84 
     85 #if defined(OS_LINUX)
     86 #include "chrome/browser/ui/process_singleton_dialog_linux.h"
     87 #endif
     88 
     89 #if defined(TOOLKIT_VIEWS) && defined(OS_LINUX) && !defined(OS_CHROMEOS)
     90 #include "ui/views/linux_ui/linux_ui.h"
     91 #endif
     92 
     93 using content::BrowserThread;
     94 
     95 namespace {
     96 
     97 // Timeout for the current browser process to respond. 20 seconds should be
     98 // enough.
     99 const int kTimeoutInSeconds = 20;
    100 // Number of retries to notify the browser. 20 retries over 20 seconds = 1 try
    101 // per second.
    102 const int kRetryAttempts = 20;
    103 static bool g_disable_prompt;
    104 const char kStartToken[] = "START";
    105 const char kACKToken[] = "ACK";
    106 const char kShutdownToken[] = "SHUTDOWN";
    107 const char kTokenDelimiter = '\0';
    108 const int kMaxMessageLength = 32 * 1024;
    109 const int kMaxACKMessageLength = arraysize(kShutdownToken) - 1;
    110 
    111 const char kLockDelimiter = '-';
    112 
    113 // Set a file descriptor to be non-blocking.
    114 // Return 0 on success, -1 on failure.
    115 int SetNonBlocking(int fd) {
    116   int flags = fcntl(fd, F_GETFL, 0);
    117   if (-1 == flags)
    118     return flags;
    119   if (flags & O_NONBLOCK)
    120     return 0;
    121   return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
    122 }
    123 
    124 // Set the close-on-exec bit on a file descriptor.
    125 // Returns 0 on success, -1 on failure.
    126 int SetCloseOnExec(int fd) {
    127   int flags = fcntl(fd, F_GETFD, 0);
    128   if (-1 == flags)
    129     return flags;
    130   if (flags & FD_CLOEXEC)
    131     return 0;
    132   return fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
    133 }
    134 
    135 // Close a socket and check return value.
    136 void CloseSocket(int fd) {
    137   int rv = IGNORE_EINTR(close(fd));
    138   DCHECK_EQ(0, rv) << "Error closing socket: " << safe_strerror(errno);
    139 }
    140 
    141 // Write a message to a socket fd.
    142 bool WriteToSocket(int fd, const char *message, size_t length) {
    143   DCHECK(message);
    144   DCHECK(length);
    145   size_t bytes_written = 0;
    146   do {
    147     ssize_t rv = HANDLE_EINTR(
    148         write(fd, message + bytes_written, length - bytes_written));
    149     if (rv < 0) {
    150       if (errno == EAGAIN || errno == EWOULDBLOCK) {
    151         // The socket shouldn't block, we're sending so little data.  Just give
    152         // up here, since NotifyOtherProcess() doesn't have an asynchronous api.
    153         LOG(ERROR) << "ProcessSingleton would block on write(), so it gave up.";
    154         return false;
    155       }
    156       PLOG(ERROR) << "write() failed";
    157       return false;
    158     }
    159     bytes_written += rv;
    160   } while (bytes_written < length);
    161 
    162   return true;
    163 }
    164 
    165 struct timeval TimeDeltaToTimeVal(const base::TimeDelta& delta) {
    166   struct timeval result;
    167   result.tv_sec = delta.InSeconds();
    168   result.tv_usec = delta.InMicroseconds() % base::Time::kMicrosecondsPerSecond;
    169   return result;
    170 }
    171 
    172 // Wait a socket for read for a certain timeout.
    173 // Returns -1 if error occurred, 0 if timeout reached, > 0 if the socket is
    174 // ready for read.
    175 int WaitSocketForRead(int fd, const base::TimeDelta& timeout) {
    176   fd_set read_fds;
    177   struct timeval tv = TimeDeltaToTimeVal(timeout);
    178 
    179   FD_ZERO(&read_fds);
    180   FD_SET(fd, &read_fds);
    181 
    182   return HANDLE_EINTR(select(fd + 1, &read_fds, NULL, NULL, &tv));
    183 }
    184 
    185 // Read a message from a socket fd, with an optional timeout.
    186 // If |timeout| <= 0 then read immediately.
    187 // Return number of bytes actually read, or -1 on error.
    188 ssize_t ReadFromSocket(int fd,
    189                        char* buf,
    190                        size_t bufsize,
    191                        const base::TimeDelta& timeout) {
    192   if (timeout > base::TimeDelta()) {
    193     int rv = WaitSocketForRead(fd, timeout);
    194     if (rv <= 0)
    195       return rv;
    196   }
    197 
    198   size_t bytes_read = 0;
    199   do {
    200     ssize_t rv = HANDLE_EINTR(read(fd, buf + bytes_read, bufsize - bytes_read));
    201     if (rv < 0) {
    202       if (errno != EAGAIN && errno != EWOULDBLOCK) {
    203         PLOG(ERROR) << "read() failed";
    204         return rv;
    205       } else {
    206         // It would block, so we just return what has been read.
    207         return bytes_read;
    208       }
    209     } else if (!rv) {
    210       // No more data to read.
    211       return bytes_read;
    212     } else {
    213       bytes_read += rv;
    214     }
    215   } while (bytes_read < bufsize);
    216 
    217   return bytes_read;
    218 }
    219 
    220 // Set up a sockaddr appropriate for messaging.
    221 void SetupSockAddr(const std::string& path, struct sockaddr_un* addr) {
    222   addr->sun_family = AF_UNIX;
    223   CHECK(path.length() < arraysize(addr->sun_path))
    224       << "Socket path too long: " << path;
    225   base::strlcpy(addr->sun_path, path.c_str(), arraysize(addr->sun_path));
    226 }
    227 
    228 // Set up a socket appropriate for messaging.
    229 int SetupSocketOnly() {
    230   int sock = socket(PF_UNIX, SOCK_STREAM, 0);
    231   PCHECK(sock >= 0) << "socket() failed";
    232 
    233   int rv = SetNonBlocking(sock);
    234   DCHECK_EQ(0, rv) << "Failed to make non-blocking socket.";
    235   rv = SetCloseOnExec(sock);
    236   DCHECK_EQ(0, rv) << "Failed to set CLOEXEC on socket.";
    237 
    238   return sock;
    239 }
    240 
    241 // Set up a socket and sockaddr appropriate for messaging.
    242 void SetupSocket(const std::string& path, int* sock, struct sockaddr_un* addr) {
    243   *sock = SetupSocketOnly();
    244   SetupSockAddr(path, addr);
    245 }
    246 
    247 // Read a symbolic link, return empty string if given path is not a symbol link.
    248 base::FilePath ReadLink(const base::FilePath& path) {
    249   base::FilePath target;
    250   if (!base::ReadSymbolicLink(path, &target)) {
    251     // The only errno that should occur is ENOENT.
    252     if (errno != 0 && errno != ENOENT)
    253       PLOG(ERROR) << "readlink(" << path.value() << ") failed";
    254   }
    255   return target;
    256 }
    257 
    258 // Unlink a path. Return true on success.
    259 bool UnlinkPath(const base::FilePath& path) {
    260   int rv = unlink(path.value().c_str());
    261   if (rv < 0 && errno != ENOENT)
    262     PLOG(ERROR) << "Failed to unlink " << path.value();
    263 
    264   return rv == 0;
    265 }
    266 
    267 // Create a symlink. Returns true on success.
    268 bool SymlinkPath(const base::FilePath& target, const base::FilePath& path) {
    269   if (!base::CreateSymbolicLink(target, path)) {
    270     // Double check the value in case symlink suceeded but we got an incorrect
    271     // failure due to NFS packet loss & retry.
    272     int saved_errno = errno;
    273     if (ReadLink(path) != target) {
    274       // If we failed to create the lock, most likely another instance won the
    275       // startup race.
    276       errno = saved_errno;
    277       PLOG(ERROR) << "Failed to create " << path.value();
    278       return false;
    279     }
    280   }
    281   return true;
    282 }
    283 
    284 // Extract the hostname and pid from the lock symlink.
    285 // Returns true if the lock existed.
    286 bool ParseLockPath(const base::FilePath& path,
    287                    std::string* hostname,
    288                    int* pid) {
    289   std::string real_path = ReadLink(path).value();
    290   if (real_path.empty())
    291     return false;
    292 
    293   std::string::size_type pos = real_path.rfind(kLockDelimiter);
    294 
    295   // If the path is not a symbolic link, or doesn't contain what we expect,
    296   // bail.
    297   if (pos == std::string::npos) {
    298     *hostname = "";
    299     *pid = -1;
    300     return true;
    301   }
    302 
    303   *hostname = real_path.substr(0, pos);
    304 
    305   const std::string& pid_str = real_path.substr(pos + 1);
    306   if (!base::StringToInt(pid_str, pid))
    307     *pid = -1;
    308 
    309   return true;
    310 }
    311 
    312 // Returns true if the user opted to unlock the profile.
    313 bool DisplayProfileInUseError(const base::FilePath& lock_path,
    314                               const std::string& hostname,
    315                               int pid) {
    316   base::string16 error = l10n_util::GetStringFUTF16(
    317       IDS_PROFILE_IN_USE_POSIX,
    318       base::IntToString16(pid),
    319       base::ASCIIToUTF16(hostname));
    320   LOG(ERROR) << error;
    321 
    322   if (g_disable_prompt)
    323     return false;
    324 
    325 #if defined(OS_LINUX)
    326   base::string16 relaunch_button_text = l10n_util::GetStringUTF16(
    327       IDS_PROFILE_IN_USE_LINUX_RELAUNCH);
    328   return ShowProcessSingletonDialog(error, relaunch_button_text);
    329 #elif defined(OS_MACOSX)
    330   // On Mac, always usurp the lock.
    331   return true;
    332 #endif
    333 
    334   NOTREACHED();
    335   return false;
    336 }
    337 
    338 bool IsChromeProcess(pid_t pid) {
    339   base::FilePath other_chrome_path(base::GetProcessExecutablePath(pid));
    340   return (!other_chrome_path.empty() &&
    341           other_chrome_path.BaseName() ==
    342           base::FilePath(chrome::kBrowserProcessExecutableName));
    343 }
    344 
    345 // A helper class to hold onto a socket.
    346 class ScopedSocket {
    347  public:
    348   ScopedSocket() : fd_(-1) { Reset(); }
    349   ~ScopedSocket() { Close(); }
    350   int fd() { return fd_; }
    351   void Reset() {
    352     Close();
    353     fd_ = SetupSocketOnly();
    354   }
    355   void Close() {
    356     if (fd_ >= 0)
    357       CloseSocket(fd_);
    358     fd_ = -1;
    359   }
    360  private:
    361   int fd_;
    362 };
    363 
    364 // Returns a random string for uniquifying profile connections.
    365 std::string GenerateCookie() {
    366   return base::Uint64ToString(base::RandUint64());
    367 }
    368 
    369 bool CheckCookie(const base::FilePath& path, const base::FilePath& cookie) {
    370   return (cookie == ReadLink(path));
    371 }
    372 
    373 bool ConnectSocket(ScopedSocket* socket,
    374                    const base::FilePath& socket_path,
    375                    const base::FilePath& cookie_path) {
    376   base::FilePath socket_target;
    377   if (base::ReadSymbolicLink(socket_path, &socket_target)) {
    378     // It's a symlink. Read the cookie.
    379     base::FilePath cookie = ReadLink(cookie_path);
    380     if (cookie.empty())
    381       return false;
    382     base::FilePath remote_cookie = socket_target.DirName().
    383                              Append(chrome::kSingletonCookieFilename);
    384     // Verify the cookie before connecting.
    385     if (!CheckCookie(remote_cookie, cookie))
    386       return false;
    387     // Now we know the directory was (at that point) created by the profile
    388     // owner. Try to connect.
    389     sockaddr_un addr;
    390     SetupSockAddr(socket_target.value(), &addr);
    391     int ret = HANDLE_EINTR(connect(socket->fd(),
    392                                    reinterpret_cast<sockaddr*>(&addr),
    393                                    sizeof(addr)));
    394     if (ret != 0)
    395       return false;
    396     // Check the cookie again. We only link in /tmp, which is sticky, so, if the
    397     // directory is still correct, it must have been correct in-between when we
    398     // connected. POSIX, sadly, lacks a connectat().
    399     if (!CheckCookie(remote_cookie, cookie)) {
    400       socket->Reset();
    401       return false;
    402     }
    403     // Success!
    404     return true;
    405   } else if (errno == EINVAL) {
    406     // It exists, but is not a symlink (or some other error we detect
    407     // later). Just connect to it directly; this is an older version of Chrome.
    408     sockaddr_un addr;
    409     SetupSockAddr(socket_path.value(), &addr);
    410     int ret = HANDLE_EINTR(connect(socket->fd(),
    411                                    reinterpret_cast<sockaddr*>(&addr),
    412                                    sizeof(addr)));
    413     return (ret == 0);
    414   } else {
    415     // File is missing, or other error.
    416     if (errno != ENOENT)
    417       PLOG(ERROR) << "readlink failed";
    418     return false;
    419   }
    420 }
    421 
    422 #if defined(OS_MACOSX)
    423 bool ReplaceOldSingletonLock(const base::FilePath& symlink_content,
    424                              const base::FilePath& lock_path) {
    425   // Try taking an flock(2) on the file. Failure means the lock is taken so we
    426   // should quit.
    427   base::ScopedFD lock_fd(HANDLE_EINTR(
    428       open(lock_path.value().c_str(), O_RDWR | O_CREAT | O_SYMLINK, 0644)));
    429   if (!lock_fd.is_valid()) {
    430     PLOG(ERROR) << "Could not open singleton lock";
    431     return false;
    432   }
    433 
    434   int rc = HANDLE_EINTR(flock(lock_fd.get(), LOCK_EX | LOCK_NB));
    435   if (rc == -1) {
    436     if (errno == EWOULDBLOCK) {
    437       LOG(ERROR) << "Singleton lock held by old process.";
    438     } else {
    439       PLOG(ERROR) << "Error locking singleton lock";
    440     }
    441     return false;
    442   }
    443 
    444   // Successfully taking the lock means we can replace it with the a new symlink
    445   // lock. We never flock() the lock file from now on. I.e. we assume that an
    446   // old version of Chrome will not run with the same user data dir after this
    447   // version has run.
    448   if (!base::DeleteFile(lock_path, false)) {
    449     PLOG(ERROR) << "Could not delete old singleton lock.";
    450     return false;
    451   }
    452 
    453   return SymlinkPath(symlink_content, lock_path);
    454 }
    455 #endif  // defined(OS_MACOSX)
    456 
    457 }  // namespace
    458 
    459 ///////////////////////////////////////////////////////////////////////////////
    460 // ProcessSingleton::LinuxWatcher
    461 // A helper class for a Linux specific implementation of the process singleton.
    462 // This class sets up a listener on the singleton socket and handles parsing
    463 // messages that come in on the singleton socket.
    464 class ProcessSingleton::LinuxWatcher
    465     : public base::MessageLoopForIO::Watcher,
    466       public base::MessageLoop::DestructionObserver,
    467       public base::RefCountedThreadSafe<ProcessSingleton::LinuxWatcher,
    468                                         BrowserThread::DeleteOnIOThread> {
    469  public:
    470   // A helper class to read message from an established socket.
    471   class SocketReader : public base::MessageLoopForIO::Watcher {
    472    public:
    473     SocketReader(ProcessSingleton::LinuxWatcher* parent,
    474                  base::MessageLoop* ui_message_loop,
    475                  int fd)
    476         : parent_(parent),
    477           ui_message_loop_(ui_message_loop),
    478           fd_(fd),
    479           bytes_read_(0) {
    480       DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    481       // Wait for reads.
    482       base::MessageLoopForIO::current()->WatchFileDescriptor(
    483           fd, true, base::MessageLoopForIO::WATCH_READ, &fd_reader_, this);
    484       // If we haven't completed in a reasonable amount of time, give up.
    485       timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(kTimeoutInSeconds),
    486                    this, &SocketReader::CleanupAndDeleteSelf);
    487     }
    488 
    489     virtual ~SocketReader() {
    490       CloseSocket(fd_);
    491     }
    492 
    493     // MessageLoopForIO::Watcher impl.
    494     virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
    495     virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {
    496       // SocketReader only watches for accept (read) events.
    497       NOTREACHED();
    498     }
    499 
    500     // Finish handling the incoming message by optionally sending back an ACK
    501     // message and removing this SocketReader.
    502     void FinishWithACK(const char *message, size_t length);
    503 
    504    private:
    505     void CleanupAndDeleteSelf() {
    506       DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    507 
    508       parent_->RemoveSocketReader(this);
    509       // We're deleted beyond this point.
    510     }
    511 
    512     base::MessageLoopForIO::FileDescriptorWatcher fd_reader_;
    513 
    514     // The ProcessSingleton::LinuxWatcher that owns us.
    515     ProcessSingleton::LinuxWatcher* const parent_;
    516 
    517     // A reference to the UI message loop.
    518     base::MessageLoop* const ui_message_loop_;
    519 
    520     // The file descriptor we're reading.
    521     const int fd_;
    522 
    523     // Store the message in this buffer.
    524     char buf_[kMaxMessageLength];
    525 
    526     // Tracks the number of bytes we've read in case we're getting partial
    527     // reads.
    528     size_t bytes_read_;
    529 
    530     base::OneShotTimer<SocketReader> timer_;
    531 
    532     DISALLOW_COPY_AND_ASSIGN(SocketReader);
    533   };
    534 
    535   // We expect to only be constructed on the UI thread.
    536   explicit LinuxWatcher(ProcessSingleton* parent)
    537       : ui_message_loop_(base::MessageLoop::current()),
    538         parent_(parent) {
    539   }
    540 
    541   // Start listening for connections on the socket.  This method should be
    542   // called from the IO thread.
    543   void StartListening(int socket);
    544 
    545   // This method determines if we should use the same process and if we should,
    546   // opens a new browser tab.  This runs on the UI thread.
    547   // |reader| is for sending back ACK message.
    548   void HandleMessage(const std::string& current_dir,
    549                      const std::vector<std::string>& argv,
    550                      SocketReader* reader);
    551 
    552   // MessageLoopForIO::Watcher impl.  These run on the IO thread.
    553   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
    554   virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {
    555     // ProcessSingleton only watches for accept (read) events.
    556     NOTREACHED();
    557   }
    558 
    559   // MessageLoop::DestructionObserver
    560   virtual void WillDestroyCurrentMessageLoop() OVERRIDE {
    561     fd_watcher_.StopWatchingFileDescriptor();
    562   }
    563 
    564  private:
    565   friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
    566   friend class base::DeleteHelper<ProcessSingleton::LinuxWatcher>;
    567 
    568   virtual ~LinuxWatcher() {
    569     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    570     STLDeleteElements(&readers_);
    571 
    572     base::MessageLoopForIO* ml = base::MessageLoopForIO::current();
    573     ml->RemoveDestructionObserver(this);
    574   }
    575 
    576   // Removes and deletes the SocketReader.
    577   void RemoveSocketReader(SocketReader* reader);
    578 
    579   base::MessageLoopForIO::FileDescriptorWatcher fd_watcher_;
    580 
    581   // A reference to the UI message loop (i.e., the message loop we were
    582   // constructed on).
    583   base::MessageLoop* ui_message_loop_;
    584 
    585   // The ProcessSingleton that owns us.
    586   ProcessSingleton* const parent_;
    587 
    588   std::set<SocketReader*> readers_;
    589 
    590   DISALLOW_COPY_AND_ASSIGN(LinuxWatcher);
    591 };
    592 
    593 void ProcessSingleton::LinuxWatcher::OnFileCanReadWithoutBlocking(int fd) {
    594   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    595   // Accepting incoming client.
    596   sockaddr_un from;
    597   socklen_t from_len = sizeof(from);
    598   int connection_socket = HANDLE_EINTR(accept(
    599       fd, reinterpret_cast<sockaddr*>(&from), &from_len));
    600   if (-1 == connection_socket) {
    601     PLOG(ERROR) << "accept() failed";
    602     return;
    603   }
    604   int rv = SetNonBlocking(connection_socket);
    605   DCHECK_EQ(0, rv) << "Failed to make non-blocking socket.";
    606   SocketReader* reader = new SocketReader(this,
    607                                           ui_message_loop_,
    608                                           connection_socket);
    609   readers_.insert(reader);
    610 }
    611 
    612 void ProcessSingleton::LinuxWatcher::StartListening(int socket) {
    613   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    614   // Watch for client connections on this socket.
    615   base::MessageLoopForIO* ml = base::MessageLoopForIO::current();
    616   ml->AddDestructionObserver(this);
    617   ml->WatchFileDescriptor(socket, true, base::MessageLoopForIO::WATCH_READ,
    618                           &fd_watcher_, this);
    619 }
    620 
    621 void ProcessSingleton::LinuxWatcher::HandleMessage(
    622     const std::string& current_dir, const std::vector<std::string>& argv,
    623     SocketReader* reader) {
    624   DCHECK(ui_message_loop_ == base::MessageLoop::current());
    625   DCHECK(reader);
    626 
    627   if (parent_->notification_callback_.Run(CommandLine(argv),
    628                                           base::FilePath(current_dir))) {
    629     // Send back "ACK" message to prevent the client process from starting up.
    630     reader->FinishWithACK(kACKToken, arraysize(kACKToken) - 1);
    631   } else {
    632     LOG(WARNING) << "Not handling interprocess notification as browser"
    633                     " is shutting down";
    634     // Send back "SHUTDOWN" message, so that the client process can start up
    635     // without killing this process.
    636     reader->FinishWithACK(kShutdownToken, arraysize(kShutdownToken) - 1);
    637     return;
    638   }
    639 }
    640 
    641 void ProcessSingleton::LinuxWatcher::RemoveSocketReader(SocketReader* reader) {
    642   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    643   DCHECK(reader);
    644   readers_.erase(reader);
    645   delete reader;
    646 }
    647 
    648 ///////////////////////////////////////////////////////////////////////////////
    649 // ProcessSingleton::LinuxWatcher::SocketReader
    650 //
    651 
    652 void ProcessSingleton::LinuxWatcher::SocketReader::OnFileCanReadWithoutBlocking(
    653     int fd) {
    654   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    655   DCHECK_EQ(fd, fd_);
    656   while (bytes_read_ < sizeof(buf_)) {
    657     ssize_t rv = HANDLE_EINTR(
    658         read(fd, buf_ + bytes_read_, sizeof(buf_) - bytes_read_));
    659     if (rv < 0) {
    660       if (errno != EAGAIN && errno != EWOULDBLOCK) {
    661         PLOG(ERROR) << "read() failed";
    662         CloseSocket(fd);
    663         return;
    664       } else {
    665         // It would block, so we just return and continue to watch for the next
    666         // opportunity to read.
    667         return;
    668       }
    669     } else if (!rv) {
    670       // No more data to read.  It's time to process the message.
    671       break;
    672     } else {
    673       bytes_read_ += rv;
    674     }
    675   }
    676 
    677   // Validate the message.  The shortest message is kStartToken\0x\0x
    678   const size_t kMinMessageLength = arraysize(kStartToken) + 4;
    679   if (bytes_read_ < kMinMessageLength) {
    680     buf_[bytes_read_] = 0;
    681     LOG(ERROR) << "Invalid socket message (wrong length):" << buf_;
    682     CleanupAndDeleteSelf();
    683     return;
    684   }
    685 
    686   std::string str(buf_, bytes_read_);
    687   std::vector<std::string> tokens;
    688   base::SplitString(str, kTokenDelimiter, &tokens);
    689 
    690   if (tokens.size() < 3 || tokens[0] != kStartToken) {
    691     LOG(ERROR) << "Wrong message format: " << str;
    692     CleanupAndDeleteSelf();
    693     return;
    694   }
    695 
    696   // Stop the expiration timer to prevent this SocketReader object from being
    697   // terminated unexpectly.
    698   timer_.Stop();
    699 
    700   std::string current_dir = tokens[1];
    701   // Remove the first two tokens.  The remaining tokens should be the command
    702   // line argv array.
    703   tokens.erase(tokens.begin());
    704   tokens.erase(tokens.begin());
    705 
    706   // Return to the UI thread to handle opening a new browser tab.
    707   ui_message_loop_->PostTask(FROM_HERE, base::Bind(
    708       &ProcessSingleton::LinuxWatcher::HandleMessage,
    709       parent_,
    710       current_dir,
    711       tokens,
    712       this));
    713   fd_reader_.StopWatchingFileDescriptor();
    714 
    715   // LinuxWatcher::HandleMessage() is in charge of destroying this SocketReader
    716   // object by invoking SocketReader::FinishWithACK().
    717 }
    718 
    719 void ProcessSingleton::LinuxWatcher::SocketReader::FinishWithACK(
    720     const char *message, size_t length) {
    721   if (message && length) {
    722     // Not necessary to care about the return value.
    723     WriteToSocket(fd_, message, length);
    724   }
    725 
    726   if (shutdown(fd_, SHUT_WR) < 0)
    727     PLOG(ERROR) << "shutdown() failed";
    728 
    729   BrowserThread::PostTask(
    730       BrowserThread::IO,
    731       FROM_HERE,
    732       base::Bind(&ProcessSingleton::LinuxWatcher::RemoveSocketReader,
    733                  parent_,
    734                  this));
    735   // We will be deleted once the posted RemoveSocketReader task runs.
    736 }
    737 
    738 ///////////////////////////////////////////////////////////////////////////////
    739 // ProcessSingleton
    740 //
    741 ProcessSingleton::ProcessSingleton(
    742     const base::FilePath& user_data_dir,
    743     const NotificationCallback& notification_callback)
    744     : notification_callback_(notification_callback),
    745       current_pid_(base::GetCurrentProcId()),
    746       watcher_(new LinuxWatcher(this)) {
    747   socket_path_ = user_data_dir.Append(chrome::kSingletonSocketFilename);
    748   lock_path_ = user_data_dir.Append(chrome::kSingletonLockFilename);
    749   cookie_path_ = user_data_dir.Append(chrome::kSingletonCookieFilename);
    750 
    751   kill_callback_ = base::Bind(&ProcessSingleton::KillProcess,
    752                               base::Unretained(this));
    753 }
    754 
    755 ProcessSingleton::~ProcessSingleton() {
    756 }
    757 
    758 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
    759   return NotifyOtherProcessWithTimeout(
    760       *CommandLine::ForCurrentProcess(),
    761       kRetryAttempts,
    762       base::TimeDelta::FromSeconds(kTimeoutInSeconds),
    763       true);
    764 }
    765 
    766 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout(
    767     const CommandLine& cmd_line,
    768     int retry_attempts,
    769     const base::TimeDelta& timeout,
    770     bool kill_unresponsive) {
    771   DCHECK_GE(retry_attempts, 0);
    772   DCHECK_GE(timeout.InMicroseconds(), 0);
    773 
    774   base::TimeDelta sleep_interval = timeout / retry_attempts;
    775 
    776   ScopedSocket socket;
    777   for (int retries = 0; retries <= retry_attempts; ++retries) {
    778     // Try to connect to the socket.
    779     if (ConnectSocket(&socket, socket_path_, cookie_path_))
    780       break;
    781 
    782     // If we're in a race with another process, they may be in Create() and have
    783     // created the lock but not attached to the socket.  So we check if the
    784     // process with the pid from the lockfile is currently running and is a
    785     // chrome browser.  If so, we loop and try again for |timeout|.
    786 
    787     std::string hostname;
    788     int pid;
    789     if (!ParseLockPath(lock_path_, &hostname, &pid)) {
    790       // No lockfile exists.
    791       return PROCESS_NONE;
    792     }
    793 
    794     if (hostname.empty()) {
    795       // Invalid lockfile.
    796       UnlinkPath(lock_path_);
    797       return PROCESS_NONE;
    798     }
    799 
    800     if (hostname != net::GetHostName() && !IsChromeProcess(pid)) {
    801       // Locked by process on another host. If the user selected to unlock
    802       // the profile, try to continue; otherwise quit.
    803       if (DisplayProfileInUseError(lock_path_, hostname, pid)) {
    804         UnlinkPath(lock_path_);
    805         return PROCESS_NONE;
    806       }
    807       return PROFILE_IN_USE;
    808     }
    809 
    810     if (!IsChromeProcess(pid)) {
    811       // Orphaned lockfile (no process with pid, or non-chrome process.)
    812       UnlinkPath(lock_path_);
    813       return PROCESS_NONE;
    814     }
    815 
    816     if (IsSameChromeInstance(pid)) {
    817       // Orphaned lockfile (pid is part of same chrome instance we are, even
    818       // though we haven't tried to create a lockfile yet).
    819       UnlinkPath(lock_path_);
    820       return PROCESS_NONE;
    821     }
    822 
    823     if (retries == retry_attempts) {
    824       // Retries failed.  Kill the unresponsive chrome process and continue.
    825       if (!kill_unresponsive || !KillProcessByLockPath())
    826         return PROFILE_IN_USE;
    827       return PROCESS_NONE;
    828     }
    829 
    830     base::PlatformThread::Sleep(sleep_interval);
    831   }
    832 
    833   timeval socket_timeout = TimeDeltaToTimeVal(timeout);
    834   setsockopt(socket.fd(),
    835              SOL_SOCKET,
    836              SO_SNDTIMEO,
    837              &socket_timeout,
    838              sizeof(socket_timeout));
    839 
    840   // Found another process, prepare our command line
    841   // format is "START\0<current dir>\0<argv[0]>\0...\0<argv[n]>".
    842   std::string to_send(kStartToken);
    843   to_send.push_back(kTokenDelimiter);
    844 
    845   base::FilePath current_dir;
    846   if (!PathService::Get(base::DIR_CURRENT, &current_dir))
    847     return PROCESS_NONE;
    848   to_send.append(current_dir.value());
    849 
    850   const std::vector<std::string>& argv = cmd_line.argv();
    851   for (std::vector<std::string>::const_iterator it = argv.begin();
    852       it != argv.end(); ++it) {
    853     to_send.push_back(kTokenDelimiter);
    854     to_send.append(*it);
    855   }
    856 
    857   // Send the message
    858   if (!WriteToSocket(socket.fd(), to_send.data(), to_send.length())) {
    859     // Try to kill the other process, because it might have been dead.
    860     if (!kill_unresponsive || !KillProcessByLockPath())
    861       return PROFILE_IN_USE;
    862     return PROCESS_NONE;
    863   }
    864 
    865   if (shutdown(socket.fd(), SHUT_WR) < 0)
    866     PLOG(ERROR) << "shutdown() failed";
    867 
    868   // Read ACK message from the other process. It might be blocked for a certain
    869   // timeout, to make sure the other process has enough time to return ACK.
    870   char buf[kMaxACKMessageLength + 1];
    871   ssize_t len = ReadFromSocket(socket.fd(), buf, kMaxACKMessageLength, timeout);
    872 
    873   // Failed to read ACK, the other process might have been frozen.
    874   if (len <= 0) {
    875     if (!kill_unresponsive || !KillProcessByLockPath())
    876       return PROFILE_IN_USE;
    877     return PROCESS_NONE;
    878   }
    879 
    880   buf[len] = '\0';
    881   if (strncmp(buf, kShutdownToken, arraysize(kShutdownToken) - 1) == 0) {
    882     // The other process is shutting down, it's safe to start a new process.
    883     return PROCESS_NONE;
    884   } else if (strncmp(buf, kACKToken, arraysize(kACKToken) - 1) == 0) {
    885 #if defined(TOOLKIT_VIEWS) && defined(OS_LINUX) && !defined(OS_CHROMEOS)
    886     // Likely NULL in unit tests.
    887     views::LinuxUI* linux_ui = views::LinuxUI::instance();
    888     if (linux_ui)
    889       linux_ui->NotifyWindowManagerStartupComplete();
    890 #endif
    891 
    892     // Assume the other process is handling the request.
    893     return PROCESS_NOTIFIED;
    894   }
    895 
    896   NOTREACHED() << "The other process returned unknown message: " << buf;
    897   return PROCESS_NOTIFIED;
    898 }
    899 
    900 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate() {
    901   return NotifyOtherProcessWithTimeoutOrCreate(
    902       *CommandLine::ForCurrentProcess(),
    903       kRetryAttempts,
    904       base::TimeDelta::FromSeconds(kTimeoutInSeconds));
    905 }
    906 
    907 ProcessSingleton::NotifyResult
    908 ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate(
    909     const CommandLine& command_line,
    910     int retry_attempts,
    911     const base::TimeDelta& timeout) {
    912   NotifyResult result = NotifyOtherProcessWithTimeout(
    913       command_line, retry_attempts, timeout, true);
    914   if (result != PROCESS_NONE)
    915     return result;
    916   if (Create())
    917     return PROCESS_NONE;
    918   // If the Create() failed, try again to notify. (It could be that another
    919   // instance was starting at the same time and managed to grab the lock before
    920   // we did.)
    921   // This time, we don't want to kill anything if we aren't successful, since we
    922   // aren't going to try to take over the lock ourselves.
    923   result = NotifyOtherProcessWithTimeout(
    924       command_line, retry_attempts, timeout, false);
    925   if (result != PROCESS_NONE)
    926     return result;
    927 
    928   return LOCK_ERROR;
    929 }
    930 
    931 void ProcessSingleton::OverrideCurrentPidForTesting(base::ProcessId pid) {
    932   current_pid_ = pid;
    933 }
    934 
    935 void ProcessSingleton::OverrideKillCallbackForTesting(
    936     const base::Callback<void(int)>& callback) {
    937   kill_callback_ = callback;
    938 }
    939 
    940 void ProcessSingleton::DisablePromptForTesting() {
    941   g_disable_prompt = true;
    942 }
    943 
    944 bool ProcessSingleton::Create() {
    945   int sock;
    946   sockaddr_un addr;
    947 
    948   // The symlink lock is pointed to the hostname and process id, so other
    949   // processes can find it out.
    950   base::FilePath symlink_content(base::StringPrintf(
    951       "%s%c%u",
    952       net::GetHostName().c_str(),
    953       kLockDelimiter,
    954       current_pid_));
    955 
    956   // Create symbol link before binding the socket, to ensure only one instance
    957   // can have the socket open.
    958   if (!SymlinkPath(symlink_content, lock_path_)) {
    959     // TODO(jackhou): Remove this case once this code is stable on Mac.
    960     // http://crbug.com/367612
    961 #if defined(OS_MACOSX)
    962     // On Mac, an existing non-symlink lock file means the lock could be held by
    963     // the old process singleton code. If we can successfully replace the lock,
    964     // continue as normal.
    965     if (base::IsLink(lock_path_) ||
    966         !ReplaceOldSingletonLock(symlink_content, lock_path_)) {
    967       return false;
    968     }
    969 #else
    970     // If we failed to create the lock, most likely another instance won the
    971     // startup race.
    972     return false;
    973 #endif
    974   }
    975 
    976   // Create the socket file somewhere in /tmp which is usually mounted as a
    977   // normal filesystem. Some network filesystems (notably AFS) are screwy and
    978   // do not support Unix domain sockets.
    979   if (!socket_dir_.CreateUniqueTempDir()) {
    980     LOG(ERROR) << "Failed to create socket directory.";
    981     return false;
    982   }
    983 
    984   // Check that the directory was created with the correct permissions.
    985   int dir_mode = 0;
    986   CHECK(base::GetPosixFilePermissions(socket_dir_.path(), &dir_mode) &&
    987         dir_mode == base::FILE_PERMISSION_USER_MASK)
    988       << "Temp directory mode is not 700: " << std::oct << dir_mode;
    989 
    990   // Setup the socket symlink and the two cookies.
    991   base::FilePath socket_target_path =
    992       socket_dir_.path().Append(chrome::kSingletonSocketFilename);
    993   base::FilePath cookie(GenerateCookie());
    994   base::FilePath remote_cookie_path =
    995       socket_dir_.path().Append(chrome::kSingletonCookieFilename);
    996   UnlinkPath(socket_path_);
    997   UnlinkPath(cookie_path_);
    998   if (!SymlinkPath(socket_target_path, socket_path_) ||
    999       !SymlinkPath(cookie, cookie_path_) ||
   1000       !SymlinkPath(cookie, remote_cookie_path)) {
   1001     // We've already locked things, so we can't have lost the startup race,
   1002     // but something doesn't like us.
   1003     LOG(ERROR) << "Failed to create symlinks.";
   1004     if (!socket_dir_.Delete())
   1005       LOG(ERROR) << "Encountered a problem when deleting socket directory.";
   1006     return false;
   1007   }
   1008 
   1009   SetupSocket(socket_target_path.value(), &sock, &addr);
   1010 
   1011   if (bind(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
   1012     PLOG(ERROR) << "Failed to bind() " << socket_target_path.value();
   1013     CloseSocket(sock);
   1014     return false;
   1015   }
   1016 
   1017   if (listen(sock, 5) < 0)
   1018     NOTREACHED() << "listen failed: " << safe_strerror(errno);
   1019 
   1020   DCHECK(BrowserThread::IsMessageLoopValid(BrowserThread::IO));
   1021   BrowserThread::PostTask(
   1022       BrowserThread::IO,
   1023       FROM_HERE,
   1024       base::Bind(&ProcessSingleton::LinuxWatcher::StartListening,
   1025                  watcher_.get(),
   1026                  sock));
   1027 
   1028   return true;
   1029 }
   1030 
   1031 void ProcessSingleton::Cleanup() {
   1032   UnlinkPath(socket_path_);
   1033   UnlinkPath(cookie_path_);
   1034   UnlinkPath(lock_path_);
   1035 }
   1036 
   1037 bool ProcessSingleton::IsSameChromeInstance(pid_t pid) {
   1038   pid_t cur_pid = current_pid_;
   1039   while (pid != cur_pid) {
   1040     pid = base::GetParentProcessId(pid);
   1041     if (pid < 0)
   1042       return false;
   1043     if (!IsChromeProcess(pid))
   1044       return false;
   1045   }
   1046   return true;
   1047 }
   1048 
   1049 bool ProcessSingleton::KillProcessByLockPath() {
   1050   std::string hostname;
   1051   int pid;
   1052   ParseLockPath(lock_path_, &hostname, &pid);
   1053 
   1054   if (!hostname.empty() && hostname != net::GetHostName()) {
   1055     return DisplayProfileInUseError(lock_path_, hostname, pid);
   1056   }
   1057   UnlinkPath(lock_path_);
   1058 
   1059   if (IsSameChromeInstance(pid))
   1060     return true;
   1061 
   1062   if (pid > 0) {
   1063     kill_callback_.Run(pid);
   1064     return true;
   1065   }
   1066 
   1067   LOG(ERROR) << "Failed to extract pid from path: " << lock_path_.value();
   1068   return true;
   1069 }
   1070 
   1071 void ProcessSingleton::KillProcess(int pid) {
   1072   // TODO(james.su (at) gmail.com): Is SIGKILL ok?
   1073   int rv = kill(static_cast<base::ProcessHandle>(pid), SIGKILL);
   1074   // ESRCH = No Such Process (can happen if the other process is already in
   1075   // progress of shutting down and finishes before we try to kill it).
   1076   DCHECK(rv == 0 || errno == ESRCH) << "Error killing process: "
   1077                                     << safe_strerror(errno);
   1078 }
   1079