Start using file_util symlink code, now that it's available.

chrome/browser/process_singleton_linux.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // On Linux, when the user tries to launch a second copy of chrome, we check
 // for a socket in the user's profile directory.  If the socket file is open we
 // send a message to the first chrome browser process with the current
 // directory and second process command line flags.  The second process then
 // exits.
 //
@@ skipping 42 matching lines @@
 #include <cstring>
 #include <set>
 #include <string>
 
 #include "app/l10n_util.h"
 #include "base/base_paths.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/safe_strerror_posix.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
@@ skipping 149 matching lines @@
 
   return sock;
 }
 
 // Set up a socket and sockaddr appropriate for messaging.
 void SetupSocket(const std::string& path, int* sock, struct sockaddr_un* addr) {
   *sock = SetupSocketOnly();
   SetupSockAddr(path, addr);
 }
 
-// Read a symbolic link, return empty string if given path is not a
-// symbol link. This version does not interpret the errno, leaving
-// the caller to do so.
-bool ReadLinkSilent(const std::string& path, std::string* output) {
-  char buf[PATH_MAX];
-  ssize_t len = readlink(path.c_str(), buf, PATH_MAX);
-  if (len >= 0) {
-    output->assign(buf, len);
-    return true;
-  }
-  output->clear();
-  return false;
-}
-
 // Read a symbolic link, return empty string if given path is not a symbol link.
-std::string ReadLink(const std::string& path) {
-  std::string target;
-  if (!ReadLinkSilent(path, &target)) {
+FilePath ReadLink(const FilePath& path) {
+  FilePath target;
+  if (!file_util::ReadSymbolicLink(path, &target)) {
     // The only errno that should occur is ENOENT.
     if (errno != 0 && errno != ENOENT)
-      PLOG(ERROR) << "readlink(" << path << ") failed";
+      PLOG(ERROR) << "readlink(" << path.value() << ") failed";
   }
   return target;
 }
 
 // Unlink a path. Return true on success.
-bool UnlinkPath(const std::string& path) {
-  int rv = unlink(path.c_str());
+bool UnlinkPath(const FilePath& path) {
+  int rv = unlink(path.value().c_str());
   if (rv < 0 && errno != ENOENT)
-    PLOG(ERROR) << "Failed to unlink " << path;
+    PLOG(ERROR) << "Failed to unlink " << path.value();
 
   return rv == 0;
 }
 
 // Create a symlink. Returns true on success.
-bool SymlinkPath(const std::string& target, const std::string& path) {
-  if (symlink(target.c_str(), path.c_str()) < 0) {
+bool SymlinkPath(const FilePath& target, const FilePath& path) {
+  if (!file_util::CreateSymbolicLink(target, path)) {
     // Double check the value in case symlink suceeded but we got an incorrect
     // failure due to NFS packet loss & retry.
     int saved_errno = errno;
     if (ReadLink(path) != target) {
       // If we failed to create the lock, most likely another instance won the
       // startup race.
       errno = saved_errno;
-      PLOG(ERROR) << "Failed to create " << path;
+      PLOG(ERROR) << "Failed to create " << path.value();
       return false;
     }
   }
   return true;
 }
 
 // Extract the hostname and pid from the lock symlink.
 // Returns true if the lock existed.
-bool ParseLockPath(const std::string& path,
+bool ParseLockPath(const FilePath& path,
                    std::string* hostname,
                    int* pid) {
-  std::string real_path = ReadLink(path);
+  std::string real_path = ReadLink(path).value();
   if (real_path.empty())
     return false;
 
   std::string::size_type pos = real_path.rfind(kLockDelimiter);
 
   // If the path is not a symbolic link, or doesn't contain what we expect,
   // bail.
   if (pos == std::string::npos) {
     *hostname = "";
     *pid = -1;
@@ skipping 44 matching lines @@
       return false;
   }
   return true;
 }
 
 // Extract the process's pid from a symbol link path and if it is on
 // the same host, kill the process, unlink the lock file and return true.
 // If the process is part of the same chrome instance, unlink the lock file and
 // return true without killing it.
 // If the process is on a different host, return false.
-bool KillProcessByLockPath(const std::string& path) {
+bool KillProcessByLockPath(const FilePath& path) {
   std::string hostname;
   int pid;
   ParseLockPath(path, &hostname, &pid);
 
   if (!hostname.empty() && hostname != net::GetHostName()) {
-    DisplayProfileInUseError(path, hostname, pid);
+    DisplayProfileInUseError(path.value(), hostname, pid);
     return false;
   }
   UnlinkPath(path);
 
   if (IsSameChromeInstance(pid))
     return true;
 
   if (pid > 0) {
     // TODO(james.su@gmail.com): Is SIGKILL ok?
     int rv = kill(static_cast<base::ProcessHandle>(pid), SIGKILL);
     // ESRCH = No Such Process (can happen if the other process is already in
     // progress of shutting down and finishes before we try to kill it).
     DCHECK(rv == 0 || errno == ESRCH) << "Error killing process: "
                                       << safe_strerror(errno);
     return true;
   }
 
-  LOG(ERROR) << "Failed to extract pid from path: " << path;
+  LOG(ERROR) << "Failed to extract pid from path: " << path.value();
   return true;
 }
 
 // A helper class to hold onto a socket.
 class ScopedSocket {
  public:
   ScopedSocket() : fd_(-1) { Reset(); }
   ~ScopedSocket() { Close(); }
   int fd() { return fd_; }
   void Reset() {
     Close();
     fd_ = SetupSocketOnly();
   }
   void Close() {
     if (fd_ >= 0)
       CloseSocket(fd_);
     fd_ = -1;
   }
  private:
   int fd_;
 };
 
 // Returns a random string for uniquifying profile connections.
 std::string GenerateCookie() {
   return base::Uint64ToString(base::RandUint64());
 }
 
-bool CheckCookie(const FilePath& path, const std::string& cookie) {
-  return (cookie == ReadLink(path.value()));
+bool CheckCookie(const FilePath& path, const FilePath& cookie) {
+  return (cookie == ReadLink(path));
 }
 
 bool ConnectSocket(ScopedSocket* socket,
                    const FilePath& socket_path,
                    const FilePath& cookie_path) {
-  std::string socket_target;
-  if (ReadLinkSilent(socket_path.value(), &socket_target)) {
+  FilePath socket_target;
+  if (file_util::ReadSymbolicLink(socket_path, &socket_target)) {
     // It's a symlink. Read the cookie.
-    std::string cookie = ReadLink(cookie_path.value());
+    FilePath cookie = ReadLink(cookie_path);
     if (cookie.empty())
       return false;
-    FilePath remote_cookie = FilePath(socket_target).DirName().
-        Append(chrome::kSingletonCookieFilename);
+    FilePath remote_cookie = socket_target.DirName().
+                             Append(chrome::kSingletonCookieFilename);
     // Verify the cookie before connecting.
     if (!CheckCookie(remote_cookie, cookie))
       return false;
     // Now we know the directory was (at that point) created by the profile
     // owner. Try to connect.
     sockaddr_un addr;
     SetupSockAddr(socket_path.value(), &addr);
     int ret = HANDLE_EINTR(connect(socket->fd(),
                                    reinterpret_cast<sockaddr*>(&addr),
                                    sizeof(addr)));
@@ skipping 357 matching lines @@
     if (ConnectSocket(&socket, socket_path_, cookie_path_))
       break;
 
     // If we're in a race with another process, they may be in Create() and have
     // created the lock but not attached to the socket.  So we check if the
     // process with the pid from the lockfile is currently running and is a
     // chrome browser.  If so, we loop and try again for |timeout_seconds|.
 
     std::string hostname;
     int pid;
-    if (!ParseLockPath(lock_path_.value(), &hostname, &pid)) {
+    if (!ParseLockPath(lock_path_, &hostname, &pid)) {
       // No lockfile exists.
       return PROCESS_NONE;
     }
 
     if (hostname.empty()) {
       // Invalid lockfile.
-      UnlinkPath(lock_path_.value());
+      UnlinkPath(lock_path_);
       return PROCESS_NONE;
     }
 
     if (hostname != net::GetHostName()) {
       // Locked by process on another host.
       DisplayProfileInUseError(lock_path_.value(), hostname, pid);
       return PROFILE_IN_USE;
     }
 
     if (!IsChromeProcess(pid)) {
       // Orphaned lockfile (no process with pid, or non-chrome process.)
-      UnlinkPath(lock_path_.value());
+      UnlinkPath(lock_path_);
       return PROCESS_NONE;
     }
 
     if (IsSameChromeInstance(pid)) {
       // Orphaned lockfile (pid is part of same chrome instance we are, even
       // though we haven't tried to create a lockfile yet).
-      UnlinkPath(lock_path_.value());
+      UnlinkPath(lock_path_);
       return PROCESS_NONE;
     }
 
     if (retries == timeout_seconds) {
       // Retries failed.  Kill the unresponsive chrome process and continue.
-      if (!kill_unresponsive || !KillProcessByLockPath(lock_path_.value()))
+      if (!kill_unresponsive || !KillProcessByLockPath(lock_path_))
         return PROFILE_IN_USE;
       return PROCESS_NONE;
     }
 
     PlatformThread::Sleep(1000 /* ms */);
   }
 
   timeval timeout = {timeout_seconds, 0};
   setsockopt(socket.fd(), SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
 
@@ skipping 10 matching lines @@
   const std::vector<std::string>& argv = cmd_line.argv();
   for (std::vector<std::string>::const_iterator it = argv.begin();
       it != argv.end(); ++it) {
     to_send.push_back(kTokenDelimiter);
     to_send.append(*it);
   }
 
   // Send the message
   if (!WriteToSocket(socket.fd(), to_send.data(), to_send.length())) {
     // Try to kill the other process, because it might have been dead.
-    if (!kill_unresponsive || !KillProcessByLockPath(lock_path_.value()))
+    if (!kill_unresponsive || !KillProcessByLockPath(lock_path_))
       return PROFILE_IN_USE;
     return PROCESS_NONE;
   }
 
   if (shutdown(socket.fd(), SHUT_WR) < 0)
     PLOG(ERROR) << "shutdown() failed";
 
   // Read ACK message from the other process. It might be blocked for a certain
   // timeout, to make sure the other process has enough time to return ACK.
   char buf[kMaxACKMessageLength + 1];
   ssize_t len =
       ReadFromSocket(socket.fd(), buf, kMaxACKMessageLength, timeout_seconds);
 
   // Failed to read ACK, the other process might have been frozen.
   if (len <= 0) {
-    if (!kill_unresponsive || !KillProcessByLockPath(lock_path_.value()))
+    if (!kill_unresponsive || !KillProcessByLockPath(lock_path_))
       return PROFILE_IN_USE;
     return PROCESS_NONE;
   }
 
   buf[len] = '\0';
   if (strncmp(buf, kShutdownToken, arraysize(kShutdownToken) - 1) == 0) {
     // The other process is shutting down, it's safe to start a new process.
     return PROCESS_NONE;
   } else if (strncmp(buf, kACKToken, arraysize(kACKToken) - 1) == 0) {
     // Notify the window manager that we've started up; if we do not open a
@@ skipping 34 matching lines @@
 
   return LOCK_ERROR;
 }
 
 bool ProcessSingleton::Create() {
   int sock;
   sockaddr_un addr;
 
   // The symlink lock is pointed to the hostname and process id, so other
   // processes can find it out.
-  std::string symlink_content = StringPrintf(
+  FilePath symlink_content(StringPrintf(
       "%s%c%u",
       net::GetHostName().c_str(),
       kLockDelimiter,
-      base::GetCurrentProcId());
+      base::GetCurrentProcId()));
 
   // Create symbol link before binding the socket, to ensure only one instance
   // can have the socket open.
-  if (!SymlinkPath(symlink_content, lock_path_.value())) {
+  if (!SymlinkPath(symlink_content, lock_path_)) {
       // If we failed to create the lock, most likely another instance won the
       // startup race.
       return false;
   }
 
   // Create the socket file somewhere in /tmp which is usually mounted as a
   // normal filesystem. Some network filesystems (notably AFS) are screwy and
   // do not support Unix domain sockets.
   if (!socket_dir_.CreateUniqueTempDir()) {
     LOG(ERROR) << "Failed to create socket directory.";
     return false;
   }
   // Setup the socket symlink and the two cookies.
   FilePath socket_target_path =
       socket_dir_.path().Append(chrome::kSingletonSocketFilename);
-  std::string cookie = GenerateCookie();
+  FilePath cookie(GenerateCookie());
   FilePath remote_cookie_path =
       socket_dir_.path().Append(chrome::kSingletonCookieFilename);
-  UnlinkPath(socket_path_.value());
-  UnlinkPath(cookie_path_.value());
-  if (!SymlinkPath(socket_target_path.value(), socket_path_.value()) ||
-      !SymlinkPath(cookie, cookie_path_.value()) ||
-      !SymlinkPath(cookie, remote_cookie_path.value())) {
+  UnlinkPath(socket_path_);
+  UnlinkPath(cookie_path_);
+  if (!SymlinkPath(socket_target_path, socket_path_) ||
+      !SymlinkPath(cookie, cookie_path_) ||
+      !SymlinkPath(cookie, remote_cookie_path)) {
     // We've already locked things, so we can't have lost the startup race,
     // but something doesn't like us.
     LOG(ERROR) << "Failed to create symlinks.";
     socket_dir_.Delete();
     return false;
   }
 
   SetupSocket(socket_target_path.value(), &sock, &addr);
 
   if (bind(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
@@ skipping 12 matching lines @@
   DCHECK(ml);
   ml->PostTask(FROM_HERE, NewRunnableMethod(
     watcher_.get(),
     &ProcessSingleton::LinuxWatcher::StartListening,
     sock));
 
   return true;
 }
 
 void ProcessSingleton::Cleanup() {
-  UnlinkPath(socket_path_.value());
-  UnlinkPath(cookie_path_.value());
-  UnlinkPath(lock_path_.value());
+  UnlinkPath(socket_path_);
+  UnlinkPath(cookie_path_);
+  UnlinkPath(lock_path_);
 }