https://github.com/al8n/getifs

A bunch of cross platform network tools for fetching interfaces, multicast addresses, local ip addresses, private ip addresses, public ip addresses and etc.
https://github.com/al8n/getifs

getifaddrs network-interface network-interfaces rust

Last synced: about 2 months ago
JSON representation

A bunch of cross platform network tools for fetching interfaces, multicast addresses, local ip addresses, private ip addresses, public ip addresses and etc.

Host: GitHub
URL: https://github.com/al8n/getifs
Owner: al8n
License: apache-2.0
Created: 2025-01-01T11:04:04.000Z (over 1 year ago)
Default Branch: main
Last Pushed: 2025-07-29T00:29:35.000Z (10 months ago)
Last Synced: 2025-07-30T09:49:54.990Z (10 months ago)
Topics: getifaddrs, network-interface, network-interfaces, rust
Language: Rust
Homepage:
Size: 88.9 KB
Stars: 21
Watchers: 1
Forks: 3
Open Issues: 2
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Funding: .github/FUNDING.yml
- License: LICENSE-APACHE

Awesome Lists containing this project

README

          


GetIfs





Cross-platform enumeration of network interfaces and their MTU, gateway, multicast, and local/private/public IP addresses — with a libc-free netlink backend on Linux and no getifaddrs dependency.

[][Github-url]



[][CI-url]

[][codecov-url]

[][doc-url]

[][crates-url]

[][crates-url]





## Installation

```toml

[dependencies]

getifs = "0.5"

```

## Features

- **Zero libc dependency** on Linux (uses netlink directly)

- **MTU information** - Get interface MTU values

- **Multicast addresses** - Fetch multicast group memberships

- **Gateway discovery** - Find IPv4 and IPv6 gateway addresses

- **RFC-based filtering** - Filter addresses by RFC classification

- **High performance** - Up to 189x faster than alternatives on macOS (see benchmarks)

- **Cross-platform** - Linux, macOS, BSD, Windows support

## Quick Start

```rust

use getifs::{interfaces, local_addrs, gateway_addrs};

// Get all network interfaces

let interfaces = interfaces().unwrap();

for interface in interfaces {

    println!("Interface: {} (index: {})", interface.name(), interface.index());

    println!("  MTU: {}", interface.mtu());

    println!("  Flags: {:?}", interface.flags());

}

// Get local IP addresses

let local_ips = local_addrs().unwrap();

for ip in local_ips {

    println!("Local IP: {}", ip);

}

// Get gateway addresses

let gateways = gateway_addrs().unwrap();

for gateway in gateways {

    println!("Gateway: {}", gateway);

}

```

## Examples

- Fetching all interfaces: [examples/interfaces.rs](./examples/interfaces.rs)

- Fetching all interface addresses (excluding multicast addrs): [examples/addrs.rs](./examples/addrs.rs)

- Fetching all interface multicast addresses: [examples/multicast_addrs.rs](./examples/multicast_addrs.rs)

- Fetching gateway addresses: [examples/gateway.rs](./examples/gateway.rs)

- Fetching local ip addresses: [examples/local_ip_addrs.rs](./examples/local_ip_addrs.rs)

- Fetching ip addresses by RFC: [examples/filter_by_rfc.rs](./examples/filter_by_rfc.rs)

## Details

OS | Approach

--- | ---

Linux (no `libc`) | `socket(AF_NETLINK, SOCK_RAW \| SOCK_CLOEXEC, NETLINK_ROUTE)`

BSD-like | `sysctl`

Windows | `GetAdaptersAddresses`

## Why `getifs`?

Existing network interface crates have limitations:

- **Missing features**: Most don't support MTU or multicast addresses

- **Performance overhead**: Nearly all use `libc::getifaddrs`, which is slower

- **Unnecessary allocations**: Heavy use of heap allocations for simple queries

`getifs` addresses these by:

- Using platform-native APIs directly (netlink, sysctl, GetAdaptersAddresses)

- Minimizing allocations with `SmallVec` and `SmolStr`

- Providing comprehensive interface information including MTU and multicast support

- Achieving **significantly better performance** than alternatives:

  - **Up to 189x faster** on macOS (`interface_by_index`)

  - **Up to 37x faster** on macOS (list interfaces)

  - **2.4–2.8x faster** on Linux (interface enumeration)

  - **~7x faster** local-IP lookup on Linux

  - Comparable performance on Windows (`GetAdaptersAddresses` overhead dominates)

## Roadmap

- [ ] Support fetching routing tables

## Benchmarks

All benchmarks are run with [Criterion.rs](https://github.com/bheisler/criterion.rs) on GitHub Actions. Lower is better.

> **Note**: Automated benchmarks run on Linux, macOS, and Windows via GitHub Actions. View the latest results in the [Actions tab](https://github.com/al8n/getifs/actions/workflows/benchmark.yml) or see [benchmark documentation](.github/BENCHMARKS.md) for more details.

### Performance Summary

Numbers below compare `getifs` against `network-interface 2` and

`local-ip-address 0.6`. Each row reports median `cargo bench` time

(Criterion, 100 samples).

- **macOS (Apple M4 Pro)** — measured on a bare-metal laptop, not CI.

  The GitHub Actions macOS runners are shared virtual machines with

  highly variable latency (run-to-run wobble of ±30% on these ops),

  which obscures the real cost difference.

- **Linux (x64) / Windows (x64)** — measured on GitHub Actions

  `ubuntu-latest` / `windows-latest` runners on 2026-04-15 03:34 UTC.

| Platform | Best Operation | `getifs` | Alternative | Speedup |

|----------|----------------|----------|-------------|---------|

| **macOS** (Apple M4 Pro) | Get interface by index | 1.7 μs | 314.2 μs | **189x faster** |

| **macOS** (Apple M4 Pro) | List all interfaces | 8.4 μs | 313.0 μs | **37x faster** |

| **Linux** (x64) | Local IPv4 lookup | 13.7 μs | 94.3 μs | **6.9x faster** |

| **Linux** (x64) | List all interfaces | 41.5 μs | 111.7 μs | **2.7x faster** |

| **Windows** (x64) | Gateway IPv4 | 30.2 μs | N/A | Unique feature |

### Detailed Results

#### Interface Operations

**macOS (Apple M4 Pro, 24 GB, local bare-metal)**

| Operation | `getifs` | Alternative | Speedup |

|-----------|----------|-------------|---------|

| List all interfaces | 8.4 μs | 313.0 μs (`network-interface`) | **37x faster** |

| Get interface by index | 1.7 μs | 314.2 μs (`network-interface`) | **189x faster** |

| Get interface by name | 10.4 μs | 314.1 μs (`network-interface`) | **30x faster** |

| Get interface addresses | 8.4 μs | - | - |

| Get multicast addresses | 2.9 μs | - | - |

**Linux (GitHub Actions x64)**

| Operation | `getifs` | Alternative | Speedup |

|-----------|----------|-------------|---------|

| List all interfaces | 41.5 μs | 111.7 μs (`network-interface`) | **2.7x faster** |

| Get interface by index | 40.3 μs | 111.9 μs (`network-interface`) | **2.8x faster** |

| Get interface by name | 46.1 μs | 111.9 μs (`network-interface`) | **2.4x faster** |

| Get interface addresses | 17.3 μs | - | - |

| Get multicast addresses | 31.4 μs | - | - |

**Windows (GitHub Actions x64)**

| Operation | `getifs` | Alternative | Notes |

|-----------|----------|-------------|-------|

| List all interfaces | 974 μs | 967 μs (`network-interface`) | Within noise |

| Get interface by index | 954 μs | 976 μs (`network-interface`) | Within noise |

| Get interface by name | 1011 μs | 969 μs (`network-interface`) | Within noise |

| Get interface addresses | 958 μs | - | - |

| Get multicast addresses | 966 μs | - | - |

*Note: the Win32 `GetAdaptersAddresses` API has an inherent ~1 ms floor

that dominates every implementation — `getifs` and `network-interface`

end up within measurement noise of each other on Windows.*

#### Local IP Address Operations

**macOS (Apple M4 Pro, 24 GB, local bare-metal)**

| Operation | `getifs` | Alternative | Speedup |

|-----------|----------|-------------|---------|

| Get local IPv4 address | 6.5 μs | 9.8 μs (`local-ip-address`) | **1.5x faster** |

| Get local IPv6 address | 7.9 μs | 9.8 μs (`local-ip-address`) | **1.2x faster** |

**Linux (GitHub Actions x64)**

| Operation | `getifs` | Alternative | Speedup |

|-----------|----------|-------------|---------|

| Get local IPv4 address | 13.7 μs | 94.3 μs (`local-ip-address`) | **6.9x faster** |

| Get local IPv6 address | 11.2 μs | - | No IPv6 result from alternative |

**Windows (GitHub Actions x64)**

| Operation | `getifs` | Alternative | Notes |

|-----------|----------|-------------|-------|

| Get local IPv4 address | 963 μs | 919 μs (`local-ip-address`) | Win32 ~1 ms floor |

| Get local IPv6 address | 992 μs | 972 μs (`local-ip-address`) | Win32 ~1 ms floor |

#### Gateway Operations

| Platform | IPv4 Gateways | IPv6 Gateways | All Gateways |

|----------|---------------|---------------|--------------|

| **macOS** (M4 Pro, local) | 17.5 μs | 2.4 μs | 19.8 μs |

| **Linux** (x64, CI) | 18.4 μs | 14.3 μs | 22.4 μs |

| **Windows** (x64, CI) | 30.2 μs | 18.0 μs | 48.5 μs |

*Note: No direct alternatives available for gateway discovery, so these

are reported as absolute times rather than as speedups.*

**Why is `getifs` faster?**

- **Direct system calls**: Uses platform-native APIs (netlink on Linux, sysctl on BSD/macOS, GetAdaptersAddresses on Windows)

- **Zero-copy parsing**: Minimal allocations and efficient buffer reuse

- **No libc dependency** on Linux: Direct netlink socket communication

- **Optimized data structures**: Uses `SmallVec` and `SmolStr` to avoid heap allocations for common cases

**Platform Performance Notes:**

- **macOS**: Shows the largest speedups (30–189x on bare metal) due to

  the efficient sysctl-based implementation avoiding `getifaddrs`'s

  per-call overhead. On shared CI runners the absolute numbers are

  noisier but the ordering holds.

- **Linux**: 2.4–2.8x faster interface enumeration via direct netlink,

  and ~7x faster local-IP lookup from avoiding the test-socket round

  trip that `local-ip-address` performs.

- **Windows**: Similar performance to alternatives — `GetAdaptersAddresses`

  has an inherent ~1 ms floor that dominates every implementation.

## Sister crates

- [`iprobe`](https://github.com/al8n/iprobe): Probe if the host system supports IPv4, IPv6 and IPv4-mapped-IPv6.

- [`iprfc`](https://github.com/al8n/iprfc): Known RFCs for IP addresses.

## Pedigree

- The code in this crate is inspired by Golang's `interface.go` and [HashiCorp's go-sockaddr](https://github.com/hashicorp/go-sockaddr).

#### License

`getifs` is under the terms of both the MIT license and the

Apache License (Version 2.0).

See [LICENSE-APACHE](LICENSE-APACHE), [LICENSE-MIT](LICENSE-MIT) for details.

Copyright (c) 2026 Al Liu.

[Github-url]: https://github.com/al8n/getifs/

[CI-url]: https://github.com/al8n/getifs/actions/workflows/ci.yml

[doc-url]: https://docs.rs/getifs

[crates-url]: https://crates.io/crates/getifs

[codecov-url]: https://app.codecov.io/gh/al8n/getifs/

ecosyste.ms

Data

Tools

Indexes

Applications

Experiments

Awesome

https://github.com/al8n/getifs

Awesome Lists containing this project

README

GetIfs