RawSocket.cpp

Go to the documentation of this file.

#include "connection/RawSocket.hpp"
 
#include "utils/ErrorHelpers.hpp"
 
#include <algorithm>
#include <chrono>
#include <cstring>
#include <format>
#include <ios>
#include <iterator>
#include <stdexcept>
#include <utility>
 
#include <net/ethernet.h>
#include <net/if.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
 
void RawSocket::init(int domain, int type, int protocol)
{
    _sockFd = socket(domain, type, protocol); // Init socket
    if (_sockFd < 0)
    {
        throw std::ios_base::failure(getErrnoString(errno));
    }
    if (bind(_sockFd, std::bit_cast<sockaddr *>(&_addr), sizeof(_addr)) < 0)
    {
        throw std::ios_base::failure(std::string("Bind failed: ") + getErrnoString(errno));
    }
}
 
RawSocket::RawSocket(std::string iface, bool isWrite) : _writeMode(isWrite), _iFace(std::move(iface))
{
    // Prepare socket address
    memset(static_cast<void *>(&_addr), 0, sizeof(sockaddr_ll));
    _addr.sll_family = AF_PACKET;
    _addr.sll_protocol = htons(ETH_P_ALL);
    _addr.sll_ifindex = static_cast<int>(if_nametoindex(_iFace.c_str()));
    if (_addr.sll_ifindex == 0)
    {
        throw std::ios_base::failure(std::string("Can't find interface: ") + getErrnoString(errno));
    }
 
    // Interface request
    ifreq ifr{};
    memset(static_cast<void *>(&ifr), 0, sizeof(ifreq));
    const auto maxIfaceNameLen = static_cast<size_t>(IFNAMSIZ - 1);
    const size_t ifaceNameLen = _iFace.size() < maxIfaceNameLen ? _iFace.size() : maxIfaceNameLen;
    auto *const ifaceNameBegin = std::begin(ifr.ifr_name);
    std::copy_n(_iFace.begin(), ifaceNameLen, ifaceNameBegin);
    *std::next(ifaceNameBegin, static_cast<std::ptrdiff_t>(ifaceNameLen)) = '\0';
 
    if (isWrite)
    {
        init(PF_PACKET, SOCK_RAW, IPPROTO_RAW);
        if (setsockopt(_sockFd, SOL_SOCKET, SO_BINDTODEVICE, static_cast<void *>(&ifr), sizeof(ifr)) < 0)
        {
            throw std::ios_base::failure(std::string("Can't set socket options: ") + getErrnoString(errno));
        }
    }
    else
    {
        init(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    }
    _isReady = true;
}
 
int RawSocket::writeData(const unsigned char *data, size_t dataLen)
{
    if (!_isReady || !_writeMode)
    {
        return -EPERM;
    }
 
    auto startTime = std::chrono::high_resolution_clock::now();
    const auto retval = static_cast<int>(write(_sockFd, data, dataLen));
 
    // Update stats
    _stats.processingTime += static_cast<double>((std::chrono::high_resolution_clock::now() - startTime).count());
    if (retval > 0)
    {
        _stats.sentBytes += static_cast<size_t>(retval);
    }
 
    return retval;
}
 
int RawSocket::readData(unsigned char *data, size_t dataLen)
{
    if (!_isReady || _writeMode)
    {
        return -EPERM;
    }
    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
    socklen_t socketLen = sizeof(_addr);
 
    auto startTime = std::chrono::high_resolution_clock::now();
    const auto retval =
        static_cast<int>(recvfrom(_sockFd, data, dataLen, 0, std::bit_cast<sockaddr *>(&_addr), &socketLen));
 
    // Update stats
    _stats.processingTime += static_cast<double>((std::chrono::high_resolution_clock::now() - startTime).count());
    if (retval > 0)
    {
        _stats.receivedBytes += static_cast<size_t>(retval);
    }
 
    return retval;
}
 
RawSocketStats RawSocket::getStats(bool resetInternalStats)
{
    if (resetInternalStats)
    {
        RawSocketStats buffer = _stats;
        _stats = {.sentBytes = 0, .receivedBytes = 0, .processingTime = 0.0};
        return buffer;
    }
    return _stats;
}
 
RawSocket::~RawSocket() { close(_sockFd); }