Refactor unix domain socket.

net/socket/unix_domain_client_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_client_socket_posix.h"
+
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_util.h"
+#include "net/socket/socket_libevent.h"
+
+namespace net {
+
+UnixDomainClientSocket::UnixDomainClientSocket(const std::string& socket_path,
+                                               bool use_abstract_namespace)
+    : socket_path_(socket_path),
+      use_abstract_namespace_(use_abstract_namespace) {
+}
+
+UnixDomainClientSocket::UnixDomainClientSocket(
+    scoped_ptr<SocketLibevent> socket)
+    : use_abstract_namespace_(false),
+      socket_(socket.Pass()) {
+}
+
+UnixDomainClientSocket::~UnixDomainClientSocket() {
+  Disconnect();
+}
+
+// static
+bool UnixDomainClientSocket::FillAddress(const std::string& socket_path,
+                                         bool use_abstract_namespace,
+                                         SockaddrStorage* address) {
+  struct sockaddr_un* socket_addr =
+      reinterpret_cast<struct sockaddr_un*>(address->addr);
+  size_t path_max = address->addr_len - offsetof(struct sockaddr_un, sun_path);

[mmenke, 2014/07/23 18:52:40]

Can we just use sizeof(struct sockaddr_storage) or sizeof(addr->address) instead
of addr_len?  Seems weird that if this is called twice for different client
sockets, on the same SockaddrStorage, the first call can cause the second call
to fail, if the second address is longer.

You'd also need to use the same value in the memset below, but otherwise, code
would be the same.

[mmenke, 2014/07/23 18:52:40]

Hrm...SockaddrStorage is not guaranteed to be long enough to hold any AF_UNIX
address.  Do we care?  I guess we didn't, before.  May be worth a comment about
the length here.

From socket.h:

/* Structure large enough to hold any socket address (with the historical
   exception of AF_UNIX).  We reserve 128 bytes.  */
#define __ss_aligntype	unsigned long int
#define _SS_SIZE	128
#define _SS_PADSIZE	(_SS_SIZE - (2 * sizeof (__ss_aligntype)))

struct sockaddr_storage
  {
    __SOCKADDR_COMMON (ss_);	/* Address family, etc.  */
    __ss_aligntype __ss_align;	/* Force desired alignment.  */
    char __ss_padding[_SS_PADSIZE];
  };

[mmenke, 2014/07/23 18:54:35]

Oh....we used sockaddr_un before, which is indeed long enough, so this is
actually a regression.

[byungchul, 2014/07/23 22:27:11]

That explains why I failed in mac_chromium_rel which tries create a long socket
path name (109 bytes). According "man 7 unix":

#define UNIX_PATH_MAX    108

struct sockaddr_un {
    sa_family_t sun_family;               /* AF_UNIX */
    char        sun_path[UNIX_PATH_MAX];  /* pathname */
};

I think sockaddr_storage is big enough though its header comment, at least for
linux. So far, only user of this class is android, linux remoting_host and
unittests. So, hard to say we have regression failure.
Shortened socket path names in unittests. Let's see the result.

+  // Non abstract namespace pathname should be null-terminated. Abstract
+  // namespace pathname must start with '\0'. So, the size is always greater
+  // than socket_path size by 1.
+  size_t path_size = socket_path.size() + 1;
+  if (path_size > path_max)
+    return false;
+
+  memset(socket_addr, 0, address->addr_len);
+  socket_addr->sun_family = AF_UNIX;
+  address->addr_len = path_size + offsetof(struct sockaddr_un, sun_path);
+  if (!use_abstract_namespace) {
+    memcpy(socket_addr->sun_path, socket_path.c_str(), socket_path.size());
+    return true;
+  }
+
+#if defined(OS_ANDROID) || defined(OS_LINUX)
+  // 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(socket_addr->sun_path + 1, socket_path.c_str(), socket_path.size());
+  return true;
+#else
+  return false;
+#endif
+}
+
+int UnixDomainClientSocket::Connect(const CompletionCallback& callback) {
+  DCHECK(!socket_);
+
+  if (socket_path_.empty())
+    return ERR_ADDRESS_INVALID;
+
+  SockaddrStorage address;
+  if (!FillAddress(socket_path_, use_abstract_namespace_, &address))
+    return ERR_ADDRESS_INVALID;
+
+  socket_.reset(new SocketLibevent);
+  int rv = socket_->Open(AF_UNIX);
+  DCHECK_NE(ERR_IO_PENDING, rv);
+  if (rv != OK)
+    return rv;
+
+  return socket_->Connect(address, callback);
+}
+
+void UnixDomainClientSocket::Disconnect() {
+  socket_.reset();
+}
+
+bool UnixDomainClientSocket::IsConnected() const {
+  return socket_ && socket_->IsConnected();
+}
+
+bool UnixDomainClientSocket::IsConnectedAndIdle() const {
+  return socket_ && socket_->IsConnectedAndIdle();
+}
+
+int UnixDomainClientSocket::GetPeerAddress(IPEndPoint* address) const {
+  NOTIMPLEMENTED();
+  return ERR_NOT_IMPLEMENTED;
+}
+
+int UnixDomainClientSocket::GetLocalAddress(IPEndPoint* address) const {
+  NOTIMPLEMENTED();
+  return ERR_NOT_IMPLEMENTED;
+}
+
+const BoundNetLog& UnixDomainClientSocket::NetLog() const {
+  return net_log_;
+}
+
+void UnixDomainClientSocket::SetSubresourceSpeculation() {
+}
+
+void UnixDomainClientSocket::SetOmniboxSpeculation() {
+}
+
+bool UnixDomainClientSocket::WasEverUsed() const {
+  return true;  // We don't care.
+}
+
+bool UnixDomainClientSocket::UsingTCPFastOpen() const {
+  return false;
+}
+
+bool UnixDomainClientSocket::WasNpnNegotiated() const {
+  return false;
+}
+
+NextProto UnixDomainClientSocket::GetNegotiatedProtocol() const {
+  return kProtoUnknown;
+}
+
+bool UnixDomainClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
+  return false;
+}
+
+int UnixDomainClientSocket::Read(IOBuffer* buf, int buf_len,
+                                 const CompletionCallback& callback) {
+  DCHECK(socket_);
+  return socket_->Read(buf, buf_len, callback);
+}
+
+int UnixDomainClientSocket::Write(IOBuffer* buf, int buf_len,
+                                  const CompletionCallback& callback) {
+  DCHECK(socket_);
+  return socket_->Write(buf, buf_len, callback);
+}
+
+int UnixDomainClientSocket::SetReceiveBufferSize(int32 size) {
+  NOTIMPLEMENTED();
+  return ERR_NOT_IMPLEMENTED;
+}
+
+int UnixDomainClientSocket::SetSendBufferSize(int32 size) {
+  NOTIMPLEMENTED();
+  return ERR_NOT_IMPLEMENTED;
+}
+
+}  // namespace net