RawSocket Class Reference

#include <RawSocket.hpp>

Collaboration diagram for RawSocket:

Public Member Functions
	RawSocket (std::string iface, bool isWrite=false)
	RawSocket (const RawSocket &)=delete
	Copy constructor.
	RawSocket (RawSocket &&)=delete
	Move constructor.
RawSocket &	operator= (RawSocket)=delete
	Copy assignment operator.
RawSocket &	operator= (RawSocket &&)=delete
	Move assignment operator.
const std::string &	getInterfaceName () const
int	writeData (const unsigned char *data, size_t dataLen)
int	readData (unsigned char *data, size_t dataLen)
RawSocketStats	getStats (bool resetInternalStats=false)
	~RawSocket ()

Private Member Functions
void	init (int domain, int type, int protocol)

Private Attributes
bool	_isReady {false}
	Ready flag.
bool	_writeMode {false}
	Mode indicator. True = Write, False = Read.
int	_sockFd {-1}
	Socket descriptor.
std::string	_iFace
	Currently used ethernet interface.
sockaddr_ll	_addr {}
	Socket structure.
RawSocketStats	_stats {}
	Internal structure for statistics.

Detailed Description

Raw socket reads and writes binary data to the provided interface. Write operations do not modify any field (MAC, IP, etc.). They only write the full data directly, similar to file write operations.

Definition at line 23 of file RawSocket.hpp.

Constructor & Destructor Documentation

RawSocket() [1/3]

RawSocket::RawSocket ( std::string iface, bool isWrite = false )

explicit

Construct a new RawSocket object

Parameters

[in]	iface	Ethernet interface
[in]	isWrite	True if write mode, false if read mode is requested

Definition at line 31 of file RawSocket.cpp.

                                                  : _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));
    memcpy(std::addressof(ifr.ifr_name), _iFace.c_str(),
           _iFace.size()); // Size should be sufficient because if_nametoindex not failed
 
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RawSocket() [2/3]

RawSocket::RawSocket ( const RawSocket & )

delete

Copy constructor.

Here is the call graph for this function:

RawSocket() [3/3]

RawSocket::RawSocket ( RawSocket && )

delete

Move constructor.

Here is the call graph for this function:

~RawSocket()

RawSocket::~RawSocket

(

)

Destroy the RawSocket object

Definition at line 112 of file RawSocket.cpp.

{ close(_sockFd); }

Member Function Documentation

getInterfaceName()

const std::string & RawSocket::getInterfaceName ( ) const

inlinenodiscard

Returns the binded ethernet interface

Returns

std::string Name of the interface

Definition at line 64 of file RawSocket.hpp.

{ return _iFace; }

getStats()

RawSocketStats RawSocket::getStats

(

bool

resetInternalStats = false

)

Get the statistics of the class

Parameters

[in]

resetInternalStats

Whether the internal statistics structure should be reset after being returned

Returns

RawSocketStats Produced statistics

Definition at line 101 of file RawSocket.cpp.

{
    if (resetInternalStats)
    {
        RawSocketStats buffer = _stats;
        _stats = {.sentBytes = 0, .receivedBytes = 0, .processingTime = 0.0};
        return buffer;
    }
    return _stats;
}

init()

void RawSocket::init ( int domain, int type, int protocol )

private

Definition at line 18 of file RawSocket.cpp.

{
    _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));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

RawSocket & RawSocket::operator= ( RawSocket && )

delete

Move assignment operator.

Here is the call graph for this function:

operator=() [2/2]

RawSocket & RawSocket::operator= ( RawSocket )

delete

Copy assignment operator.

Here is the call graph for this function:

readData()

int RawSocket::readData	(	unsigned char *	data,
		size_t	dataLen )

Reads data from the interface

Parameters

[out]	data	User-allocated data
[out]	dataLen	Length of the data

Returns

int Status of the operation. Returns the number of read bytes, negative on errors.

Definition at line 81 of file RawSocket.cpp.

{
    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());
    _stats.receivedBytes += dataLen;
 
    return retval;
}

writeData()

int RawSocket::writeData	(	const unsigned char *	data,
		size_t	dataLen )

Writes data to the interface

Parameters

[in]	data	Full payload data to write
[in]	dataLen	Length of the data

Returns

int Status of the operation. Returns the number of written bytes, negative on errors.

Definition at line 64 of file RawSocket.cpp.

{
    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());
    _stats.sentBytes += dataLen;
 
    return retval;
}

Member Data Documentation

_addr

sockaddr_ll RawSocket::_addr {}

private

Socket structure.

Definition at line 34 of file RawSocket.hpp.

{};

_iFace

std::string RawSocket::_iFace

private

Currently used ethernet interface.

Definition at line 32 of file RawSocket.hpp.

_isReady

bool RawSocket::_isReady {false}

private

Ready flag.

Definition at line 26 of file RawSocket.hpp.

{false};

_sockFd

int RawSocket::_sockFd {-1}

private

Socket descriptor.

Definition at line 30 of file RawSocket.hpp.

{-1};

_stats

RawSocketStats RawSocket::_stats {}

private

Internal structure for statistics.

Definition at line 36 of file RawSocket.hpp.

{};

_writeMode

bool RawSocket::_writeMode {false}

private

Mode indicator. True = Write, False = Read.

Definition at line 28 of file RawSocket.hpp.

{false};

---

The documentation for this class was generated from the following files:

• /__w/Repo-Init/Repo-Init/include/connection/RawSocket.hpp
• /__w/Repo-Init/Repo-Init/src/connection/RawSocket.cpp