Fix to bug 75303

ipc/ipc_channel_posix.cc

 // Copyright (c) 2011 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.
 
 #include "ipc/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/un.h>
 
 #include <string>
 #include <map>
 
+#include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/global_descriptors_posix.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
+#include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "ipc/ipc_descriptors.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/file_descriptor_set_posix.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message_utils.h"
 
 namespace IPC {
@@ skipping 99 matching lines @@
 
 //------------------------------------------------------------------------------
 // Verify that kMaxPipeNameLength is a decent size.
 COMPILE_ASSERT(sizeof(((sockaddr_un*)0)->sun_path) >= kMaxPipeNameLength,
                BAD_SUN_PATH_LENGTH);
 
 // Creates a unix domain socket bound to the specified name that is listening
 // for connections.
 bool CreateServerUnixDomainSocket(const std::string& pipe_name,
                                   int* server_listen_fd) {
+  FilePath temp_dir;
+  PathService::Get(base::DIR_TEMP, &temp_dir);

[sanjeevr, 2011/06/20 21:50:34]

Document why this is needed.

+  std::string pipe_path= temp_dir.value()+ "/" + pipe_name;

[sanjeevr, 2011/06/20 21:50:34]

Use FilePath::Append instead of appending the string manually.

   DCHECK(server_listen_fd);
-  DCHECK_GT(pipe_name.length(), 0u);
-  DCHECK_LT(pipe_name.length(), kMaxPipeNameLength);
+  DCHECK_GT(pipe_path.length(), 0u);
+  DCHECK_LT(pipe_path.length(), kMaxPipeNameLength);
 
-  if (pipe_name.length() == 0 || pipe_name.length() >= kMaxPipeNameLength) {
+  if (pipe_path.length() == 0 || pipe_path.length() >= kMaxPipeNameLength) {
     return false;
   }
 
   // Create socket.
   int fd = socket(AF_UNIX, SOCK_STREAM, 0);
   if (fd < 0) {
     return false;
   }
 
   // Make socket non-blocking
   if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
-    PLOG(ERROR) << "fcntl(O_NONBLOCK) " << pipe_name;
+    PLOG(ERROR) << "fcntl(O_NONBLOCK) " << pipe_path;
     if (HANDLE_EINTR(close(fd)) < 0)
-      PLOG(ERROR) << "close " << pipe_name;
+      PLOG(ERROR) << "close " << pipe_path;
     return false;
   }
 
   // Delete any old FS instances.
-  unlink(pipe_name.c_str());
+  unlink(pipe_path.c_str());
 
   // Make sure the path we need exists.
-  FilePath path(pipe_name);
+  FilePath path(pipe_path);
   FilePath dir_path = path.DirName();
   if (!file_util::CreateDirectory(dir_path)) {
     return false;
   }
 
   // Create unix_addr structure.
   struct sockaddr_un unix_addr;
   memset(&unix_addr, 0, sizeof(unix_addr));
   unix_addr.sun_family = AF_UNIX;
   int path_len = snprintf(unix_addr.sun_path, IPC::kMaxPipeNameLength,
-                          "%s", pipe_name.c_str());
-  DCHECK_EQ(static_cast<int>(pipe_name.length()), path_len);
+                          "%s", pipe_path.c_str());
+  DCHECK_EQ(static_cast<int>(pipe_path.length()), path_len);
   size_t unix_addr_len = offsetof(struct sockaddr_un,
                                        sun_path) + path_len + 1;
 
   // Bind the socket.
   if (bind(fd, reinterpret_cast<const sockaddr*>(&unix_addr),
            unix_addr_len) != 0) {
-    PLOG(ERROR) << "bind " << pipe_name;
+    PLOG(ERROR) << "bind " << pipe_path;
     if (HANDLE_EINTR(close(fd)) < 0)
-      PLOG(ERROR) << "close " << pipe_name;
+      PLOG(ERROR) << "close " << pipe_path;
     return false;
   }
 
   // Start listening on the socket.
   const int listen_queue_length = 1;
   if (listen(fd, listen_queue_length) != 0) {
-    PLOG(ERROR) << "listen " << pipe_name;
+    PLOG(ERROR) << "listen " << pipe_path;
     if (HANDLE_EINTR(close(fd)) < 0)
-      PLOG(ERROR) << "close " << pipe_name;
+      PLOG(ERROR) << "close " << pipe_path;
     return false;
   }
 
   *server_listen_fd = fd;
   return true;
 }
 
 // Accept a connection on a socket we are listening to.
 bool ServerAcceptConnection(int server_listen_fd, int* server_socket) {
   DCHECK(server_socket);
 
   int accept_fd = HANDLE_EINTR(accept(server_listen_fd, NULL, 0));
   if (accept_fd < 0)
     return false;
   if (fcntl(accept_fd, F_SETFL, O_NONBLOCK) == -1) {
     PLOG(ERROR) << "fcntl(O_NONBLOCK) " << accept_fd;
     if (HANDLE_EINTR(close(accept_fd)) < 0)
       PLOG(ERROR) << "close " << accept_fd;
     return false;
   }
 
   *server_socket = accept_fd;
   return true;
 }
 
 bool CreateClientUnixDomainSocket(const std::string& pipe_name,
                                   int* client_socket) {
+  FilePath temp_dir;
+  PathService::Get(base::DIR_TEMP, &temp_dir);
+  std::string pipe_path= temp_dir.value()+ "/" + pipe_name;
   DCHECK(client_socket);
-  DCHECK_GT(pipe_name.length(), 0u);
-  DCHECK_LT(pipe_name.length(), kMaxPipeNameLength);
+  DCHECK_GT(pipe_path.length(), 0u);
+  DCHECK_LT(pipe_path.length(), kMaxPipeNameLength);
 
-  if (pipe_name.length() == 0 || pipe_name.length() >= kMaxPipeNameLength) {
+  if (pipe_path.length() == 0 || pipe_path.length() >= kMaxPipeNameLength) {
     return false;
   }
 
   // Create socket.
   int fd = socket(AF_UNIX, SOCK_STREAM, 0);
   if (fd < 0) {
-    PLOG(ERROR) << "socket " << pipe_name;
+    PLOG(ERROR) << "socket " << pipe_path;
     return false;
   }
 
   // Make socket non-blocking
   if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
-    PLOG(ERROR) << "fcntl(O_NONBLOCK) " << pipe_name;
+    PLOG(ERROR) << "fcntl(O_NONBLOCK) " << pipe_path;
     if (HANDLE_EINTR(close(fd)) < 0)
-      PLOG(ERROR) << "close " << pipe_name;
+      PLOG(ERROR) << "close " << pipe_path;
     return false;
   }
 
   // Create server side of socket.
   struct sockaddr_un server_unix_addr;
   memset(&server_unix_addr, 0, sizeof(server_unix_addr));
   server_unix_addr.sun_family = AF_UNIX;
   int path_len = snprintf(server_unix_addr.sun_path, IPC::kMaxPipeNameLength,
-                          "%s", pipe_name.c_str());
-  DCHECK_EQ(static_cast<int>(pipe_name.length()), path_len);
+                          "%s", pipe_path.c_str());
+  DCHECK_EQ(static_cast<int>(pipe_path.length()), path_len);
   size_t server_unix_addr_len = offsetof(struct sockaddr_un,
                                          sun_path) + path_len + 1;
 
   if (HANDLE_EINTR(connect(fd, reinterpret_cast<sockaddr*>(&server_unix_addr),
                            server_unix_addr_len)) != 0) {
-    PLOG(ERROR) << "connect " << pipe_name;
+    PLOG(ERROR) << "connect " << pipe_path;
     if (HANDLE_EINTR(close(fd)) < 0)
-      PLOG(ERROR) << "close " << pipe_name;
+      PLOG(ERROR) << "close " << pipe_path;
     return false;
   }
 
   *client_socket = fd;
   return true;
 }
 
 bool SocketWriteErrorIsRecoverable() {
 #if defined(OS_MACOSX)
   // On OS X if sendmsg() is trying to send fds between processes and there
@@ skipping 914 matching lines @@
 
 bool Channel::GetClientEuid(uid_t* client_euid) const {
   return channel_impl_->GetClientEuid(client_euid);
 }
 
 void Channel::ResetToAcceptingConnectionState() {
   channel_impl_->ResetToAcceptingConnectionState();
 }
 
 }  // namespace IPC