use std::io;
use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
use std::time::Duration;
use fast_talker::nic;
use crate::clock::Instant;
use crate::error::{CameraError, Result};
use crate::gige::proto::bootstrap::DeviceInfo;
use crate::gige::proto::gvcp::{self, Ack};
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct NetworkAdapter {
pub name: String,
pub ip: Ipv4Addr,
pub netmask: Ipv4Addr,
pub broadcast: Ipv4Addr,
}
pub fn enumerate_adapters() -> io::Result<Vec<NetworkAdapter>> {
let mut out = Vec::new();
for iface in nic::interfaces()? {
if !iface.up || iface.loopback {
continue;
}
for a in &iface.addresses {
let (IpAddr::V4(ip), IpAddr::V4(netmask)) = (a.ip, a.netmask()) else {
continue;
};
if ip.is_unspecified() {
continue;
}
let broadcast = a
.broadcast
.unwrap_or_else(|| Ipv4Addr::from(u32::from(ip) | !u32::from(netmask)));
out.push(NetworkAdapter {
name: iface.name.clone(),
ip,
netmask,
broadcast,
});
}
}
Ok(out)
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DiscoveryConfig {
pub adapters: Option<Vec<NetworkAdapter>>,
pub recv_window: Duration,
pub limited_broadcast: bool,
pub source_port: u16,
pub device_port: u16,
}
impl Default for DiscoveryConfig {
fn default() -> Self {
Self {
adapters: None,
recv_window: Duration::from_secs(1),
limited_broadcast: true,
source_port: 0,
device_port: gvcp::GVCP_PORT,
}
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DiscoveredDevice {
pub info: DeviceInfo,
pub from: SocketAddr,
pub adapter: NetworkAdapter,
}
pub fn discover(cfg: &DiscoveryConfig) -> Result<Vec<DiscoveredDevice>> {
let adapters = match &cfg.adapters {
Some(a) => a.clone(),
None => enumerate_adapters()?,
};
let beacon = gvcp::encode_discovery(true);
let mut sockets = Vec::new();
for adapter in adapters {
let socket = match open_adapter_socket(&adapter, cfg.source_port) {
Ok(s) => s,
Err(e) => {
tracing::warn!("discovery: skipping {} ({}): {e}", adapter.name, adapter.ip);
continue;
}
};
let mut sent = false;
for dest in beacon_destinations(&adapter, cfg.limited_broadcast, cfg.device_port) {
match socket.send_to(&beacon, dest) {
Ok(_) => sent = true,
Err(e) => tracing::trace!("discovery: send to {dest} failed: {e}"),
}
}
if sent {
sockets.push((adapter, socket));
}
}
if sockets.is_empty() {
return Err(CameraError::Io(io::Error::new(
io::ErrorKind::AddrNotAvailable,
"no usable network adapter for discovery",
)));
}
let mut found: Vec<DiscoveredDevice> = Vec::new();
let deadline = Instant::now() + cfg.recv_window;
let mut buf = [0u8; 0xffff];
loop {
let now = Instant::now();
if now >= deadline {
break;
}
for (adapter, socket) in &sockets {
socket
.set_read_timeout(Some(Duration::from_millis(20)))
.ok();
let (n, from) = match socket.recv_from(&mut buf) {
Ok(v) => v,
Err(ref e)
if e.kind() == io::ErrorKind::WouldBlock
|| e.kind() == io::ErrorKind::TimedOut =>
{
continue;
}
Err(e) => {
tracing::trace!("discovery: recv on {} failed: {e}", adapter.name);
continue;
}
};
let Some(device) = parse_discovery_ack(&buf[..n], from, adapter) else {
continue;
};
if !found.iter().any(|d| d.info.mac == device.info.mac) {
found.push(device);
}
}
}
tracing::debug!(devices = found.len(), "discovery finished");
Ok(found)
}
fn beacon_destinations(adapter: &NetworkAdapter, limited: bool, port: u16) -> Vec<SocketAddr> {
let mut dests = vec![SocketAddr::new(adapter.broadcast.into(), port)];
if limited && adapter.broadcast != Ipv4Addr::BROADCAST {
dests.push(SocketAddr::new(Ipv4Addr::BROADCAST.into(), port));
}
dests
}
fn open_adapter_socket(adapter: &NetworkAdapter, source_port: u16) -> io::Result<UdpSocket> {
let socket = UdpSocket::bind(SocketAddr::new(adapter.ip.into(), source_port))?;
socket.set_broadcast(true)?;
Ok(socket)
}
fn parse_discovery_ack(
datagram: &[u8],
from: SocketAddr,
adapter: &NetworkAdapter,
) -> Option<DiscoveredDevice> {
let ack = Ack::parse(datagram)?;
if ack.answer != gvcp::DISCOVERY_ACK || ack.status.is_error() {
return None;
}
let info = DeviceInfo::parse(ack.payload)?;
Some(DiscoveredDevice {
info,
from,
adapter: adapter.clone(),
})
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ForceIpConfig {
pub discovery: DiscoveryConfig,
pub ack_window: Duration,
}
impl Default for ForceIpConfig {
fn default() -> Self {
Self {
discovery: DiscoveryConfig::default(),
ack_window: Duration::from_secs(1),
}
}
}
pub fn force_ip(
mac: [u8; 6],
ip: Ipv4Addr,
mask: Ipv4Addr,
gateway: Ipv4Addr,
cfg: &ForceIpConfig,
) -> Result<bool> {
let adapters = match &cfg.discovery.adapters {
Some(a) => a.clone(),
None => enumerate_adapters()?,
};
let packet = gvcp::encode_force_ip(mac, ip, mask, gateway, 1);
let mut sockets = Vec::new();
for adapter in adapters {
let socket = match open_adapter_socket(&adapter, cfg.discovery.source_port) {
Ok(s) => s,
Err(e) => {
tracing::warn!("force-ip: skipping {} ({}): {e}", adapter.name, adapter.ip);
continue;
}
};
for dest in beacon_destinations(
&adapter,
cfg.discovery.limited_broadcast,
cfg.discovery.device_port,
) {
if let Err(e) = socket.send_to(&packet, dest) {
tracing::trace!("force-ip: send to {dest} failed: {e}");
}
}
sockets.push(socket);
}
let deadline = Instant::now() + cfg.ack_window;
let mut buf = [0u8; 256];
while Instant::now() < deadline {
for socket in &sockets {
socket
.set_read_timeout(Some(Duration::from_millis(20)))
.ok();
let Ok((n, _)) = socket.recv_from(&mut buf) else {
continue;
};
if let Some(ack) = Ack::parse(&buf[..n])
&& ack.answer == gvcp::FORCEIP_ACK
&& !ack.status.is_error()
{
return Ok(true);
}
}
}
Ok(false)
}
pub fn is_reachable(device: &DiscoveredDevice) -> bool {
let mask = u32::from(device.adapter.netmask);
(u32::from(device.info.ip) & mask) == (u32::from(device.adapter.ip) & mask)
}
pub fn discover_on(interface_ip: Ipv4Addr, recv_window: Duration) -> Result<Vec<DiscoveredDevice>> {
let adapter = enumerate_adapters()?
.into_iter()
.find(|a| a.ip == interface_ip)
.ok_or_else(|| {
CameraError::Io(io::Error::new(
io::ErrorKind::AddrNotAvailable,
format!("no Up IPv4 adapter with address {interface_ip}"),
))
})?;
let cfg = DiscoveryConfig {
adapters: Some(vec![adapter]),
recv_window,
..DiscoveryConfig::default()
};
discover(&cfg)
}
pub fn device_ip(device: &DiscoveredDevice) -> IpAddr {
device.info.ip.into()
}