8 ip_utils
crate-kit edited this page 2026-11-14 04:11:29 +00:00

pmoutils > ip_utils

Module: ip_utils

Contents

Enums

Functions

  • guess_local_ip - Devine l'adresse IP locale de la machine.
  • list_all_ips - Liste les adresses IP non-loopback des interfaces réseau, de la famille demandée.
  • local_ip_towards - L'adresse IPv4 locale que le système utiliserait comme source pour joindre peer.

pmoutils::ip_utils::IpFamily

Enum

Famille d'adresses IP à retourner par list_all_ips.

Le choix est explicite : aucune famille n'est retournée « par défaut ».

Variants:

  • V4 - Adresses IPv4 uniquement.
  • V6 - Adresses IPv6 uniquement (y compris les adresses locales au lien fe80::/10).
  • Both - Adresses IPv4 et IPv6.

Traits: Copy, Eq

Trait Implementations:

  • PartialEq
    • fn eq(self: &Self, other: &Self) -> bool
  • Clone
    • fn clone(self: &Self) -> Self
  • Hash
    • fn hash<__H>(self: &Self, state: & mut __H)
  • Debug
    • fn fmt(self: &Self, f: & mut $crate::fmt::Formatter) -> $crate::fmt::Result

pmoutils::ip_utils::guess_local_ip

Function

Devine l'adresse IP locale de la machine.

Cette fonction tente de déterminer l'adresse IP locale en créant une connexion UDP vers un serveur DNS public (8.8.8.8). Cette technique permet d'identifier l'interface réseau qui serait utilisée pour communiquer avec Internet.

Fonctionnement

  1. Crée un socket UDP lié à 0.0.0.0:0 (n'importe quelle interface, port aléatoire)
  2. Tente une connexion (non effective pour UDP) vers 8.8.8.8:53 (port DNS standard)
  3. Récupère l'adresse IP locale du socket

Aucun paquet n'est émis : 8.8.8.8 ne sert qu'à interroger la table de routage.

Repli

Sans route vers 8.8.8.8 (LAN isolé, sans passerelle), la fonction ne s'arrête pas là : elle retient la première adresse IPv4 privée (RFC 1918 : 10/8, 172.16/12, 192.168/16) portée par une interface, hors loopback et hors lien local (169.254/16), en parcourant les interfaces par ordre alphabétique de nom. Sur une machine à plusieurs interfaces privées sans route par défaut, ce choix est donc arbitraire mais stable : list_all_ips permet de choisir explicitement.

Returns

L'adresse IPv4 locale de l'interface qui sert de sortie vers Internet ou, à défaut, l'adresse privée de repli décrite ci-dessus.

Errors

Retourne l'erreur de la sonde de routage (socket impossible à créer, aucune route vers 8.8.8.8, adresse obtenue non exploitable) quand le repli ne trouve non plus aucune adresse privée. Il n'y a pas de repli sur 127.0.0.1 : c'est à l'appelant de décider quoi faire sans adresse.

Examples

use pmoutils::guess_local_ip;

match guess_local_ip() {
    Ok(ip) => println!("IP locale détectée: {ip}"), // ex. "192.168.1.42"
    Err(e) => println!("Pas d'adresse locale: {e}"),
}

Note

Cette méthode ne crée pas de véritable connexion réseau (UDP est sans connexion), elle demande simplement au système d'exploitation quelle interface serait utilisée pour joindre l'adresse cible.

Limites

  • Seule une adresse IPv4 est retournée, celle de la route par défaut vers 8.8.8.8. Sur une machine multi-interfaces (VPN, Docker, plusieurs cartes), c'est l'interface de sortie vers Internet, pas forcément celle du réseau local visé par l'appelant : utiliser list_all_ips pour choisir explicitement.
  • L'adresse retournée peut changer d'un appel à l'autre (changement de réseau).
  • Le repli ignore les adresses publiques : une machine dont aucune interface n'a d'adresse privée et qui n'a pas de route par défaut obtient une erreur.
fn guess_local_ip() -> io::Result<std::net::Ipv4Addr>

pmoutils::ip_utils::list_all_ips

Function

Liste les adresses IP non-loopback des interfaces réseau, de la famille demandée.

Parcourt toutes les interfaces réseau de la machine et collecte leurs adresses, en excluant les adresses de loopback (127.0.0.0/8, ::1). Utile pour choisir une interface sur une machine qui en a plusieurs (VPN, Docker, plusieurs cartes), là où guess_local_ip ne retourne que celle de la route par défaut.

Arguments

  • family - Famille d'adresses retournées : IpFamily::V4, IpFamily::V6 ou IpFamily::Both

Returns

Une table triée par nom d'interface où :

  • Clé : nom de l'interface réseau (ex: "eth0", "wlan0", "en0")
  • Valeur : adresses de cette interface dans la famille demandée, triées et sans doublon

Une interface qui n'a aucune adresse de la famille demandée est absente de la table. Une machine sans adresse correspondante retourne donc une table vide, ce qui n'est pas une erreur.

Errors

Retourne l'erreur d'entrée/sortie du système si la liste des interfaces ne peut pas être lue.

Examples

use pmoutils::ip_utils::{list_all_ips, IpFamily};

let ips = list_all_ips(IpFamily::V4).expect("interfaces illisibles");
for (interface, addresses) in &ips {
    println!("Interface {}: {:?}", interface, addresses);
}
// Affiche par exemple:
// Interface en0: [192.168.1.42]
// Interface eth0: [10.0.0.15]

Limites

  • Les adresses IPv6 locales au lien (fe80::/10) sont retournées avec les autres : filtrer côté appelant si elles ne conviennent pas.
  • L'interface, pas l'état du lien : une interface déconnectée qui garde une adresse configurée est listée.
fn list_all_ips(family: IpFamily) -> io::Result<std::collections::BTreeMap<String, Vec<std::net::IpAddr>>>

pmoutils::ip_utils::local_ip_towards

Function

L'adresse IPv4 locale que le système utiliserait comme source pour joindre peer.

C'est la bonne réponse à « quelle adresse donner à ce pair pour qu'il me rappelle ? » : sur une machine à plusieurs interfaces (Ethernet et Wi-Fi, VPN, Docker), l'adresse dépend du pair, et elle est forcément sur le sous-réseau par lequel il est joint. Là où guess_local_ip répond « par où je sors vers Internet ? », cette fonction répond pour le pair visé.

Errors

Socket impossible à créer, aucune route vers peer (réseau injoignable), ou adresse obtenue non exploitable. Il n'y a pas de repli : c'est à l'appelant de décider quoi faire sans adresse.

Note

Rien n'est émis : UDP est sans connexion, connect interroge seulement la table de routage.

Examples

use std::net::Ipv4Addr;
use pmoutils::ip_utils::local_ip_towards;

// Le pair n'est jamais contacté ; sans route, l'appel échoue.
match local_ip_towards(Ipv4Addr::new(192, 0, 2, 10)) {
    Ok(ip) => println!("source vers ce pair : {ip}"),
    Err(e) => println!("pas de route : {e}"),
}
fn local_ip_towards(peer: std::net::Ipv4Addr) -> io::Result<std::net::Ipv4Addr>