base/posix/unix_domain_socket.cc

   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.h"
   6
   7 #include <errno.h>
   8 #include <unistd.h>
   9 #include <sys/uio.h>
  10 #include <sys/socket.h>
  11
  12 #include "base/logging.h"
  13 #include "base/pickle.h"
  14 #include "base/posix/eintr_wrapper.h"
  15 #include "base/stl_util.h"
  16
  17 const size_t UnixDomainSocket::kMaxFileDescriptors = 16;
  18
  19 // static
  20 bool UnixDomainSocket::SendMsg(int fd,
  21                                const void* buf,
  22                                size_t length,
  23                                const std::vector<int>& fds) {
  24   struct msghdr msg;
  25   memset(&msg, 0, sizeof(msg));
  26   struct iovec iov = {const_cast<void*>(buf), length};
  27   msg.msg_iov = &iov;
  28   msg.msg_iovlen = 1;
  29
  30   char* control_buffer = NULL;
  31   if (fds.size()) {
  32     const unsigned control_len = CMSG_SPACE(sizeof(int) * fds.size());
  33     control_buffer = new char[control_len];
  34
  35     struct cmsghdr *cmsg;
  36     msg.msg_control = control_buffer;
  37     msg.msg_controllen = control_len;
  38     cmsg = CMSG_FIRSTHDR(&msg);
  39     cmsg->cmsg_level = SOL_SOCKET;
  40     cmsg->cmsg_type = SCM_RIGHTS;
  41     cmsg->cmsg_len = CMSG_LEN(sizeof(int) * fds.size());
  42     memcpy(CMSG_DATA(cmsg), &fds[0], sizeof(int) * fds.size());
  43     msg.msg_controllen = cmsg->cmsg_len;
  44   }
  45
  46   // When available, take advantage of MSG_NOSIGNAL to avoid
  47   // a SIGPIPE if the other end breaks the connection.
  48 #if defined(MSG_NOSIGNAL)
  49   const int flags = MSG_NOSIGNAL;
  50 #else
  51   const int flags = 0;
  52 #endif
  53   const ssize_t r = HANDLE_EINTR(sendmsg(fd, &msg, flags));
  54   const bool ret = static_cast<ssize_t>(length) == r;
  55   delete[] control_buffer;
  56   return ret;
  57 }
  58
  59 // static
  60 ssize_t UnixDomainSocket::RecvMsg(int fd,
  61                                   void* buf,
  62                                   size_t length,
  63                                   std::vector<int>* fds) {
  64   fds->clear();
  65
  66   struct msghdr msg;
  67   memset(&msg, 0, sizeof(msg));
  68   struct iovec iov = {buf, length};
  69   msg.msg_iov = &iov;
  70   msg.msg_iovlen = 1;
  71
  72   char control_buffer[CMSG_SPACE(sizeof(int) * kMaxFileDescriptors)];
  73   msg.msg_control = control_buffer;
  74   msg.msg_controllen = sizeof(control_buffer);
  75
  76   const ssize_t r = HANDLE_EINTR(recvmsg(fd, &msg, 0));
  77   if (r == -1)
  78     return -1;
  79
  80   int* wire_fds = NULL;
  81   unsigned wire_fds_len = 0;
  82
  83   if (msg.msg_controllen > 0) {
  84     struct cmsghdr* cmsg;
  85     for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
  86       if (cmsg->cmsg_level == SOL_SOCKET &&
  87           cmsg->cmsg_type == SCM_RIGHTS) {
  88         const unsigned payload_len = cmsg->cmsg_len - CMSG_LEN(0);
  89         DCHECK(payload_len % sizeof(int) == 0);
  90         wire_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
  91         wire_fds_len = payload_len / sizeof(int);
  92         break;
  93       }
  94     }
  95   }
  96
  97   if (msg.msg_flags & MSG_TRUNC || msg.msg_flags & MSG_CTRUNC) {
  98     for (unsigned i = 0; i < wire_fds_len; ++i)
  99       close(wire_fds[i]);
 100     errno = EMSGSIZE;
 101     return -1;
 102   }
 103
 104   fds->resize(wire_fds_len);
 105   memcpy(vector_as_array(fds), wire_fds, sizeof(int) * wire_fds_len);
 106
 107   return r;
 108 }
 109
 110 // static
 111 ssize_t UnixDomainSocket::SendRecvMsg(int fd,
 112                                       uint8_t* reply,
 113                                       unsigned max_reply_len,
 114                                       int* result_fd,
 115                                       const Pickle& request) {
 116   int fds[2];
 117
 118   // This socketpair is only used for the IPC and is cleaned up before
 119   // returning.
 120   if (socketpair(AF_UNIX, SOCK_DGRAM, 0, fds) == -1)
 121     return -1;
 122
 123   std::vector<int> fd_vector;
 124   fd_vector.push_back(fds[1]);
 125   if (!SendMsg(fd, request.data(), request.size(), fd_vector)) {
 126     close(fds[0]);
 127     close(fds[1]);
 128     return -1;
 129   }
 130   close(fds[1]);
 131
 132   fd_vector.clear();
 133   const ssize_t reply_len = RecvMsg(fds[0], reply, max_reply_len, &fd_vector);
 134   close(fds[0]);
 135   if (reply_len == -1)
 136     return -1;
 137
 138   if ((!fd_vector.empty() && result_fd == NULL) || fd_vector.size() > 1) {
 139     for (std::vector<int>::const_iterator
 140          i = fd_vector.begin(); i != fd_vector.end(); ++i) {
 141       close(*i);
 142     }
 143
 144     NOTREACHED();
 145
 146     return -1;
 147   }
 148
 149   if (result_fd)
 150     *result_fd = fd_vector.empty() ? -1 : fd_vector[0];
 151
 152   return reply_len;
 153 }