1  /* Smoke test for MSG_CMSG_CLOEXEC.
       2     Copyright (C) 2021-2023 Free Software Foundation, Inc.
       3     This file is part of the GNU C Library.
       4  
       5     The GNU C Library is free software; you can redistribute it and/or
       6     modify it under the terms of the GNU Lesser General Public
       7     License as published by the Free Software Foundation; either
       8     version 2.1 of the License, or (at your option) any later version.
       9  
      10     The GNU C Library is distributed in the hope that it will be useful,
      11     but WITHOUT ANY WARRANTY; without even the implied warranty of
      12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      13     Lesser General Public License for more details.
      14  
      15     You should have received a copy of the GNU Lesser General Public
      16     License along with the GNU C Library; if not, see
      17     <https://www.gnu.org/licenses/>.  */
      18  
      19  #include <support/xunistd.h>
      20  #include <support/check.h>
      21  #include <sys/socket.h>
      22  #include <sys/un.h>
      23  #include <string.h>
      24  #include <fcntl.h>
      25  
      26  static void
      27  send_fd (int sockfd, int fd)
      28  {
      29    char data[] = "hello";
      30    struct iovec iov = { .iov_base = data, .iov_len = sizeof (data) };
      31  
      32    union
      33    {
      34      struct cmsghdr header;
      35      char bytes[CMSG_SPACE (sizeof (fd))];
      36    } cmsg_storage;
      37  
      38    struct msghdr msg =
      39      {
      40        .msg_iov = &iov,
      41        .msg_iovlen = 1,
      42        .msg_control = cmsg_storage.bytes,
      43        .msg_controllen = sizeof (cmsg_storage)
      44      };
      45  
      46    memset (&cmsg_storage, 0, sizeof (cmsg_storage));
      47  
      48    struct cmsghdr *cmsg = CMSG_FIRSTHDR (&msg);
      49    cmsg->cmsg_level = SOL_SOCKET;
      50    cmsg->cmsg_type = SCM_RIGHTS;
      51    cmsg->cmsg_len = CMSG_LEN (sizeof (fd));
      52    memcpy (CMSG_DATA (cmsg), &fd, sizeof (fd));
      53  
      54    ssize_t nsent = sendmsg (sockfd, &msg, 0);
      55    if (nsent < 0)
      56      FAIL_EXIT1 ("sendmsg (%d): %m", sockfd);
      57    TEST_COMPARE (nsent, sizeof (data));
      58  }
      59  
      60  static int
      61  recv_fd (int sockfd, int flags)
      62  {
      63    char buffer[100];
      64    struct iovec iov = { .iov_base = buffer, .iov_len = sizeof (buffer) };
      65  
      66    union
      67    {
      68      struct cmsghdr header;
      69      char bytes[100];
      70    } cmsg_storage;
      71  
      72    struct msghdr msg =
      73      {
      74        .msg_iov = &iov,
      75        .msg_iovlen = 1,
      76        .msg_control = cmsg_storage.bytes,
      77        .msg_controllen = sizeof (cmsg_storage)
      78      };
      79  
      80    ssize_t nrecv = recvmsg (sockfd, &msg, flags);
      81    if (nrecv < 0)
      82      FAIL_EXIT1 ("recvmsg (%d): %m", sockfd);
      83  
      84    TEST_COMPARE (msg.msg_controllen, CMSG_SPACE (sizeof (int)));
      85    struct cmsghdr *cmsg = CMSG_FIRSTHDR (&msg);
      86    TEST_COMPARE (cmsg->cmsg_level, SOL_SOCKET);
      87    TEST_COMPARE (cmsg->cmsg_type, SCM_RIGHTS);
      88    TEST_COMPARE (cmsg->cmsg_len, CMSG_LEN (sizeof (int)));
      89  
      90    int fd;
      91    memcpy (&fd, CMSG_DATA (cmsg), sizeof (fd));
      92    return fd;
      93  }
      94  
      95  static int
      96  do_test (void)
      97  {
      98    int sockfd[2];
      99    int newfd;
     100    int flags;
     101    int rc = socketpair (AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0, sockfd);
     102    if (rc < 0)
     103      FAIL_EXIT1 ("socketpair: %m");
     104  
     105    send_fd (sockfd[1], STDIN_FILENO);
     106    newfd = recv_fd (sockfd[0], 0);
     107    TEST_VERIFY_EXIT (newfd > 0);
     108    flags = fcntl (newfd, F_GETFD, 0);
     109    TEST_VERIFY_EXIT (flags != -1);
     110    TEST_VERIFY (!(flags & FD_CLOEXEC));
     111    xclose (newfd);
     112  
     113    send_fd (sockfd[1], STDIN_FILENO);
     114    newfd = recv_fd (sockfd[0], MSG_CMSG_CLOEXEC);
     115    TEST_VERIFY_EXIT (newfd > 0);
     116    flags = fcntl (newfd, F_GETFD, 0);
     117    TEST_VERIFY_EXIT (flags != -1);
     118    TEST_VERIFY (flags & FD_CLOEXEC);
     119    xclose (newfd);
     120  
     121    xclose (sockfd[0]);
     122    xclose (sockfd[1]);
     123    return 0;
     124  }
     125  
     126  #include <support/test-driver.c>