Home | History | Annotate | Download | only in embedder 
      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 "mojo/embedder/platform_channel_utils_posix.h"
      6 
      7 #include <sys/socket.h>
      8 #include <sys/uio.h>
      9 #include <unistd.h>
     10 
     11 #include "base/logging.h"
     12 #include "base/posix/eintr_wrapper.h"
     13 #include "build/build_config.h"
     14 
     15 namespace mojo {
     16 namespace embedder {
     17 
     18 // On Linux, |SIGPIPE| is suppressed by passing |MSG_NOSIGNAL| to
     19 // |send()|/|sendmsg()|. (There is no way of suppressing |SIGPIPE| on
     20 // |write()|/|writev().) On Mac, |SIGPIPE| is suppressed by setting the
     21 // |SO_NOSIGPIPE| option on the socket.
     22 //
     23 // Performance notes:
     24 //  - On Linux, we have to use |send()|/|sendmsg()| rather than
     25 //    |write()|/|writev()| in order to suppress |SIGPIPE|. This is okay, since
     26 //    |send()| is (slightly) faster than |write()| (!), while |sendmsg()| is
     27 //    quite comparable to |writev()|.
     28 //  - On Mac, we may use |write()|/|writev()|. Here, |write()| is considerably
     29 //    faster than |send()|, whereas |sendmsg()| is quite comparable to
     30 //    |writev()|.
     31 //  - On both platforms, an appropriate |sendmsg()|/|writev()| is considerably
     32 //    faster than two |send()|s/|write()|s.
     33 //  - Relative numbers (minimum real times from 10 runs) for one |write()| of
     34 //    1032 bytes, one |send()| of 1032 bytes, one |writev()| of 32+1000 bytes,
     35 //    one |sendmsg()| of 32+1000 bytes, two |write()|s of 32 and 1000 bytes, two
     36 //    |send()|s of 32 and 1000 bytes:
     37 //    - Linux: 0.81 s, 0.77 s, 0.87 s, 0.89 s, 1.31 s, 1.22 s
     38 //    - Mac: 2.21 s, 2.91 s, 2.98 s, 3.08 s, 3.59 s, 4.74 s
     39 
     40 // Flags to use with calling |send()| or |sendmsg()| (see above).
     41 #if defined(OS_MACOSX)
     42 const int kSendFlags = 0;
     43 #else
     44 const int kSendFlags = MSG_NOSIGNAL;
     45 #endif
     46 
     47 ssize_t PlatformChannelWrite(PlatformHandle h,
     48                              const void* bytes,
     49                              size_t num_bytes) {
     50   DCHECK(h.is_valid());
     51   DCHECK(bytes);
     52   DCHECK_GT(num_bytes, 0u);
     53 
     54 #if defined(OS_MACOSX)
     55   return HANDLE_EINTR(write(h.fd, bytes, num_bytes));
     56 #else
     57   return send(h.fd, bytes, num_bytes, kSendFlags);
     58 #endif
     59 }
     60 
     61 ssize_t PlatformChannelWritev(PlatformHandle h,
     62                               struct iovec* iov,
     63                               size_t num_iov) {
     64   DCHECK(h.is_valid());
     65   DCHECK(iov);
     66   DCHECK_GT(num_iov, 0u);
     67 
     68 #if defined(OS_MACOSX)
     69   return HANDLE_EINTR(writev(h.fd, iov, static_cast<int>(num_iov)));
     70 #else
     71   struct msghdr msg = {};
     72   msg.msg_iov = iov;
     73   msg.msg_iovlen = num_iov;
     74   return HANDLE_EINTR(sendmsg(h.fd, &msg, kSendFlags));
     75 #endif
     76 }
     77 
     78 ssize_t PlatformChannelSendmsgWithHandles(PlatformHandle h,
     79                                           struct iovec* iov,
     80                                           size_t num_iov,
     81                                           PlatformHandle* platform_handles,
     82                                           size_t num_platform_handles) {
     83   DCHECK(iov);
     84   DCHECK_GT(num_iov, 0u);
     85   DCHECK(platform_handles);
     86   DCHECK_GT(num_platform_handles, 0u);
     87   DCHECK_LE(num_platform_handles, kPlatformChannelMaxNumHandles);
     88 
     89   char cmsg_buf[CMSG_SPACE(kPlatformChannelMaxNumHandles * sizeof(int))];
     90   struct msghdr msg = {};
     91   msg.msg_iov = iov;
     92   msg.msg_iovlen = num_iov;
     93   msg.msg_control = cmsg_buf;
     94   msg.msg_controllen = CMSG_LEN(num_platform_handles * sizeof(int));
     95   struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
     96   cmsg->cmsg_level = SOL_SOCKET;
     97   cmsg->cmsg_type = SCM_RIGHTS;
     98   cmsg->cmsg_len = CMSG_LEN(num_platform_handles * sizeof(int));
     99   for (size_t i = 0; i < num_platform_handles; i++) {
    100     DCHECK(platform_handles[i].is_valid());
    101     reinterpret_cast<int*>(CMSG_DATA(cmsg))[i] = platform_handles[i].fd;
    102   }
    103 
    104   return HANDLE_EINTR(sendmsg(h.fd, &msg, kSendFlags));
    105 }
    106 
    107 bool PlatformChannelSendHandles(PlatformHandle h,
    108                                 PlatformHandle* handles,
    109                                 size_t num_handles) {
    110   DCHECK(handles);
    111   DCHECK_GT(num_handles, 0u);
    112   DCHECK_LE(num_handles, kPlatformChannelMaxNumHandles);
    113 
    114   // Note: |sendmsg()| fails on Mac if we don't write at least one character.
    115   struct iovec iov = {const_cast<char*>(""), 1};
    116   char cmsg_buf[CMSG_SPACE(kPlatformChannelMaxNumHandles * sizeof(int))];
    117   struct msghdr msg = {};
    118   msg.msg_iov = &iov;
    119   msg.msg_iovlen = 1;
    120   msg.msg_control = cmsg_buf;
    121   msg.msg_controllen = CMSG_LEN(num_handles * sizeof(int));
    122   struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
    123   cmsg->cmsg_level = SOL_SOCKET;
    124   cmsg->cmsg_type = SCM_RIGHTS;
    125   cmsg->cmsg_len = CMSG_LEN(num_handles * sizeof(int));
    126   for (size_t i = 0; i < num_handles; i++) {
    127     DCHECK(handles[i].is_valid());
    128     reinterpret_cast<int*>(CMSG_DATA(cmsg))[i] = handles[i].fd;
    129   }
    130 
    131   ssize_t result = HANDLE_EINTR(sendmsg(h.fd, &msg, kSendFlags));
    132   if (result < 1) {
    133     DCHECK_EQ(result, -1);
    134     return false;
    135   }
    136 
    137   for (size_t i = 0; i < num_handles; i++)
    138     handles[i].CloseIfNecessary();
    139   return true;
    140 }
    141 
    142 ssize_t PlatformChannelRecvmsg(PlatformHandle h,
    143                                void* buf,
    144                                size_t num_bytes,
    145                                std::deque<PlatformHandle>* platform_handles) {
    146   DCHECK(buf);
    147   DCHECK_GT(num_bytes, 0u);
    148   DCHECK(platform_handles);
    149 
    150   struct iovec iov = {buf, num_bytes};
    151   char cmsg_buf[CMSG_SPACE(kPlatformChannelMaxNumHandles * sizeof(int))];
    152   struct msghdr msg = {};
    153   msg.msg_iov = &iov;
    154   msg.msg_iovlen = 1;
    155   msg.msg_control = cmsg_buf;
    156   msg.msg_controllen = sizeof(cmsg_buf);
    157 
    158   ssize_t result = HANDLE_EINTR(recvmsg(h.fd, &msg, MSG_DONTWAIT));
    159   if (result < 0)
    160     return result;
    161 
    162   // Success; no control messages.
    163   if (msg.msg_controllen == 0)
    164     return result;
    165 
    166   DCHECK(!(msg.msg_flags & MSG_CTRUNC));
    167 
    168   for (cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); cmsg;
    169        cmsg = CMSG_NXTHDR(&msg, cmsg)) {
    170     if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
    171       size_t payload_length = cmsg->cmsg_len - CMSG_LEN(0);
    172       DCHECK_EQ(payload_length % sizeof(int), 0u);
    173       size_t num_fds = payload_length / sizeof(int);
    174       const int* fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
    175       for (size_t i = 0; i < num_fds; i++) {
    176         platform_handles->push_back(PlatformHandle(fds[i]));
    177         DCHECK(platform_handles->back().is_valid());
    178       }
    179     }
    180   }
    181 
    182   return result;
    183 }
    184 
    185 }  // namespace embedder
    186 }  // namespace mojo
    187