raw_socket.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_RAW_SOCKET_HPP
#define JOIN_CORE_RAW_SOCKET_HPP
 
// libjoin.
#include <join/socket.hpp>
 
// C.
#include <netinet/tcp.h>
#include <sys/ioctl.h>
 
namespace join
{
    template <class Protocol>
    class BasicRawSocket : public BasicSocket<Protocol>
    {
    public:
        using Ptr = std::unique_ptr<BasicRawSocket<Protocol>>;
        using Mode = typename BasicSocket<Protocol>::Mode;
        using State = typename BasicSocket<Protocol>::State;
        using Endpoint = typename Protocol::Endpoint;
 
        enum Option
        {
            NoDelay,         
            KeepAlive,       
            KeepIdle,        
            KeepIntvl,       
            KeepCount,       
            SndBuffer,       
            RcvBuffer,       
            TimeStamp,       
            ReuseAddr,       
            ReusePort,       
            Broadcast,       
            Ttl,             
            MulticastLoop,   
            MulticastTtl,    
            PathMtuDiscover, 
            RcvError,        
            AuxData,         
        };
 
        BasicRawSocket () noexcept
        : BasicRawSocket (Mode::NonBlocking)
        {
        }
 
        explicit BasicRawSocket (Mode mode) noexcept
        : BasicSocket<Protocol> (mode)
        {
        }
 
        BasicRawSocket (const BasicRawSocket& other) = delete;
 
        BasicRawSocket& operator= (const BasicRawSocket& other) = delete;
 
        BasicRawSocket (BasicRawSocket&& other) noexcept = default;
 
        BasicRawSocket& operator= (BasicRawSocket&& other) noexcept = default;
 
        virtual ~BasicRawSocket () = default;
 
        int bind (const Endpoint& endpoint) noexcept override
        {
            if ((this->_state == State::Closed) && (this->open (endpoint.protocol ()) == -1))
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            if (endpoint.protocol ().family () == AF_PACKET)
            {
                if (reinterpret_cast<const struct sockaddr_ll*> (endpoint.addr ())->sll_ifindex == 0)
                {
                    lastError = std::make_error_code (std::errc::no_such_device);
                    return -1;
                }
            }
            else if ((endpoint.protocol ().family () == AF_INET6) || (endpoint.protocol ().family () == AF_INET))
            {
                setOption (Option::ReuseAddr, 1);
            }
            else if (endpoint.protocol ().family () == AF_UNIX)
            {
                ::unlink (endpoint.device ().c_str ());
            }
 
            return BasicSocket<Protocol>::bind (endpoint);
        }
 
        int bindToDevice (const std::string& device) noexcept
        {
            if (this->_state == State::Closed)
            {
                lastError = make_error_code (Errc::ConnectionClosed);
                return -1;
            }
 
            if (this->_state == State::Connected)
            {
                lastError = make_error_code (Errc::InUse);
                return -1;
            }
 
            if ((this->family () == AF_INET6) || (this->family () == AF_INET))
            {
                setOption (Option::ReuseAddr, 1);
            }
 
            int result = ::setsockopt (this->_handle, SOL_SOCKET, SO_BINDTODEVICE, device.c_str (), device.size ());
            if (result == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
            }
 
            return 0;
        }
 
        ssize_t canRead () const noexcept
        {
            int available = 0;
 
            // check if data can be read in the socket internal buffer.
            if (::ioctl (this->_handle, FIONREAD, &available) == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
            }
 
            return available;
        }
 
        ssize_t read (char* data, size_t maxSize) noexcept
        {
            struct iovec iov;
            iov.iov_base = data;
            iov.iov_len = maxSize;
 
            struct msghdr message;
            message.msg_name = nullptr;
            message.msg_namelen = 0;
            message.msg_iov = &iov;
            message.msg_iovlen = 1;
            message.msg_control = nullptr;
            message.msg_controllen = 0;
 
            ssize_t size = ::recvmsg (this->_handle, &message, 0);
            if (size == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
            }
 
            if (message.msg_flags & MSG_TRUNC)
            {
                lastError = make_error_code (Errc::MessageTooLong);
                return -1;
            }
 
            return size;
        }
 
        ssize_t write (const char* data, size_t maxSize) noexcept
        {
            struct iovec iov;
            iov.iov_base = const_cast<char*> (data);
            iov.iov_len = maxSize;
 
            struct msghdr message;
            message.msg_name = nullptr;
            message.msg_namelen = 0;
            message.msg_iov = &iov;
            message.msg_iovlen = 1;
            message.msg_control = nullptr;
            message.msg_controllen = 0;
 
            ssize_t result = ::sendmsg (this->_handle, &message, 0);
            if (result == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
            }
 
            return result;
        }
 
        virtual int setOption (Option option, int value) noexcept
        {
            int optlevel, optname;
 
            switch (option)
            {
                case Option::KeepAlive:
                    optlevel = SOL_SOCKET;
                    optname = SO_KEEPALIVE;
                    break;
 
                case Option::SndBuffer:
                    optlevel = SOL_SOCKET;
                    optname = SO_SNDBUF;
                    break;
 
                case Option::RcvBuffer:
                    optlevel = SOL_SOCKET;
                    optname = SO_RCVBUF;
                    break;
 
                case Option::TimeStamp:
                    optlevel = SOL_SOCKET;
                    optname = SO_TIMESTAMP;
                    break;
 
                case Option::ReuseAddr:
                    optlevel = SOL_SOCKET;
                    optname = SO_REUSEADDR;
                    break;
 
                case Option::ReusePort:
                    optlevel = SOL_SOCKET;
                    optname = SO_REUSEPORT;
                    break;
 
                case Option::Broadcast:
                    optlevel = SOL_SOCKET;
                    optname = SO_BROADCAST;
                    break;
 
                case Option::AuxData:
                    optlevel = SOL_PACKET;
                    optname = PACKET_AUXDATA;
                    break;
 
                case Option::Ttl:
                    if (this->family () == AF_INET6)
                    {
                        optlevel = IPPROTO_IPV6;
                        optname = IPV6_UNICAST_HOPS;
                    }
                    else
                    {
                        optlevel = IPPROTO_IP;
                        optname = IP_TTL;
                    }
                    break;
 
                case Option::MulticastLoop:
                    if (this->family () == AF_INET6)
                    {
                        optlevel = IPPROTO_IPV6;
                        optname = IPV6_MULTICAST_LOOP;
                    }
                    else
                    {
                        optlevel = IPPROTO_IP;
                        optname = IP_MULTICAST_LOOP;
                    }
                    break;
 
                case Option::MulticastTtl:
                    if (this->family () == AF_INET6)
                    {
                        optlevel = IPPROTO_IPV6;
                        optname = IPV6_MULTICAST_HOPS;
                    }
                    else
                    {
                        optlevel = IPPROTO_IP;
                        optname = IP_MULTICAST_TTL;
                    }
                    break;
 
                case Option::PathMtuDiscover:
                    if (this->family () == AF_INET6)
                    {
                        optlevel = IPPROTO_IPV6;
                        optname = IPV6_MTU_DISCOVER;
                    }
                    else
                    {
                        optlevel = IPPROTO_IP;
                        optname = IP_MTU_DISCOVER;
                    }
                    break;
 
                case Option::RcvError:
                    if (this->family () == AF_INET6)
                    {
                        optlevel = IPPROTO_IPV6;
                        optname = IPV6_RECVERR;
                    }
                    else
                    {
                        optlevel = IPPROTO_IP;
                        optname = IP_RECVERR;
                    }
                    break;
 
                default:
                    lastError = make_error_code (Errc::InvalidParam);
                    return -1;
            }
 
            int result = ::setsockopt (this->_handle, optlevel, optname, &value, sizeof (value));
            if (result == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
            }
 
            return 0;
        }
    };
}
 
#endif