net/socket/unix_domain_client_socket_posix.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/socket/unix_domain_client_socket_posix.h"
   6
   7 #include <sys/socket.h>
   8 #include <sys/un.h>
   9
  10 #include "base/logging.h"
  11 #include "base/posix/eintr_wrapper.h"
  12 #include "net/base/ip_endpoint.h"
  13 #include "net/base/net_errors.h"
  14 #include "net/base/net_util.h"
  15 #include "net/socket/socket_posix.h"
  16
  17 namespace net {
  18
  19 UnixDomainClientSocket::UnixDomainClientSocket(const std::string& socket_path,
  20                                                bool use_abstract_namespace)
  21     : socket_path_(socket_path),
  22       use_abstract_namespace_(use_abstract_namespace) {
  23 }
  24
  25 UnixDomainClientSocket::UnixDomainClientSocket(scoped_ptr<SocketPosix> socket)
  26     : use_abstract_namespace_(false), socket_(socket.Pass()) {}
  27
  28 UnixDomainClientSocket::~UnixDomainClientSocket() {
  29   Disconnect();
  30 }
  31
  32 // static
  33 bool UnixDomainClientSocket::FillAddress(const std::string& socket_path,
  34                                          bool use_abstract_namespace,
  35                                          SockaddrStorage* address) {
  36   struct sockaddr_un* socket_addr =
  37       reinterpret_cast<struct sockaddr_un*>(address->addr);
  38   size_t path_max = address->addr_len - offsetof(struct sockaddr_un, sun_path);
  39   // Non abstract namespace pathname should be null-terminated. Abstract
  40   // namespace pathname must start with '\0'. So, the size is always greater
  41   // than socket_path size by 1.
  42   size_t path_size = socket_path.size() + 1;
  43   if (path_size > path_max)
  44     return false;
  45
  46   memset(socket_addr, 0, address->addr_len);
  47   socket_addr->sun_family = AF_UNIX;
  48   address->addr_len = path_size + offsetof(struct sockaddr_un, sun_path);
  49   if (!use_abstract_namespace) {
  50     memcpy(socket_addr->sun_path, socket_path.c_str(), socket_path.size());
  51     return true;
  52   }
  53
  54 #if defined(OS_ANDROID) || defined(OS_LINUX)
  55   // Convert the path given into abstract socket name. It must start with
  56   // the '\0' character, so we are adding it. |addr_len| must specify the
  57   // length of the structure exactly, as potentially the socket name may
  58   // have '\0' characters embedded (although we don't support this).
  59   // Note that addr.sun_path is already zero initialized.
  60   memcpy(socket_addr->sun_path + 1, socket_path.c_str(), socket_path.size());
  61   return true;
  62 #else
  63   return false;
  64 #endif
  65 }
  66
  67 int UnixDomainClientSocket::Connect(const CompletionCallback& callback) {
  68   DCHECK(!socket_);
  69
  70   if (socket_path_.empty())
  71     return ERR_ADDRESS_INVALID;
  72
  73   SockaddrStorage address;
  74   if (!FillAddress(socket_path_, use_abstract_namespace_, &address))
  75     return ERR_ADDRESS_INVALID;
  76
  77   socket_.reset(new SocketPosix);
  78   int rv = socket_->Open(AF_UNIX);
  79   DCHECK_NE(ERR_IO_PENDING, rv);
  80   if (rv != OK)
  81     return rv;
  82
  83   return socket_->Connect(address, callback);
  84 }
  85
  86 void UnixDomainClientSocket::Disconnect() {
  87   socket_.reset();
  88 }
  89
  90 bool UnixDomainClientSocket::IsConnected() const {
  91   return socket_ && socket_->IsConnected();
  92 }
  93
  94 bool UnixDomainClientSocket::IsConnectedAndIdle() const {
  95   return socket_ && socket_->IsConnectedAndIdle();
  96 }
  97
  98 int UnixDomainClientSocket::GetPeerAddress(IPEndPoint* address) const {
  99   // Unix domain sockets have no valid associated addr/port;
 100   // return either not connected or address invalid.
 101   DCHECK(address);
 102
 103   if (!IsConnected())
 104     return ERR_SOCKET_NOT_CONNECTED;
 105
 106   return ERR_ADDRESS_INVALID;
 107 }
 108
 109 int UnixDomainClientSocket::GetLocalAddress(IPEndPoint* address) const {
 110   // Unix domain sockets have no valid associated addr/port;
 111   // return either not connected or address invalid.
 112   DCHECK(address);
 113
 114   if (!socket_)
 115     return ERR_SOCKET_NOT_CONNECTED;
 116
 117   return ERR_ADDRESS_INVALID;
 118 }
 119
 120 const BoundNetLog& UnixDomainClientSocket::NetLog() const {
 121   return net_log_;
 122 }
 123
 124 void UnixDomainClientSocket::SetSubresourceSpeculation() {
 125 }
 126
 127 void UnixDomainClientSocket::SetOmniboxSpeculation() {
 128 }
 129
 130 bool UnixDomainClientSocket::WasEverUsed() const {
 131   return true;  // We don't care.
 132 }
 133
 134 bool UnixDomainClientSocket::UsingTCPFastOpen() const {
 135   return false;
 136 }
 137
 138 bool UnixDomainClientSocket::WasNpnNegotiated() const {
 139   return false;
 140 }
 141
 142 NextProto UnixDomainClientSocket::GetNegotiatedProtocol() const {
 143   return kProtoUnknown;
 144 }
 145
 146 bool UnixDomainClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
 147   return false;
 148 }
 149
 150 void UnixDomainClientSocket::GetConnectionAttempts(
 151     ConnectionAttempts* out) const {
 152   out->clear();
 153 }
 154
 155 int UnixDomainClientSocket::Read(IOBuffer* buf, int buf_len,
 156                                  const CompletionCallback& callback) {
 157   DCHECK(socket_);
 158   return socket_->Read(buf, buf_len, callback);
 159 }
 160
 161 int UnixDomainClientSocket::Write(IOBuffer* buf, int buf_len,
 162                                   const CompletionCallback& callback) {
 163   DCHECK(socket_);
 164   return socket_->Write(buf, buf_len, callback);
 165 }
 166
 167 int UnixDomainClientSocket::SetReceiveBufferSize(int32 size) {
 168   NOTIMPLEMENTED();
 169   return ERR_NOT_IMPLEMENTED;
 170 }
 171
 172 int UnixDomainClientSocket::SetSendBufferSize(int32 size) {
 173   NOTIMPLEMENTED();
 174   return ERR_NOT_IMPLEMENTED;
 175 }
 176
 177 SocketDescriptor UnixDomainClientSocket::ReleaseConnectedSocket() {
 178   DCHECK(socket_);
 179   DCHECK(socket_->IsConnected());
 180
 181   SocketDescriptor socket_fd = socket_->ReleaseConnectedSocket();
 182   socket_.reset();
 183   return socket_fd;
 184 }
 185
 186 }  // namespace net