Snull is the “Simple Network Utility,” a historical Linux sample driver from Linux Device Drivers. It creates two software-only network interfaces, usually sn0 and sn1, and delivers packets sent through one to the other. Snull is a teaching device—not a physical Ethernet driver, a general-purpose virtual NIC, or a production networking component.
What snull actually is
Snull simulates a pair of connected network interfaces inside one Linux machine. Applications and the kernel can treat sn0 and sn1 as separate interfaces, while the sample driver forwards traffic between them in software.
Its purpose is to expose the work a network driver performs: registering a device, accepting transmissions, allocating packet buffers, and handing received packets to Linux networking code. The source file identifies itself as “snull.c — the Simple Network Utility” and credits Alessandro Rubini, Jonathan Corbet, and O’Reilly & Associates in 2001.
How the two-interface simulation works
Traffic crosses from sn0 to sn1
A packet transmitted through one virtual interface is processed by the sample and delivered to the other. This makes the host appear to be communicating with a remote network endpoint even though no physical cable or second computer is involved.
Free tools Windows power users keep installed
One-click scans. No signup required.
#1 Best Overall
It is deliberately not ordinary loopback
Linux loopback normally recognizes traffic addressed to the local host and keeps it within the local stack. Snull changes selected source and destination IP-address bits so the kernel does not immediately treat the destination as one of its own local interface addresses. That forced path makes the driver’s transmit and receive work visible.
Example address networks
The reference design uses two symbolic class-C networks named snullnet0 and snullnet1. Their third octets differ in the least significant bit, and the example’s local and remote addresses are selected so the transformation maps traffic from one virtual side to the other. These values explain the mechanism; they are not a recommended production addressing plan.
Rank #2
What protocols snull supports
Snull is intentionally IP-only. It looks inside packets and rewrites addresses, so non-IP protocols are not transparently carried unless the code is changed. That restriction is useful pedagogically: it keeps the simulation understandable while showing why a real hardware driver should generally avoid assumptions about a particular network-layer protocol.
The Linux driver concepts demonstrated
struct net_device and registration
Each interface is represented by a Linux struct net_device. Registering that structure adds the device to the kernel’s network-device list and makes the interface available to the networking subsystem.
Transmit and receive paths
The simulated transmit path accepts a packet from the networking stack and arranges for it to appear on the paired interface. On reception, snull allocates an sk_buff, fills it with packet data, and passes it upward to the device-independent networking code.
Separating device details from common work
The chapter’s central design lesson is separation: simulated hardware behavior is kept apart from generic network-driver housekeeping. That boundary is valuable when studying how a real driver connects hardware-specific operations to Linux’s common networking infrastructure.
Why old snull code needs caution on modern Linux
The canonical material comes from the second edition of Linux Device Drivers, published in 2001, and the public example uses kernel APIs from that era. Current kernels have changed networking interfaces, module patterns, build requirements, and driver infrastructure. You should therefore treat the sample as a conceptual guide and expect substantial adaptation before attempting to compile it on a current distribution.
- Do not assume the historical source will build unchanged with a contemporary kernel.
- Use an isolated virtual machine or lab system when adapting old kernel-module code.
- Check the target kernel’s current networking-driver documentation and API definitions before replacing deprecated interfaces.
- Keep the original address transformation and IP-only assumptions in mind when interpreting test results.
Snull compared with common alternatives
| Characteristic | Snull |
|---|---|
| Interfaces | Two software interfaces, normally sn0 and sn1 |
| Traffic model | Packets sent through one side are delivered through the other |
| Packet handling | Inspects packets and rewrites selected IP-address bits |
| Protocol scope | IP traffic; non-IP protocols are not transparently supported by the reference design |
| Primary purpose | Instruction in Linux network-driver structure |
| Kernel context | Historical APIs associated with the 2001 second edition of Linux Device Drivers |
| Production status | Not a production NIC driver or a substitute for a maintained virtual networking facility |
This distinction matters when choosing a tool. Snull is valuable for reading and modifying driver code; a modern virtual Ethernet pair, TAP/TUN device, or another maintained facility is generally the more appropriate choice for current networking experiments. Their present-day behavior and API details depend on the operating system and version.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
What you can learn by studying the example
- Device registration: how a module describes a network interface and registers it with the kernel.
- Packet ownership: where an
sk_buffis allocated, populated, and handed to upper layers. - Transmit/receive boundaries: how a driver connects a device-specific path to generic networking code.
- Protocol assumptions: why packet inspection and address rewriting make this simulation unsuitable as a transparent, all-protocol link.
- Abstraction design: how separating simulated hardware behavior from common housekeeping improves comprehension and portability of the design.
Who should use or read snull?
- Kernel learners: readers who need a compact example of network-device registration and packet delivery.
- Driver developers: engineers studying the conceptual boundary between hardware-specific operations and Linux networking code.
- Systems students: readers who want to see why a teaching driver may alter packets instead of behaving like a transparent cable.
It is a poor fit for production connectivity, performance testing, protocol benchmarking, or replacing a maintained virtual interface implementation.
Recommended reference
Linux Device Drivers, 2nd Edition by Jonathan Corbet and Alessandro Rubini gives the complete historical context and dissects the network-driver chapter containing snull. Its treatment remains useful for concepts, but its 2001 API context must be kept in view when working with current kernels.
The Bottom Line
Snull is best understood as a two-interface Linux teaching driver: it uses sn0 and sn1, rewrites selected IP addresses to avoid ordinary local-loopback handling, and demonstrates network-device registration plus transmit and receive paths. Its historical, IP-only design makes it excellent study material—but not a modern production network solution.
