1 // Copyright (c) 2012 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_socket_posix.h" 6 7 #include <cstring> 8 #include <string> 9 10 #include <errno.h> 11 #include <sys/socket.h> 12 #include <sys/stat.h> 13 #include <sys/types.h> 14 #include <sys/un.h> 15 #include <unistd.h> 16 17 #include "base/bind.h" 18 #include "base/callback.h" 19 #include "base/posix/eintr_wrapper.h" 20 #include "base/threading/platform_thread.h" 21 #include "build/build_config.h" 22 #include "net/base/net_errors.h" 23 #include "net/base/net_util.h" 24 #include "net/socket/socket_descriptor.h" 25 26 namespace net { 27 28 namespace { 29 30 bool NoAuthenticationCallback(uid_t, gid_t) { 31 return true; 32 } 33 34 bool GetPeerIds(int socket, uid_t* user_id, gid_t* group_id) { 35 #if defined(OS_LINUX) || defined(OS_ANDROID) 36 struct ucred user_cred; 37 socklen_t len = sizeof(user_cred); 38 if (getsockopt(socket, SOL_SOCKET, SO_PEERCRED, &user_cred, &len) == -1) 39 return false; 40 *user_id = user_cred.uid; 41 *group_id = user_cred.gid; 42 #else 43 if (getpeereid(socket, user_id, group_id) == -1) 44 return false; 45 #endif 46 return true; 47 } 48 49 } // namespace 50 51 // static 52 UnixDomainSocket::AuthCallback UnixDomainSocket::NoAuthentication() { 53 return base::Bind(NoAuthenticationCallback); 54 } 55 56 // static 57 scoped_ptr<UnixDomainSocket> UnixDomainSocket::CreateAndListenInternal( 58 const std::string& path, 59 const std::string& fallback_path, 60 StreamListenSocket::Delegate* del, 61 const AuthCallback& auth_callback, 62 bool use_abstract_namespace) { 63 SocketDescriptor s = CreateAndBind(path, use_abstract_namespace); 64 if (s == kInvalidSocket && !fallback_path.empty()) 65 s = CreateAndBind(fallback_path, use_abstract_namespace); 66 if (s == kInvalidSocket) 67 return scoped_ptr<UnixDomainSocket>(); 68 scoped_ptr<UnixDomainSocket> sock( 69 new UnixDomainSocket(s, del, auth_callback)); 70 sock->Listen(); 71 return sock.Pass(); 72 } 73 74 // static 75 scoped_ptr<UnixDomainSocket> UnixDomainSocket::CreateAndListen( 76 const std::string& path, 77 StreamListenSocket::Delegate* del, 78 const AuthCallback& auth_callback) { 79 return CreateAndListenInternal(path, "", del, auth_callback, false); 80 } 81 82 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED) 83 // static 84 scoped_ptr<UnixDomainSocket> 85 UnixDomainSocket::CreateAndListenWithAbstractNamespace( 86 const std::string& path, 87 const std::string& fallback_path, 88 StreamListenSocket::Delegate* del, 89 const AuthCallback& auth_callback) { 90 return 91 CreateAndListenInternal(path, fallback_path, del, auth_callback, true); 92 } 93 #endif 94 95 UnixDomainSocket::UnixDomainSocket( 96 SocketDescriptor s, 97 StreamListenSocket::Delegate* del, 98 const AuthCallback& auth_callback) 99 : StreamListenSocket(s, del), 100 auth_callback_(auth_callback) {} 101 102 UnixDomainSocket::~UnixDomainSocket() {} 103 104 // static 105 SocketDescriptor UnixDomainSocket::CreateAndBind(const std::string& path, 106 bool use_abstract_namespace) { 107 sockaddr_un addr; 108 static const size_t kPathMax = sizeof(addr.sun_path); 109 if (use_abstract_namespace + path.size() + 1 /* '\0' */ > kPathMax) 110 return kInvalidSocket; 111 const SocketDescriptor s = CreatePlatformSocket(PF_UNIX, SOCK_STREAM, 0); 112 if (s == kInvalidSocket) 113 return kInvalidSocket; 114 memset(&addr, 0, sizeof(addr)); 115 addr.sun_family = AF_UNIX; 116 socklen_t addr_len; 117 if (use_abstract_namespace) { 118 // Convert the path given into abstract socket name. It must start with 119 // the '\0' character, so we are adding it. |addr_len| must specify the 120 // length of the structure exactly, as potentially the socket name may 121 // have '\0' characters embedded (although we don't support this). 122 // Note that addr.sun_path is already zero initialized. 123 memcpy(addr.sun_path + 1, path.c_str(), path.size()); 124 addr_len = path.size() + offsetof(struct sockaddr_un, sun_path) + 1; 125 } else { 126 memcpy(addr.sun_path, path.c_str(), path.size()); 127 addr_len = sizeof(sockaddr_un); 128 } 129 if (bind(s, reinterpret_cast<sockaddr*>(&addr), addr_len)) { 130 LOG(ERROR) << "Could not bind unix domain socket to " << path; 131 if (use_abstract_namespace) 132 LOG(ERROR) << " (with abstract namespace enabled)"; 133 if (IGNORE_EINTR(close(s)) < 0) 134 LOG(ERROR) << "close() error"; 135 return kInvalidSocket; 136 } 137 return s; 138 } 139 140 void UnixDomainSocket::Accept() { 141 SocketDescriptor conn = StreamListenSocket::AcceptSocket(); 142 if (conn == kInvalidSocket) 143 return; 144 uid_t user_id; 145 gid_t group_id; 146 if (!GetPeerIds(conn, &user_id, &group_id) || 147 !auth_callback_.Run(user_id, group_id)) { 148 if (IGNORE_EINTR(close(conn)) < 0) 149 LOG(ERROR) << "close() error"; 150 return; 151 } 152 scoped_ptr<UnixDomainSocket> sock( 153 new UnixDomainSocket(conn, socket_delegate_, auth_callback_)); 154 // It's up to the delegate to AddRef if it wants to keep it around. 155 sock->WatchSocket(WAITING_READ); 156 socket_delegate_->DidAccept(this, sock.PassAs<StreamListenSocket>()); 157 } 158 159 UnixDomainSocketFactory::UnixDomainSocketFactory( 160 const std::string& path, 161 const UnixDomainSocket::AuthCallback& auth_callback) 162 : path_(path), 163 auth_callback_(auth_callback) {} 164 165 UnixDomainSocketFactory::~UnixDomainSocketFactory() {} 166 167 scoped_ptr<StreamListenSocket> UnixDomainSocketFactory::CreateAndListen( 168 StreamListenSocket::Delegate* delegate) const { 169 return UnixDomainSocket::CreateAndListen( 170 path_, delegate, auth_callback_).PassAs<StreamListenSocket>(); 171 } 172 173 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED) 174 175 UnixDomainSocketWithAbstractNamespaceFactory:: 176 UnixDomainSocketWithAbstractNamespaceFactory( 177 const std::string& path, 178 const std::string& fallback_path, 179 const UnixDomainSocket::AuthCallback& auth_callback) 180 : UnixDomainSocketFactory(path, auth_callback), 181 fallback_path_(fallback_path) {} 182 183 UnixDomainSocketWithAbstractNamespaceFactory:: 184 ~UnixDomainSocketWithAbstractNamespaceFactory() {} 185 186 scoped_ptr<StreamListenSocket> 187 UnixDomainSocketWithAbstractNamespaceFactory::CreateAndListen( 188 StreamListenSocket::Delegate* delegate) const { 189 return UnixDomainSocket::CreateAndListenWithAbstractNamespace( 190 path_, fallback_path_, delegate, auth_callback_) 191 .PassAs<StreamListenSocket>(); 192 } 193 194 #endif 195 196 } // namespace net 197
