Replace StreamListenSocket with StreamSocket in HttpServer.

net/socket/unix_domain_server_socket_posix.cc

+// Copyright 2014 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_server_socket_posix.h"
+
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include "base/callback.h"
+#include "base/callback_helpers.h"
+#include "base/posix/eintr_wrapper.h"
+#include "net/base/net_errors.h"
+#include "net/socket/unix_domain_client_socket_posix.h"
+
+namespace net {
+
+UnixDomainServerSocket::UnixDomainServerSocket(
+    const AuthCallback& auth_callback,
+    bool use_abstract_namespace)
+    : socket_fd_(kInvalidSocket),
+      auth_callback_(auth_callback),
+      use_abstract_namespace_(use_abstract_namespace) {
+}
+
+UnixDomainServerSocket::~UnixDomainServerSocket() {
+  Close();
+}
+
+// static
+int UnixDomainServerSocket::CreateAndBind(const std::string& socket_path,
+                                          bool use_abstract_namespace,
+                                          SocketDescriptor* socket_fd) {
+  sockaddr_un addr;
+  socklen_t addr_len = sizeof(addr);
+  if (!UnixDomainClientSocket::FillAddress(socket_path,
+                                           use_abstract_namespace,
+                                           &addr, &addr_len))
+    return ERR_ADDRESS_INVALID;
+
+  SocketDescriptor s = CreatePlatformSocket(PF_UNIX, SOCK_STREAM, 0);
+  if (s == kInvalidSocket)
+    return errno ? MapSystemError(errno) : ERR_UNEXPECTED;
+
+  if (bind(s, reinterpret_cast<sockaddr*>(&addr), addr_len) < 0) {
+    int rv = MapSystemError(errno);
+    close(s);
+    PLOG(ERROR) << "Could not bind unix domain socket to " << socket_path
+                << (use_abstract_namespace ? " (with abstract namespace)" : "");
+    return rv;
+  }
+
+  DCHECK(socket_fd);
+  *socket_fd = s;
+  return OK;
+}
+
+// static
+bool UnixDomainServerSocket::GetPeerIds(SocketDescriptor 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) < 0)
+    return false;
+  *user_id = user_cred.uid;
+  *group_id = user_cred.gid;
+#else
+  if (getpeereid(socket, user_id, group_id) < 0)
+    return false;
+#endif
+  return true;
+}
+
+void UnixDomainServerSocket::Close() {
+  if (socket_fd_ == kInvalidSocket)
+    return;
+  close(socket_fd_);
+  socket_fd_ = kInvalidSocket;
+}
+
+int UnixDomainServerSocket::Listen(const IPEndPoint& address, int backlog) {
+  NOTIMPLEMENTED();
+  return ERR_NOT_IMPLEMENTED;
+}
+
+int UnixDomainServerSocket::ListenWithAddressAndPort(
+    const std::string& unix_domain_path,
+    int port_unused,
+    int backlog) {
+  int rv = CreateAndBind(unix_domain_path,
+                         use_abstract_namespace_,
+                         &socket_fd_);
+  if (rv != OK)
+    return rv;
+
+  if (listen(socket_fd_, backlog) < 0) {
+    PLOG(ERROR) << "listen() returned an error";
+    rv = MapSystemError(errno);
+    Close();
+    return rv;
+  }
+
+  if (SetNonBlocking(socket_fd_)) {
+    rv = MapSystemError(errno);
+    Close();
+    return rv;
+  }
+
+  return OK;
+}
+
+int UnixDomainServerSocket::GetLocalAddress(IPEndPoint* address) const {
+  NOTIMPLEMENTED();
+  return ERR_NOT_IMPLEMENTED;
+}
+
+int UnixDomainServerSocket::Accept(scoped_ptr<StreamSocket>* socket,
+                                   const CompletionCallback& callback) {
+  DCHECK(socket);
+  DCHECK(!callback.is_null());
+  DCHECK(accept_callback_.is_null());
+
+  int rv = DoAccept(socket);
+  if (rv != ERR_IO_PENDING)
+    return rv;
+
+  if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
+          socket_fd_, true, base::MessageLoopForIO::WATCH_READ,
+          &accept_socket_watcher_, this)) {
+    PLOG(ERROR) << "WatchFileDescriptor failed on read";
+    return MapSystemError(errno);
+  }
+
+  accept_socket_ = socket;
+  accept_callback_ = callback;
+  return ERR_IO_PENDING;
+}
+
+int UnixDomainServerSocket::DoAccept(scoped_ptr<StreamSocket>* socket) {
+  int new_socket = HANDLE_EINTR(accept(socket_fd_, NULL, NULL));
+  if (new_socket < 0) {
+    // Treat as IO_PENDING for ECONNABORTED. See MapAcceptError() in
+    // tcp_socket_libevent.cc for detailed reason.
+    return errno == ECONNABORTED ? ERR_IO_PENDING : MapSystemError(errno);
+  }
+
+  uid_t user_id;
+  gid_t group_id;
+  if (!GetPeerIds(new_socket, &user_id, &group_id) ||
+      !auth_callback_.Run(user_id, group_id)) {
+    close(new_socket);
+    return ERR_IO_PENDING;
+  }
+
+  if (SetNonBlocking(new_socket)) {
+    close(new_socket);
+    return ERR_IO_PENDING;
+  }
+
+  socket->reset(new UnixDomainClientSocket(new_socket));
+  return OK;
+}
+
+void UnixDomainServerSocket::DidCompleteAccept() {
+  int rv = DoAccept(accept_socket_);
+  if (rv == ERR_IO_PENDING)
+    return;
+
+  accept_socket_watcher_.StopWatchingFileDescriptor();
+  accept_socket_ = NULL;
+  base::ResetAndReturn(&accept_callback_).Run(rv);
+}
+
+void UnixDomainServerSocket::OnFileCanReadWithoutBlocking(int fd) {
+  if (accept_callback_.is_null()) {
+    NOTREACHED();
+  } else {
+    DidCompleteAccept();
+  }
+}
+
+void UnixDomainServerSocket::OnFileCanWriteWithoutBlocking(int fd) {
+  NOTREACHED();
+}
+
+}  // namespace net