TLA  Line data    Source code

       1                 : //
       2                 : // Copyright (c) 2026 Michael Vandeberg
       3                 : //
       4                 : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       5                 : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       6                 : //
       7                 : // Official repository: https://github.com/cppalliance/corosio
       8                 : //
       9                 : 
      10                 : #ifndef BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_TRAITS_HPP
      11                 : #define BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_TRAITS_HPP
      12                 : 
      13                 : #include <boost/corosio/detail/platform.hpp>
      14                 : 
      15                 : #if BOOST_COROSIO_HAS_EPOLL
      16                 : 
      17                 : #include <boost/corosio/native/detail/make_err.hpp>
      18                 : #include <boost/corosio/native/detail/reactor/reactor_descriptor_state.hpp>
      19                 : 
      20                 : #include <system_error>
      21                 : 
      22                 : #include <errno.h>
      23                 : #include <netinet/in.h>
      24                 : #include <sys/socket.h>
      25                 : 
      26                 : /* epoll backend traits.
      27                 : 
      28                 :    Captures the platform-specific behavior of the Linux epoll backend:
      29                 :    atomic SOCK_NONBLOCK|SOCK_CLOEXEC on socket(), accept4() for
      30                 :    accepted connections, and sendmsg(MSG_NOSIGNAL) for writes.
      31                 : */
      32                 : 
      33                 : namespace boost::corosio::detail {
      34                 : 
      35                 : class epoll_scheduler;
      36                 : struct descriptor_state;
      37                 : 
      38                 : struct epoll_traits
      39                 : {
      40                 :     using scheduler_type    = epoll_scheduler;
      41                 :     using desc_state_type   = descriptor_state;
      42                 : 
      43                 :     static constexpr bool needs_write_notification = false;
      44                 : 
      45                 :     /// No extra per-socket state or lifecycle hooks needed for epoll.
      46                 :     struct stream_socket_hook
      47                 :     {
      48 HIT          32 :         std::error_code on_set_option(
      49                 :             int fd, int level, int optname,
      50                 :             void const* data, std::size_t size) noexcept
      51                 :         {
      52              32 :             if (::setsockopt(
      53                 :                     fd, level, optname, data,
      54              32 :                     static_cast<socklen_t>(size)) != 0)
      55 MIS           0 :                 return make_err(errno);
      56 HIT          32 :             return {};
      57                 :         }
      58 MIS           0 :         static void pre_shutdown(int) noexcept {}
      59 HIT       14766 :         static void pre_destroy(int) noexcept {}
      60                 :     };
      61                 : 
      62                 :     struct write_policy
      63                 :     {
      64           99323 :         static ssize_t write(int fd, iovec* iovecs, int count) noexcept
      65                 :         {
      66           99323 :             msghdr msg{};
      67           99323 :             msg.msg_iov    = iovecs;
      68           99323 :             msg.msg_iovlen = static_cast<std::size_t>(count);
      69                 : 
      70                 :             ssize_t n;
      71                 :             do
      72                 :             {
      73           99323 :                 n = ::sendmsg(fd, &msg, MSG_NOSIGNAL);
      74                 :             }
      75           99323 :             while (n < 0 && errno == EINTR);
      76           99323 :             return n;
      77                 :         }
      78                 :     };
      79                 : 
      80                 :     struct accept_policy
      81                 :     {
      82            9808 :         static int do_accept(int fd, sockaddr_storage& peer) noexcept
      83                 :         {
      84            9808 :             socklen_t addrlen = sizeof(peer);
      85                 :             int new_fd;
      86                 :             do
      87                 :             {
      88            9808 :                 new_fd = ::accept4(
      89                 :                     fd, reinterpret_cast<sockaddr*>(&peer), &addrlen,
      90                 :                     SOCK_NONBLOCK | SOCK_CLOEXEC);
      91                 :             }
      92            9808 :             while (new_fd < 0 && errno == EINTR);
      93            9808 :             return new_fd;
      94                 :         }
      95                 :     };
      96                 : 
      97                 :     /// Create a nonblocking, close-on-exec socket using Linux's atomic flags.
      98            5064 :     static int create_socket(int family, int type, int protocol) noexcept
      99                 :     {
     100            5064 :         return ::socket(family, type | SOCK_NONBLOCK | SOCK_CLOEXEC, protocol);
     101                 :     }
     102                 : 
     103                 :     /// Apply protocol-specific options after socket creation.
     104                 :     /// For IP sockets, sets IPV6_V6ONLY on AF_INET6.
     105                 :     static std::error_code
     106            4961 :     configure_ip_socket(int fd, int family) noexcept
     107                 :     {
     108            4961 :         if (family == AF_INET6)
     109                 :         {
     110              13 :             int one = 1;
     111              13 :             ::setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
     112                 :         }
     113            4961 :         return {};
     114                 :     }
     115                 : 
     116                 :     /// Apply protocol-specific options for acceptor sockets.
     117                 :     /// For IP acceptors, sets IPV6_V6ONLY=0 (dual-stack).
     118                 :     static std::error_code
     119              83 :     configure_ip_acceptor(int fd, int family) noexcept
     120                 :     {
     121              83 :         if (family == AF_INET6)
     122                 :         {
     123               8 :             int val = 0;
     124               8 :             ::setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val));
     125                 :         }
     126              83 :         return {};
     127                 :     }
     128                 : 
     129                 :     /// No extra configuration needed for local (unix) sockets on epoll.
     130                 :     static std::error_code
     131              20 :     configure_local_socket(int /*fd*/) noexcept
     132                 :     {
     133              20 :         return {};
     134                 :     }
     135                 : };
     136                 : 
     137                 : } // namespace boost::corosio::detail
     138                 : 
     139                 : #endif // BOOST_COROSIO_HAS_EPOLL
     140                 : 
     141                 : #endif // BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_TRAITS_HPP