Struct netlink_proto::sys::SocketAddr

pub struct SocketAddr(/* private fields */);

The address of a netlink socket

A netlink address is made of two parts: the unicast address of the socket, called port number or PID, and the multicast address called group ID. In this library, we’ve chosen to stick to the “port number” terminology, since PID can be confused with process ID. However, the netlink man page mostly uses PID.

Port number

Sockets in kernel space have 0 as a port number. For sockets opened by a user-space process, the port number can either be assigned by the process itself, or by the kernel. The only constraint is that this port number must be unique: two netlink sockets created by a given process must have a different port number. However, netlinks sockets created by different processes can have the same port number.

Port number assigned by the kernel

One way to set the port number is to let the kernel assign it, by calling Socket::bind with a port number set to 0. The kernel will usually use the process ID as port number for the first netlink socket created by the process, which is why the socket port number is also called PID. For example:

use std::process;
use netlink_sys::{
    protocols::NETLINK_ROUTE,
    SocketAddr, Socket,
};

let mut socket = Socket::new(NETLINK_ROUTE).unwrap();
// The first parameter is the port number. By setting it to 0 we ask the kernel to pick a port for us
let mut addr = SocketAddr::new(0, 0);
socket.bind(&addr).unwrap();
// Retrieve the socket address
socket.get_address(&mut addr).unwrap();
// the socket port number should be equal to the process ID, but there is no guarantee
println!("socket port number = {}, process ID = {}", addr.port_number(), process::id());

let mut socket2 = Socket::new(NETLINK_ROUTE).unwrap();
let mut addr2 = SocketAddr::new(0, 0);
socket2.bind(&addr2).unwrap();
socket2.get_address(&mut addr2).unwrap();
// the unicast address picked by the kernel for the second socket should be different
assert!(addr.port_number() != addr2.port_number());

Note that it’s a little tedious to create a socket address, call bind and then retrive the address with Socket::get_address. To avoid this boilerplate you can use Socket::bind_auto:

use netlink_sys::{protocols::NETLINK_ROUTE, Socket, SocketAddr};
use std::process;

let mut socket = Socket::new(NETLINK_ROUTE).unwrap();
let addr = socket.bind_auto().unwrap();
println!("socket port number = {}", addr.port_number());

Setting the port number manually

The application can also pick the port number by calling Socket::bind with an address with a non-zero port number. However, it must ensure that this number is unique for each socket created. For instance:

use netlink_sys::{protocols::NETLINK_ROUTE, Socket, SocketAddr};
use std::process;

let mut socket = Socket::new(NETLINK_ROUTE).unwrap();
// set the socket port number to 2
let mut addr = SocketAddr::new(2, 0);
socket.bind(&addr).unwrap();
// Retrieve the socket address
socket.get_address(&mut addr).unwrap();
assert_eq!(2, addr.port_number());

// Creating a second socket with the same port number fails
let mut socket2 = Socket::new(NETLINK_ROUTE).unwrap();
let mut addr2 = SocketAddr::new(2, 0);
socket2.bind(&addr2).unwrap_err();

Implementations

impl SocketAddr

pub fn new(port_number: u32, multicast_groups: u32) -> SocketAddr

Create a new socket address for with th

pub fn port_number(&self) -> u32

Get the unicast address of this socket

pub fn multicast_groups(&self) -> u32

Get the multicast groups of this socket

Trait Implementations

impl Clone for SocketAddr

fn clone(&self) -> SocketAddr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SocketAddr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for SocketAddr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for SocketAddr

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SocketAddr

fn eq(&self, other: &SocketAddr) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for SocketAddr

impl Eq for SocketAddr