From b987decb8dbd815fce9e98f1e8d4324e8e1f5436 Mon Sep 17 00:00:00 2001
From: Eric Coissac <eric@coissac.eu>
Date: Wed, 4 Feb 2026 16:20:15 +0100
Subject: [PATCH] =?UTF-8?q?Impl=C3=A9mentation=20d'un=20MediaRenderer=20UP?=
 =?UTF-8?q?nP=20priv=C3=A9=20par=20navigateur=20avec=20token?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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.
---
 Blackboard/ToThinkAbout/webrenderer.md | 139 +++++++++++++++++++++++++
 pmoupnp/src/ssdp/client.rs             |  87 +++++++++++++---
 pmoupnp/src/ssdp/server.rs             | 136 +++++++++++++++++++++---
 3 files changed, 337 insertions(+), 25 deletions(-)
 create mode 100644 Blackboard/ToThinkAbout/webrenderer.md

diff --git a/Blackboard/ToThinkAbout/webrenderer.md b/Blackboard/ToThinkAbout/webrenderer.md
new file mode 100644
index 00000000..b678f635
--- /dev/null
+++ b/Blackboard/ToThinkAbout/webrenderer.md
@@ -0,0 +1,139 @@
+Parfait. Voici un **schéma fonctionnel minimal** pour un **MediaRenderer UPnP privé par navigateur** avec **token**. L’idée est de rester fidèle à ton backend Rust existant et à la webapp Vue.js. En s'appuyant sur l'architecture de PMOMusic, j'aimerais que tu proposes un plan détaillé pour implémenter un tel système de Média Renderer.
+
+- L'application web se trouve dans: [@webapp](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmoapp/webapp) 
+- Tu as un prototype de Média Renderer dans: [@pmomediarenderer](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmomediarenderer) 
+- Le contrôle point est dans : [@pmocontrol](file:///Users/coissac/Sync/maison/Petite_maisons/src/pmomusic/pmocontrol) 
+- Tu implémenteras ce nouveau système de Média Renderer dans la CRATe pmowebrenderer
+
+Tu mettras une version du plan en Markdown dans le répertoire Architecture.
+
+---
+
+## 1. Flow général
+
+```
+Browser (Vue.js Control Point)
+ ┌───────────────┐
+ │   UI / audio  │
+ │  WebSocket    │
+ └───────▲───────┘
+         │ token
+         │
+         ▼
+Rust backend (UPnP MediaRenderer)
+ ┌───────────────────────────┐
+ │ Token → Renderer mapping  │
+ │ Device XML / SOAP endpoints│
+ │ Play/Pause/Stop → WS → Browser │
+ └───────────────────────────┘
+```
+
+---
+
+## 2. Étapes détaillées
+
+### a) Création du renderer
+
+1. Le navigateur se connecte via WebSocket ou HTTP.
+2. Rust génère un token unique pour ce client :
+
+   ```rust
+   use uuid::Uuid;
+   let token = Uuid::new_v4().to_string();
+   ```
+3. Rust crée une instance MediaRenderer **privée**, associée à ce token :
+
+   * Device description XML : `/renderer/<token>/desc.xml`
+   * AVTransport SOAP : `/renderer/<token>/avtransport`
+   * RenderingControl SOAP : `/renderer/<token>/renderingcontrol`
+
+---
+
+### b) Control Point
+
+* La webapp Vue.js reçoit le token et la “déclare” au Control Point :
+
+```js
+const renderer = {
+  token: "abcd-1234-efgh",
+  name: "Browser Renderer"
+};
+
+// Ajout au control point local
+controlPoint.addRenderer(renderer);
+```
+
+* Toutes les commandes Play/Pause/Stop incluent ce token :
+
+```js
+ws.send(JSON.stringify({
+  token: renderer.token,
+  action: "play",
+  uri: "http://localhost:8080/media.mp3"
+}));
+```
+
+---
+
+### c) Backend Rust : dispatcher les commandes
+
+* Rust reçoit le JSON avec le token.
+* Vérifie que le token correspond à un renderer actif.
+* Transmet la commande au navigateur via WebSocket (ou HTTP push) :
+
+```rust
+match msg.action.as_str() {
+    "play" => send_ws_to_browser(&token, format!("play:{}", msg.uri)),
+    "pause" => send_ws_to_browser(&token, "pause".to_string()),
+    "stop" => send_ws_to_browser(&token, "stop".to_string()),
+    _ => (),
+}
+```
+
+* Rust met à jour l’état du renderer (AVTransport/RenderingControl) pour le Control Point.
+
+---
+
+### d) Lecture côté navigateur
+
+* Le navigateur reçoit la commande via WebSocket et pilote `<audio>` :
+
+```js
+ws.onmessage = (evt) => {
+  const msg = evt.data;
+  if(msg.startsWith("play:")) {
+    audio.src = msg.split(":")[1];
+    audio.play();
+  } else if(msg === "pause") {
+    audio.pause();
+  } else if(msg === "stop") {
+    audio.pause();
+    audio.currentTime = 0;
+  }
+};
+```
+
+---
+
+### e) Fermeture / cleanup
+
+* Quand le navigateur se déconnecte :
+
+  * Rust supprime le renderer associé au token
+  * Émet un **byebye virtuel** pour le Control Point (si nécessaire)
+  * Libère toutes les ressources
+
+---
+
+## 3. Points clés
+
+1. **Token unique** = session privée + sécurité
+2. **Pas besoin de SSDP / annonce** : le renderer est dédié à un navigateur connu
+3. **Control Point Vue.js** sait exactement quel renderer utiliser
+4. **Rust backend** reste seul responsable de l’implémentation UPnP
+5. **Lecture réelle** = navigateur via `<audio>` ou `<video>`
+
+---
+
+💡 Ce modèle est très proche de ce que font **Mopidy avec Iris**, **Kodi Remote**, ou **Chromecast / local cast** : le device est connu et dédié, pas besoin de découverte réseau.
+
diff --git a/pmoupnp/src/ssdp/client.rs b/pmoupnp/src/ssdp/client.rs
index 8fcb1b8f..5b6d7cbe 100644
--- a/pmoupnp/src/ssdp/client.rs
+++ b/pmoupnp/src/ssdp/client.rs
@@ -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)
diff --git a/pmoupnp/src/ssdp/server.rs b/pmoupnp/src/ssdp/server.rs
index 4ec816fe..8dc23756 100644
--- a/pmoupnp/src/ssdp/server.rs
+++ b/pmoupnp/src/ssdp/server.rs
@@ -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);
                     }
                 }
             }