eric/pmomusic
1
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Implémentation d'un MediaRenderer UPnP privé par navigateur avec token

Browse Source 
Ajout de la documentation et de l'architecture pour le MediaRenderer UPnP privé par navigateur avec token, ainsi que les améliorations du client et serveur SSDP pour gérer les réseaux bloquant le multicast.
This commit is contained in:
Eric Coissac
2026-02-04 16:20:15 +01:00
parent c7fa37da16
commit b987decb8d
3 changed files with 337 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
pmoupnp/src/ssdp/client.rs
View File

@@ -57,6 +57,7 @@ pub enum SsdpEvent {
#[derive(Clone)]
pub struct SsdpClient {
socket: Arc<UdpSocket>,
loopback_socket: Arc<UdpSocket>,
}
impl SsdpClient {
@@ -81,26 +82,57 @@ impl SsdpClient {
for iface in get_if_addrs::get_if_addrs()? {
if let std::net::IpAddr::V4(ipv4) = iface.ip() {
if !ipv4.is_loopback() {
match socket.join_multicast_v4(&SSDP_MULTICAST_ADDR.parse().unwrap(), &ipv4) {
Ok(()) => {
// Join multicast on ALL interfaces, including loopback for local development
match socket.join_multicast_v4(&SSDP_MULTICAST_ADDR.parse().unwrap(), &ipv4) {
Ok(()) => {
if ipv4.is_loopback() {
debug!(
"SSDP: joined {} on {} (localhost - dev mode)",
SSDP_MULTICAST_ADDR, ipv4
);
} else {
debug!("SSDP: joined {} on {}", SSDP_MULTICAST_ADDR, ipv4);
}
Err(e) => {
warn!(
"SSDP: failed to join {} on {}: {}",
SSDP_MULTICAST_ADDR, ipv4, e
);
}
}
Err(e) => {
warn!(
"SSDP: failed to join {} on {}: {}",
SSDP_MULTICAST_ADDR, ipv4, e
);
}
}
}
}
// Create a second socket for loopback multicast (when network blocks multicast)
let loopback_socket2 = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP))?;
loopback_socket2.set_reuse_address(true)?;
// Bind on any address with ephemeral port (like the main socket)
let loopback_bind: SocketAddr = "0.0.0.0:0".parse().unwrap();
loopback_socket2.bind(&loopback_bind.into())?;
let loopback_socket: UdpSocket = loopback_socket2.into();
loopback_socket.set_multicast_loop_v4(true)?;
// Join multicast specifically on loopback interface (127.0.0.1)
let loopback_addr: std::net::Ipv4Addr = "127.0.0.1".parse().unwrap();
if let Err(e) =
loopback_socket.join_multicast_v4(&SSDP_MULTICAST_ADDR.parse().unwrap(), &loopback_addr)
{
warn!("Failed to join multicast on loopback socket: {}", e);
} else {
debug!(
"SSDP loopback socket: joined {} on 127.0.0.1",
SSDP_MULTICAST_ADDR
);
}
info!("✅ SSDP client ready on {}", addr);
Ok(Self {
socket: Arc::new(socket),
loopback_socket: Arc::new(loopback_socket),
})
}
@@ -118,19 +150,50 @@ impl SsdpClient {
SSDP_MULTICAST_ADDR, SSDP_PORT, mx, st
);
let addr: SocketAddr = format!("{}:{}", SSDP_MULTICAST_ADDR, SSDP_PORT)
let multicast_addr: SocketAddr = format!("{}:{}", SSDP_MULTICAST_ADDR, SSDP_PORT)
.parse()
.unwrap();
match self.socket.send_to(msg.as_bytes(), addr) {
// Try multicast first
match self.socket.send_to(msg.as_bytes(), multicast_addr) {
Ok(_) => {
info!("📤 M-SEARCH sent (ST={}, MX={})", st, mx);
info!("📤 M-SEARCH sent to multicast (ST={}, MX={})", st, mx);
debug!(
"📨 M-SEARCH payload\n<details>\n\n```\n{}\n```\n</details>\n",
msg
);
Ok(())
}
Err(e) if e.raw_os_error() == Some(65) || e.raw_os_error() == Some(101) => {
// Error 65 (EHOSTUNREACH) on macOS, 101 (ENETUNREACH) on Linux
// Network blocks multicast (e.g., eduroam) → send to localhost unicast
warn!(
"⚠️ Multicast blocked on network ({}), sending to localhost for local devices",
e
);
// Send to localhost unicast (not multicast) - servers on 127.0.0.1:1900 will receive
let localhost_addr: SocketAddr =
format!("127.0.0.1:{}", SSDP_PORT).parse().unwrap();
match self.loopback_socket.send_to(msg.as_bytes(), localhost_addr) {
Ok(_) => {
info!(
"📤 M-SEARCH sent to localhost unicast (ST={}, MX={})",
st, mx
);
debug!(
"📨 M-SEARCH localhost payload\n<details>\n\n```\n{}\n```\n</details>\n",
msg
);
Ok(())
}
Err(loopback_err) => {
warn!("❌ Failed to send M-SEARCH to localhost: {}", loopback_err);
Err(loopback_err)
}
}
}
Err(e) => {
warn!("❌ Failed to send M-SEARCH: {}", e);
Err(e)

136
pmoupnp/src/ssdp/server.rs
View File

@@ -15,6 +15,9 @@ pub struct SsdpServer {
/// Socket UDP pour SSDP
socket: Option<Arc<UdpSocket>>,
/// Socket dédié pour loopback (quand le réseau bloque le multicast)
loopback_socket: Option<Arc<UdpSocket>>,
}
impl SsdpServer {
@@ -23,6 +26,7 @@ impl SsdpServer {
Self {
devices: Arc::new(RwLock::new(HashMap::new())),
socket: None,
loopback_socket: None,
}
}
@@ -77,22 +81,90 @@ impl SsdpServer {
// Convertir en UdpSocket standard
let socket: UdpSocket = socket2.into();
// Rejoindre le groupe multicast
socket.join_multicast_v4(
&SSDP_MULTICAST_ADDR.parse().unwrap(),
&"0.0.0.0".parse().unwrap(),
)?;
// Rejoindre le groupe multicast sur toutes les interfaces (y compris loopback)
// Ceci est essentiel pour le développement local avec plusieurs instances
for iface in get_if_addrs::get_if_addrs()? {
if let std::net::IpAddr::V4(ipv4) = iface.ip() {
match socket.join_multicast_v4(&SSDP_MULTICAST_ADDR.parse().unwrap(), &ipv4) {
Ok(()) => {
if ipv4.is_loopback() {
debug!(
"SSDP server: joined {} on {} (localhost - dev mode)",
SSDP_MULTICAST_ADDR, ipv4
);
} else {
debug!("SSDP server: joined {} on {}", SSDP_MULTICAST_ADDR, ipv4);
}
}
Err(e) => {
warn!(
"SSDP server: failed to join {} on {}: {}",
SSDP_MULTICAST_ADDR, ipv4, e
);
}
}
}
}
socket.set_read_timeout(Some(Duration::from_secs(1)))?;
socket.set_multicast_loop_v4(false)?;
socket.set_multicast_loop_v4(true)?; // Important pour dev local
let socket = Arc::new(socket);
self.socket = Some(socket.clone());
// Create a second socket for loopback multicast (when network blocks multicast)
let loopback_socket2 = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP))?;
loopback_socket2.set_reuse_address(true)?;
#[cfg(unix)]
{
use std::os::unix::io::AsRawFd;
let fd = loopback_socket2.as_raw_fd();
let optval: libc::c_int = 1;
unsafe {
let result = libc::setsockopt(
fd,
libc::SOL_SOCKET,
libc::SO_REUSEPORT,
&optval as *const _ as *const libc::c_void,
std::mem::size_of_val(&optval) as libc::socklen_t,
);
if result != 0 {
return Err(std::io::Error::last_os_error());
}
}
}
// Bind on any address with ephemeral port (not on port 1900 to avoid conflicts)
let loopback_bind: SocketAddr = "0.0.0.0:0".parse().unwrap();
loopback_socket2.bind(&loopback_bind.into())?;
let loopback_socket: UdpSocket = loopback_socket2.into();
loopback_socket.set_multicast_loop_v4(true)?;
// Join multicast specifically on loopback interface (127.0.0.1)
let loopback_addr: std::net::Ipv4Addr = "127.0.0.1".parse().unwrap();
if let Err(e) =
loopback_socket.join_multicast_v4(&SSDP_MULTICAST_ADDR.parse().unwrap(), &loopback_addr)
{
warn!(
"SSDP server: failed to join multicast on loopback socket: {}",
e
);
} else {
debug!(
"SSDP loopback server socket: joined {} on 127.0.0.1",
SSDP_MULTICAST_ADDR
);
}
let loopback_socket = Arc::new(loopback_socket);
self.loopback_socket = Some(loopback_socket.clone());
info!("✅ SSDP server started on {}", addr);
// Lancer les goroutines d'annonces périodiques et d'écoute M-SEARCH
self.start_periodic_announcements(socket.clone());
self.start_periodic_announcements(socket.clone(), loopback_socket.clone());
self.start_msearch_listener(socket.clone());
Ok(())
@@ -118,9 +190,10 @@ impl SsdpServer {
// Envoyer alive pour tous les NTs
if let Some(ref socket) = self.socket {
let loopback_socket = self.loopback_socket.as_ref();
let nts = device.get_notification_types();
for nt in nts.iter() {
Self::send_alive(socket, &device, nt, false);
Self::send_alive(socket, loopback_socket, &device, nt, false);
// Petit délai pour éviter de saturer le buffer UDP sur macOS
std::thread::sleep(Duration::from_millis(5));
}
@@ -149,7 +222,13 @@ impl SsdpServer {
}
/// Envoie un NOTIFY alive
fn send_alive(socket: &UdpSocket, device: &SsdpDevice, nt: &str, is_periodic: bool) {
fn send_alive(
socket: &UdpSocket,
loopback_socket: Option<&Arc<UdpSocket>>,
device: &SsdpDevice,
nt: &str,
is_periodic: bool,
) {
let usn = if nt.starts_with("uuid:") {
format!("{}", nt)
} else {
@@ -169,11 +248,11 @@ impl SsdpServer {
SSDP_MULTICAST_ADDR, SSDP_PORT, MAX_AGE, device.location, nt, device.server, usn
);
let addr: SocketAddr = format!("{}:{}", SSDP_MULTICAST_ADDR, SSDP_PORT)
let multicast_addr: SocketAddr = format!("{}:{}", SSDP_MULTICAST_ADDR, SSDP_PORT)
.parse()
.unwrap();
match socket.send_to(msg.as_bytes(), addr) {
match socket.send_to(msg.as_bytes(), multicast_addr) {
Ok(_) => {
let label = if is_periodic { " (periodic)" } else { "" };
info!("✅ NOTIFY alive{}: {} (NT={})", label, usn, nt);
@@ -182,7 +261,34 @@ impl SsdpServer {
label, msg
);
}
Err(e) if e.raw_os_error() == Some(65) || e.raw_os_error() == Some(101) => {
// Multicast bloqué sur le réseau, envoyer en unicast sur localhost
if let Some(loopback_sock) = loopback_socket {
// Send to localhost unicast - local clients will receive
let localhost_addr: SocketAddr =
format!("127.0.0.1:{}", SSDP_PORT).parse().unwrap();
match loopback_sock.send_to(msg.as_bytes(), localhost_addr) {
Ok(_) => {
let label = if is_periodic { " (periodic)" } else { "" };
info!("✅ NOTIFY alive{} to localhost: {} (NT={})", label, usn, nt);
}
Err(loopback_err) => {
let label = if is_periodic { "periodic " } else { "" };
warn!(
"❌ Failed to send {}NOTIFY alive to localhost for {}: {}",
label, usn, loopback_err
);
}
}
} else {
let label = if is_periodic { "periodic " } else { "" };
warn!(
"❌ Failed to send {}NOTIFY alive for {} (no loopback socket available): {}",
label, usn, e
);
}
}
Err(e) => {
let label = if is_periodic { "periodic " } else { "" };
warn!("❌ Failed to send {}NOTIFY alive for {}: {}", label, usn, e);
@@ -225,7 +331,11 @@ impl SsdpServer {
}
/// Démarre les annonces périodiques (toutes les MAX_AGE/2 secondes)
fn start_periodic_announcements(&self, socket: Arc<UdpSocket>) {
fn start_periodic_announcements(
&self,
socket: Arc<UdpSocket>,
loopback_socket: Arc<UdpSocket>,
) {
let devices = Arc::clone(&self.devices);
let period = Duration::from_secs((MAX_AGE / 2) as u64);
@@ -241,7 +351,7 @@ impl SsdpServer {
};
for device in &devices_snapshot {
for nt in device.get_notification_types() {
Self::send_alive(&socket, device, nt, true);
Self::send_alive(&socket, Some(&loopback_socket), device, nt, true);
}
}
}