1 // Copyright (c) 2011 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 "base/posix/unix_domain_socket_linux.h" 6 7 #include <errno.h> 8 #include <sys/socket.h> 9 #include <sys/uio.h> 10 #include <unistd.h> 11 12 #include <vector> 13 14 #include "base/files/scoped_file.h" 15 #include "base/logging.h" 16 #include "base/memory/scoped_vector.h" 17 #include "base/pickle.h" 18 #include "base/posix/eintr_wrapper.h" 19 #include "base/stl_util.h" 20 21 const size_t UnixDomainSocket::kMaxFileDescriptors = 16; 22 23 // Creates a connected pair of UNIX-domain SOCK_SEQPACKET sockets, and passes 24 // ownership of the newly allocated file descriptors to |one| and |two|. 25 // Returns true on success. 26 static bool CreateSocketPair(base::ScopedFD* one, base::ScopedFD* two) { 27 int raw_socks[2]; 28 if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, raw_socks) == -1) 29 return false; 30 one->reset(raw_socks[0]); 31 two->reset(raw_socks[1]); 32 return true; 33 } 34 35 // static 36 bool UnixDomainSocket::EnableReceiveProcessId(int fd) { 37 const int enable = 1; 38 return setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable)) == 0; 39 } 40 41 // static 42 bool UnixDomainSocket::SendMsg(int fd, 43 const void* buf, 44 size_t length, 45 const std::vector<int>& fds) { 46 struct msghdr msg = {}; 47 struct iovec iov = { const_cast<void*>(buf), length }; 48 msg.msg_iov = &iov; 49 msg.msg_iovlen = 1; 50 51 char* control_buffer = NULL; 52 if (fds.size()) { 53 const unsigned control_len = CMSG_SPACE(sizeof(int) * fds.size()); 54 control_buffer = new char[control_len]; 55 56 struct cmsghdr* cmsg; 57 msg.msg_control = control_buffer; 58 msg.msg_controllen = control_len; 59 cmsg = CMSG_FIRSTHDR(&msg); 60 cmsg->cmsg_level = SOL_SOCKET; 61 cmsg->cmsg_type = SCM_RIGHTS; 62 cmsg->cmsg_len = CMSG_LEN(sizeof(int) * fds.size()); 63 memcpy(CMSG_DATA(cmsg), &fds[0], sizeof(int) * fds.size()); 64 msg.msg_controllen = cmsg->cmsg_len; 65 } 66 67 // Avoid a SIGPIPE if the other end breaks the connection. 68 // Due to a bug in the Linux kernel (net/unix/af_unix.c) MSG_NOSIGNAL isn't 69 // regarded for SOCK_SEQPACKET in the AF_UNIX domain, but it is mandated by 70 // POSIX. 71 const int flags = MSG_NOSIGNAL; 72 const ssize_t r = HANDLE_EINTR(sendmsg(fd, &msg, flags)); 73 const bool ret = static_cast<ssize_t>(length) == r; 74 delete[] control_buffer; 75 return ret; 76 } 77 78 // static 79 ssize_t UnixDomainSocket::RecvMsg(int fd, 80 void* buf, 81 size_t length, 82 ScopedVector<base::ScopedFD>* fds) { 83 return UnixDomainSocket::RecvMsgWithPid(fd, buf, length, fds, NULL); 84 } 85 86 // static 87 ssize_t UnixDomainSocket::RecvMsgWithPid(int fd, 88 void* buf, 89 size_t length, 90 ScopedVector<base::ScopedFD>* fds, 91 base::ProcessId* pid) { 92 return UnixDomainSocket::RecvMsgWithFlags(fd, buf, length, 0, fds, pid); 93 } 94 95 // static 96 ssize_t UnixDomainSocket::RecvMsgWithFlags(int fd, 97 void* buf, 98 size_t length, 99 int flags, 100 ScopedVector<base::ScopedFD>* fds, 101 base::ProcessId* out_pid) { 102 fds->clear(); 103 104 struct msghdr msg = {}; 105 struct iovec iov = { buf, length }; 106 msg.msg_iov = &iov; 107 msg.msg_iovlen = 1; 108 109 char control_buffer[CMSG_SPACE(sizeof(int) * kMaxFileDescriptors) + 110 CMSG_SPACE(sizeof(struct ucred))]; 111 msg.msg_control = control_buffer; 112 msg.msg_controllen = sizeof(control_buffer); 113 114 const ssize_t r = HANDLE_EINTR(recvmsg(fd, &msg, flags)); 115 if (r == -1) 116 return -1; 117 118 int* wire_fds = NULL; 119 unsigned wire_fds_len = 0; 120 base::ProcessId pid = -1; 121 122 if (msg.msg_controllen > 0) { 123 struct cmsghdr* cmsg; 124 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) { 125 const unsigned payload_len = cmsg->cmsg_len - CMSG_LEN(0); 126 if (cmsg->cmsg_level == SOL_SOCKET && 127 cmsg->cmsg_type == SCM_RIGHTS) { 128 DCHECK(payload_len % sizeof(int) == 0); 129 DCHECK(wire_fds == NULL); 130 wire_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg)); 131 wire_fds_len = payload_len / sizeof(int); 132 } 133 if (cmsg->cmsg_level == SOL_SOCKET && 134 cmsg->cmsg_type == SCM_CREDENTIALS) { 135 DCHECK(payload_len == sizeof(struct ucred)); 136 DCHECK(pid == -1); 137 pid = reinterpret_cast<struct ucred*>(CMSG_DATA(cmsg))->pid; 138 } 139 } 140 } 141 142 if (msg.msg_flags & MSG_TRUNC || msg.msg_flags & MSG_CTRUNC) { 143 for (unsigned i = 0; i < wire_fds_len; ++i) 144 close(wire_fds[i]); 145 errno = EMSGSIZE; 146 return -1; 147 } 148 149 if (wire_fds) { 150 for (unsigned i = 0; i < wire_fds_len; ++i) 151 fds->push_back(new base::ScopedFD(wire_fds[i])); 152 } 153 154 if (out_pid) { 155 // |pid| will legitimately be -1 if we read EOF, so only DCHECK if we 156 // actually received a message. Unfortunately, Linux allows sending zero 157 // length messages, which are indistinguishable from EOF, so this check 158 // has false negatives. 159 if (r > 0 || msg.msg_controllen > 0) 160 DCHECK_GE(pid, 0); 161 162 *out_pid = pid; 163 } 164 165 return r; 166 } 167 168 // static 169 ssize_t UnixDomainSocket::SendRecvMsg(int fd, 170 uint8_t* reply, 171 unsigned max_reply_len, 172 int* result_fd, 173 const Pickle& request) { 174 return UnixDomainSocket::SendRecvMsgWithFlags(fd, reply, max_reply_len, 175 0, /* recvmsg_flags */ 176 result_fd, request); 177 } 178 179 // static 180 ssize_t UnixDomainSocket::SendRecvMsgWithFlags(int fd, 181 uint8_t* reply, 182 unsigned max_reply_len, 183 int recvmsg_flags, 184 int* result_fd, 185 const Pickle& request) { 186 // This socketpair is only used for the IPC and is cleaned up before 187 // returning. 188 base::ScopedFD recv_sock, send_sock; 189 if (!CreateSocketPair(&recv_sock, &send_sock)) 190 return -1; 191 192 { 193 std::vector<int> send_fds; 194 send_fds.push_back(send_sock.get()); 195 if (!SendMsg(fd, request.data(), request.size(), send_fds)) 196 return -1; 197 } 198 199 // Close the sending end of the socket right away so that if our peer closes 200 // it before sending a response (e.g., from exiting), RecvMsgWithFlags() will 201 // return EOF instead of hanging. 202 send_sock.reset(); 203 204 ScopedVector<base::ScopedFD> recv_fds; 205 // When porting to OSX keep in mind it doesn't support MSG_NOSIGNAL, so the 206 // sender might get a SIGPIPE. 207 const ssize_t reply_len = RecvMsgWithFlags( 208 recv_sock.get(), reply, max_reply_len, recvmsg_flags, &recv_fds, NULL); 209 recv_sock.reset(); 210 if (reply_len == -1) 211 return -1; 212 213 // If we received more file descriptors than caller expected, then we treat 214 // that as an error. 215 if (recv_fds.size() > (result_fd != NULL ? 1 : 0)) { 216 NOTREACHED(); 217 return -1; 218 } 219 220 if (result_fd) 221 *result_fd = recv_fds.empty() ? -1 : recv_fds[0]->release(); 222 223 return reply_len; 224 } 225
