You either pay $20K for an Ethernet diagnostic device - or you program a Raspberry Pi to do it for you! Ever since broadcast hubs went the way of the Dodo and were replaced by smart switches, you don't see everything passing by: if you're not involved in the conversation, you miss things. My favourite diagnostic tool is Ethereal (WireShark) - but it has one huge limitation. ARP, DHCP, ICMP, UDP, TCP, DNS - I understand it all. I've been programming TCP/IP sockets for twenty years. TL DR: How do I 'quarantine' an active, usable Ethernet port from the TCP/IP stack? All the information you need is contained in the sockaddr_ll from the packet you received.This is gonna be a long one (or not - I hope)! It is possible to sidestep a lot of this work when you only wish to reply to incoming packets on the same interface that you received them.
#Raw ethernet packet sender code#
( Example code for this ifindex discovery.) To find out which interfaces exist you can either read /proc/net/devices (more complete if you don’t always have IP addresses) or use the SIOCGIFCONF ioctl. You access this with the SIOCGIFINDEX ioctl, as described in netdevice(7). The most tricky of these is the interface index, which identifies which network interface on the machine should be used to send the data. Sending a raw packet in Linux requires filling in particular fields of the sockaddr_ll as documented in the manpage. Once we have that frame it’s straightforward to decide whether we should reply to it or not. We have to hope that the layout in memory matches the definition of the struct, which is why it’s unsafe. Here, ptr::read takes a pointer and uses it to construct a real RawArpFrame based on that chunk of memory. Our sockaddr_ll was written into directly during the recvfrom() so we can simply use it. I’m using SOCK_RAW so when I receive an ARP packet so this is the information I will end up receiving: /// An ARP packet with ethernet headers still attached # struct RawArpFrame The first includes the ethernet headers in the packet body the second does not. If you’re using the AF_PACKET interface you can choose between SOCK_RAW and SOCK_DGRAM. To send and receive packets the first thing you need is a socket. This is the complete code for the server I’m going to be describing: Opening a Socket I wanted to blog about how I got it working, but since AX.25 is a little obscure I’ve decided to build a basic ARP server using similar code.
#Raw ethernet packet sender how to#
I recently figured out how to make this work for sending and receiving raw AX.25 packets. Clearly Rust’s type checker is not going to be thrilled about this. If you’re receiving from a raw socket then this actually needs to be a pointer to a sockaddr_ll, which is included in libc but is a completely different type from Rust’s point of view. The libc bindings for recvfrom(), for example, require you to pass in a *mut sockaddr. This is not especially ergonomic in Rust. It’s ostensibly a type of sockaddr but it has a different length, different fields, and different parts that are relevant in different situations. It’s documented primarily in the packet(7) manpage and the workhorse of this interface is a struct called sockaddr_ll. Linux has a fiddly but useful C interface for sending and receiving raw network packets.
0 kommentar(er)
