Refactor unix domain socket.

net/socket/unix_domain_socket_posix.cc

 // Copyright (c) 2012 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 "net/socket/unix_domain_socket_posix.h"
 
-#include <cstring>
-#include <string>
-
 #include <errno.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/un.h>
 #include <unistd.h>
 
+#include <cstring>
+#include <string>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/socket/socket_descriptor.h"
+#include "net/socket/unix_domain_client_socket_posix.h"
 
 namespace net {
 
 namespace {
 
-bool NoAuthenticationCallback(uid_t, gid_t) {
-  return true;
-}
+int CreateAndBind(const std::string& socket_path,
+                  bool use_abstract_namespace,
+                  SocketDescriptor* socket_fd) {
+  DCHECK(socket_fd);
 
-bool GetPeerIds(int socket, uid_t* user_id, gid_t* group_id) {
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-  struct ucred user_cred;
-  socklen_t len = sizeof(user_cred);
-  if (getsockopt(socket, SOL_SOCKET, SO_PEERCRED, &user_cred, &len) == -1)
-    return false;
-  *user_id = user_cred.uid;
-  *group_id = user_cred.gid;
-#else
-  if (getpeereid(socket, user_id, group_id) == -1)
-    return false;
-#endif
-  return true;
+  SockaddrStorage address;
+  if (!UnixDomainClientSocket::FillAddress(socket_path,
+                                           use_abstract_namespace,
+                                           &address)) {
+    return ERR_ADDRESS_INVALID;
+  }
+
+  SocketDescriptor fd = CreatePlatformSocket(PF_UNIX, SOCK_STREAM, 0);
+  if (fd == kInvalidSocket)
+    return errno ? MapSystemError(errno) : ERR_UNEXPECTED;
+
+  if (bind(fd, address.addr, address.addr_len) < 0) {
+    int rv = MapSystemError(errno);
+    close(fd);
+    PLOG(ERROR) << "Could not bind unix domain socket to " << socket_path
+                << (use_abstract_namespace ? " (with abstract namespace)" : "");
+    return rv;
+  }
+
+  *socket_fd = fd;
+  return OK;
 }
 
 }  // namespace
 
 // static
-UnixDomainSocket::AuthCallback UnixDomainSocket::NoAuthentication() {
-  return base::Bind(NoAuthenticationCallback);
-}
-
-// static
-scoped_ptr<UnixDomainSocket> UnixDomainSocket::CreateAndListenInternal(
+scoped_ptr<UnixDomainListenSocket>
+UnixDomainListenSocket::CreateAndListenInternal(
     const std::string& path,
     const std::string& fallback_path,
     StreamListenSocket::Delegate* del,
     const AuthCallback& auth_callback,
     bool use_abstract_namespace) {
-  SocketDescriptor s = CreateAndBind(path, use_abstract_namespace);
-  if (s == kInvalidSocket && !fallback_path.empty())
-    s = CreateAndBind(fallback_path, use_abstract_namespace);
-  if (s == kInvalidSocket)
-    return scoped_ptr<UnixDomainSocket>();
-  scoped_ptr<UnixDomainSocket> sock(
-      new UnixDomainSocket(s, del, auth_callback));
+  SocketDescriptor socket_fd = kInvalidSocket;
+  int rv = CreateAndBind(path, use_abstract_namespace, &socket_fd);
+  if (rv != OK && !fallback_path.empty())
+    rv = CreateAndBind(fallback_path, use_abstract_namespace, &socket_fd);
+  if (rv != OK)
+    return scoped_ptr<UnixDomainListenSocket>();
+  scoped_ptr<UnixDomainListenSocket> sock(
+      new UnixDomainListenSocket(socket_fd, del, auth_callback));
   sock->Listen();
   return sock.Pass();
 }
 
 // static
-scoped_ptr<UnixDomainSocket> UnixDomainSocket::CreateAndListen(
+scoped_ptr<UnixDomainListenSocket> UnixDomainListenSocket::CreateAndListen(
     const std::string& path,
     StreamListenSocket::Delegate* del,
     const AuthCallback& auth_callback) {
   return CreateAndListenInternal(path, "", del, auth_callback, false);
 }
 
 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
 // static
-scoped_ptr<UnixDomainSocket>
-UnixDomainSocket::CreateAndListenWithAbstractNamespace(
+scoped_ptr<UnixDomainListenSocket>
+UnixDomainListenSocket::CreateAndListenWithAbstractNamespace(
     const std::string& path,
     const std::string& fallback_path,
     StreamListenSocket::Delegate* del,
     const AuthCallback& auth_callback) {
   return
       CreateAndListenInternal(path, fallback_path, del, auth_callback, true);
 }
 #endif
 
-UnixDomainSocket::UnixDomainSocket(
+UnixDomainListenSocket::UnixDomainListenSocket(
     SocketDescriptor s,
     StreamListenSocket::Delegate* del,
     const AuthCallback& auth_callback)
     : StreamListenSocket(s, del),
       auth_callback_(auth_callback) {}
 
-UnixDomainSocket::~UnixDomainSocket() {}
+UnixDomainListenSocket::~UnixDomainListenSocket() {}
 
-// static
-SocketDescriptor UnixDomainSocket::CreateAndBind(const std::string& path,
-                                                 bool use_abstract_namespace) {
-  sockaddr_un addr;
-  static const size_t kPathMax = sizeof(addr.sun_path);
-  if (use_abstract_namespace + path.size() + 1 /* '\0' */ > kPathMax)
-    return kInvalidSocket;
-  const SocketDescriptor s = CreatePlatformSocket(PF_UNIX, SOCK_STREAM, 0);
-  if (s == kInvalidSocket)
-    return kInvalidSocket;
-  memset(&addr, 0, sizeof(addr));
-  addr.sun_family = AF_UNIX;
-  socklen_t addr_len;
-  if (use_abstract_namespace) {
-    // Convert the path given into abstract socket name. It must start with
-    // the '\0' character, so we are adding it. |addr_len| must specify the
-    // length of the structure exactly, as potentially the socket name may
-    // have '\0' characters embedded (although we don't support this).
-    // Note that addr.sun_path is already zero initialized.
-    memcpy(addr.sun_path + 1, path.c_str(), path.size());
-    addr_len = path.size() + offsetof(struct sockaddr_un, sun_path) + 1;
-  } else {
-    memcpy(addr.sun_path, path.c_str(), path.size());
-    addr_len = sizeof(sockaddr_un);
-  }
-  if (bind(s, reinterpret_cast<sockaddr*>(&addr), addr_len)) {
-    LOG(ERROR) << "Could not bind unix domain socket to " << path;
-    if (use_abstract_namespace)
-      LOG(ERROR) << " (with abstract namespace enabled)";
-    if (IGNORE_EINTR(close(s)) < 0)
-      LOG(ERROR) << "close() error";
-    return kInvalidSocket;
-  }
-  return s;
-}
-
-void UnixDomainSocket::Accept() {
+void UnixDomainListenSocket::Accept() {
   SocketDescriptor conn = StreamListenSocket::AcceptSocket();
   if (conn == kInvalidSocket)
     return;
   uid_t user_id;
   gid_t group_id;
-  if (!GetPeerIds(conn, &user_id, &group_id) ||
+  if (!UnixDomainServerSocket::GetPeerIds(conn, &user_id, &group_id) ||
       !auth_callback_.Run(user_id, group_id)) {
     if (IGNORE_EINTR(close(conn)) < 0)
       LOG(ERROR) << "close() error";
     return;
   }
-  scoped_ptr<UnixDomainSocket> sock(
-      new UnixDomainSocket(conn, socket_delegate_, auth_callback_));
+  scoped_ptr<UnixDomainListenSocket> sock(
+      new UnixDomainListenSocket(conn, socket_delegate_, auth_callback_));
   // It's up to the delegate to AddRef if it wants to keep it around.
   sock->WatchSocket(WAITING_READ);
   socket_delegate_->DidAccept(this, sock.PassAs<StreamListenSocket>());
 }
 
-UnixDomainSocketFactory::UnixDomainSocketFactory(
+UnixDomainListenSocketFactory::UnixDomainListenSocketFactory(
     const std::string& path,
-    const UnixDomainSocket::AuthCallback& auth_callback)
+    const UnixDomainListenSocket::AuthCallback& auth_callback)
     : path_(path),
       auth_callback_(auth_callback) {}
 
-UnixDomainSocketFactory::~UnixDomainSocketFactory() {}
+UnixDomainListenSocketFactory::~UnixDomainListenSocketFactory() {}
 
-scoped_ptr<StreamListenSocket> UnixDomainSocketFactory::CreateAndListen(
+scoped_ptr<StreamListenSocket> UnixDomainListenSocketFactory::CreateAndListen(
     StreamListenSocket::Delegate* delegate) const {
-  return UnixDomainSocket::CreateAndListen(
+  return UnixDomainListenSocket::CreateAndListen(
       path_, delegate, auth_callback_).PassAs<StreamListenSocket>();
 }
 
 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
 
-UnixDomainSocketWithAbstractNamespaceFactory::
-UnixDomainSocketWithAbstractNamespaceFactory(
+UnixDomainListenSocketWithAbstractNamespaceFactory::
+UnixDomainListenSocketWithAbstractNamespaceFactory(
     const std::string& path,
     const std::string& fallback_path,
-    const UnixDomainSocket::AuthCallback& auth_callback)
-    : UnixDomainSocketFactory(path, auth_callback),
+    const UnixDomainListenSocket::AuthCallback& auth_callback)
+    : UnixDomainListenSocketFactory(path, auth_callback),
       fallback_path_(fallback_path) {}
 
-UnixDomainSocketWithAbstractNamespaceFactory::
-~UnixDomainSocketWithAbstractNamespaceFactory() {}
+UnixDomainListenSocketWithAbstractNamespaceFactory::
+~UnixDomainListenSocketWithAbstractNamespaceFactory() {}
 
 scoped_ptr<StreamListenSocket>
-UnixDomainSocketWithAbstractNamespaceFactory::CreateAndListen(
+UnixDomainListenSocketWithAbstractNamespaceFactory::CreateAndListen(
     StreamListenSocket::Delegate* delegate) const {
-  return UnixDomainSocket::CreateAndListenWithAbstractNamespace(
+  return UnixDomainListenSocket::CreateAndListenWithAbstractNamespace(
              path_, fallback_path_, delegate, auth_callback_)
          .PassAs<StreamListenSocket>();
 }
 
 #endif
 
 }  // namespace net