It is fairly easy to create IP, TCP or UDP sockets using boost::asio library. But when it comes to Ethernet sockets for instance, you need to implement boost/asio/basic_raw_socket.hpp
As there are no examples of such a thing over the internet and as I spent a long time before finding the answer, I'll put my work-around in here.
The most helpful resource I found was: AF_NETLINK (netlink) sockets using boost::asio
A raw socket can be opened using the generic::raw_protocol stuff:
std::string ifname("eth1");
typedef boost::asio::generic::raw_protocol raw_protocol_t;
typedef boost::asio::generic::basic_endpoint<raw_protocol_t> raw_endpoint_t;
sockaddr_ll sockaddr;
memset(&sockaddr, 0, sizeof(sockaddr));
sockaddr.sll_family = PF_PACKET;
sockaddr.sll_protocol = htons(ETH_P_ALL);
sockaddr.sll_ifindex = if_nametoindex(ifname.c_str());
sockaddr.sll_hatype = 1;
raw_protocol_t::socket socket(io_service, raw_protocol_t(PF_PACKET, SOCK_RAW))
socket.bind(raw_endpoint_t(&sockaddr, sizeof(sockaddr)));
First thing to do is to create an ethernet protocol based on the basic_raw_socket class. You can modify the protocol (htons(ETH_P_ALL)) and the family (PF_PACKET) fields, depending on the traffic you want to send/receive.
/// Create a link-layer protocol associated with a link-layer endpoint
class ll_protocol
{
public:
/// Obtain an identifier for the type of the protocol.
int type() const
{
return SOCK_RAW;
}
/// Obtain an identifier for the protocol.
int protocol() const
{
return protocol_;
}
/// Obtain an identifier for the protocol family.
int family() const
{
return family_;
}
// Construct with a specific family.
explicit ll_protocol(int protocol, int family) :
protocol_(protocol), family_(family)
{
}
explicit ll_protocol() :
protocol_(htons(ETH_P_ALL)), family_(PF_PACKET)
{
}
typedef boost::asio::basic_raw_socket<ll_protocol> socket;
typedef ll_endpoint<ll_protocol> endpoint;
private:
int protocol_;
int family_;
};
To bind the socket to the interface, an endpoint is required. The key point is to create a sockaddr_ll structure, in which the interface to send/receive traffic can be specified.
#include <net/ethernet.h>
#include <sys/socket.h>
#include <linux/if_packet.h>
#include <cstddef>
template <typename Protocol>
class ll_endpoint
{
private:
sockaddr_ll sockaddr;
public:
/// The protocol type associated with the endpoint.
typedef Protocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
/// Constructor
ll_endpoint(const char* ifname)
{
sockaddr.sll_family = PF_PACKET;
sockaddr.sll_protocol = htons(ETH_P_ALL);
sockaddr.sll_ifindex = if_nametoindex(ifname);
sockaddr.sll_hatype = 1;
}
/// Assign from another endpoint.
ll_endpoint& operator=(const ll_endpoint& other)
{
sockaddr = other.sockaddr;
return *this;
}
/// The protocol associated with the endpoint.
protocol_type protocol() const
{
return protocol_type();
}
/// Get the underlying endpoint in the native type.
data_type* data()
{
return &sockaddr;
}
/// Get the underlying endpoint in the native type.
const data_type* data() const
{
return (struct sockaddr*)&sockaddr;
}
/// Get the underlying size of the endpoint in the native type.
std::size_t size() const
{
return sizeof(sockaddr);
}
/// Set the underlying size of the endpoint in the native type.
void resize(std::size_t size)
{
/* nothing we can do here */
}
/// Get the capacity of the endpoint in the native type.
std::size_t capacity() const
{
return sizeof(sockaddr);
}
/// Compare two endpoints for equality.
friend bool operator==(const ll_endpoint<Protocol>& e1,
const ll_endpoint<Protocol>& e2)
{
return e1.sockaddr == e2.sockaddr;
}
/// Compare two endpoints for inequality.
friend bool operator!=(const ll_endpoint<Protocol>& e1,
const ll_endpoint<Protocol>& e2)
{
return !(e1.sockaddr == e2.sockaddr);
}
/// Compare endpoints for ordering.
friend bool operator<(const ll_endpoint<Protocol>& e1,
const ll_endpoint<Protocol>& e2)
{
return e1.sockaddr < e2.sockaddr;
}
/// Compare endpoints for ordering.
friend bool operator>(const ll_endpoint<Protocol>& e1,
const ll_endpoint<Protocol>& e2)
{
return e2.sockaddr < e1.sockaddr;
}
/// Compare endpoints for ordering.
friend bool operator<=(const ll_endpoint<Protocol>& e1,
const ll_endpoint<Protocol>& e2)
{
return !(e2 < e1);
}
/// Compare endpoints for ordering.
friend bool operator>=(const ll_endpoint<Protocol>& e1,
const ll_endpoint<Protocol>& e2)
{
return !(e1 < e2);
}
};
Finally, you can open the socket and connect to the endpoint as follow:
string ifname("eth1");
ll_protocol::socket socket;
socket.open(ll_protocol());
socket.bind(ll_endpoint<ll_protocol>((const char*)ifname.c_str()));
Here is a demo to capture one packet from loopback device with boost asio raw socket:
#include <iostream>
#include <string>
#include <array>
#include <netpacket/packet.h>
#include <net/ethernet.h>
#include <boost/asio.hpp>
#include <boost/format.hpp>
int main()
{
const std::string port = "lo";
std::array<uint8_t, 20> buffer;
uint bytes_received;
sockaddr_ll sockaddr{0};
sockaddr.sll_family = PF_PACKET;
sockaddr.sll_protocol = htons(ETH_P_ALL);
sockaddr.sll_ifindex = if_nametoindex(port.c_str());
sockaddr.sll_hatype = 1;
boost::asio::io_service ios;
boost::asio::generic::raw_protocol::endpoint endpoint(&sockaddr, sizeof(sockaddr), SOCK_RAW);
boost::asio::generic::raw_protocol::socket socket(ios, endpoint);
socket.non_blocking();
bytes_received = socket.receive(boost::asio::buffer(buffer, buffer.size()));
std::cout << "Received " << bytes_received << " bytes" << std::endl;
std::cout << "Source MAC address: ";
std::cout << boost::format("%02X-%02X-%02X-%02X-%02X-%02X") %
buffer[0] % buffer[1] % buffer[2] %
buffer[3] % buffer[4] % buffer[5];
std::cout << std::endl;
std::cout << "Dest MAC address: ";
std::cout << boost::format("%02X-%02X-%02X-%02X-%02X-%02X") %
buffer[6] % buffer[7] % buffer[8] %
buffer[9] % buffer[10] % buffer[11];
std::cout << std::endl;
return 0;
}
