show all ips

Author: Fredolx

src-tauri/Cargo.lock

@@ -42,6 +42,7 @@ rusqlite_migration = "1.3.1"
 base64 = "0.22.1"
 tauri-plugin-notification = "2.2.0"
 warp = "0.3.7"
+if-addrs = "0.13.3"
 [target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
 shell-words = "1.1.0"
 [target.'cfg(target_os = "windows")'.dependencies]

src-tauri/Cargo.toml

@@ -7,7 +7,7 @@ use tauri::{
 use tokio::sync::Mutex;
 use types::{
     AppState, Channel, CustomChannel, CustomChannelExtraData, EPGNotify, Filters, Group, IdName,
-    Settings, Source, EPG,
+    NetworkInfo, Settings, Source, EPG,
 };
 
 pub mod epg;
@@ -83,7 +83,8 @@ pub fn run() {
             on_start_check_epg,
             start_restream,
             stop_restream,
-            watch_self
+            watch_self,
+            get_network_info
         ])
         .setup(|app| {
             app.manage(Mutex::new(AppState {
@@ -417,6 +418,11 @@ async fn stop_restream(state: State<'_, Mutex<AppState>>) -> Result<(), String>
 }
 
 #[tauri::command]
-async fn watch_self() -> Result<(), String> {
-    restream::watch_self().await.map_err(map_err_frontend)
+async fn watch_self(port: u16) -> Result<(), String> {
+    restream::watch_self(port).await.map_err(map_err_frontend)
+}
+
+#[tauri::command]
+async fn get_network_info() -> Result<NetworkInfo, String> {
+    restream::get_network_info().await.map_err(map_err_frontend)
 }

src-tauri/src/lib.rs

@@ -4,6 +4,7 @@ use std::{
 };
 
 use anyhow::{Context, Result};
+use if_addrs::IfAddr;
 use tauri::State;
 use tokio::{
     fs,
@@ -15,10 +16,14 @@ use tokio::{
 
 use crate::{
     log::log,
-    mpv, sql,
-    types::{AppState, Channel},
+    mpv,
+    settings::get_settings,
+    sql,
+    types::{AppState, Channel, NetworkInfo},
 };
 
+const WAN_IP_API: &str = "https://api.ipify.org";
+
 fn start_ffmpeg_listening(channel: Channel, restream_dir: PathBuf) -> Result<Child> {
     let headers = sql::get_channel_headers_by_id(channel.id.context("no channel id")?)?;
     let playlist_dir = get_playlist_dir(restream_dir);
@@ -128,9 +133,9 @@ async fn delete_old_segments(dir: &Path) -> Result<()> {
     Ok(())
 }
 
-pub async fn watch_self() -> Result<()> {
+pub async fn watch_self(port: u16) -> Result<()> {
     let channel = Channel {
-        url: Some("http://127.0.0.1:3000/stream.m3u8".to_string()),
+        url: Some(format!("http://127.0.0.1:{port}/stream.m3u8").to_string()),
         name: "Local livestream".to_string(),
         favorite: false,
         group: None,
@@ -145,11 +150,11 @@ pub async fn watch_self() -> Result<()> {
     mpv::play(channel, false).await
 }
 
-fn share_restream(ip: String, channel: Channel) -> Result<()> {
+fn share_restream(address: String, channel: Channel) -> Result<()> {
     crate::share::share_custom_channel(Channel {
         id: Some(-1),
         name: format!("RST | {}", channel.name).to_string(),
-        url: Some(format!("http://{ip}/stream.m3u8").to_string()),
+        url: Some(address),
         group: None,
         image: channel.image,
         media_type: crate::media_type::LIVESTREAM,
@@ -160,3 +165,27 @@ fn share_restream(ip: String, channel: Channel) -> Result<()> {
         stream_id: None,
     })
 }
+
+pub async fn get_network_info() -> Result<NetworkInfo> {
+    let port = get_settings()?.restream_port.unwrap_or(3000);
+    Ok(NetworkInfo {
+        port,
+        local_ips: get_ips(port)?,
+        wan_ip: get_wan_ip(port).await?,
+    })
+}
+
+fn get_ips(port: u16) -> Result<Vec<String>> {
+    Ok(if_addrs::get_if_addrs()?
+        .iter()
+        .filter(|i| i.ip().is_ipv4() && !i.ip().is_loopback())
+        .map(|i| format!("http://{}:{port}/stream.m3u8", i.ip().to_string()))
+        .collect())
+}
+
+async fn get_wan_ip(port: u16) -> Result<String> {
+    Ok(format!(
+        "http://{}:{port}/stream.m3u8",
+        reqwest::get(WAN_IP_API).await?.text().await?
+    ))
+}

src-tauri/src/restream.rs

@@ -11,6 +11,7 @@ pub const RECORDING_PATH: &str = "recordingPath";
 pub const DEFAULT_VIEW: &str = "defaultView";
 pub const VOLUME: &str = "volume";
 pub const REFRESH_ON_START: &str = "refreshOnStart";
+pub const RESTREAM_PORT: &str = "restreamPort";
 
 pub fn get_settings() -> Result<Settings> {
     let map = sql::get_settings()?;
@@ -21,6 +22,7 @@ pub fn get_settings() -> Result<Settings> {
         default_view: map.get(DEFAULT_VIEW).and_then(|s| s.parse().ok()),
         volume: map.get(VOLUME).and_then(|s| s.parse().ok()),
         refresh_on_start: map.get(REFRESH_ON_START).and_then(|s| s.parse().ok()),
+        restream_port: map.get(RESTREAM_PORT).and_then(|s| s.parse().ok()),
     };
     Ok(settings)
 }
@@ -48,6 +50,9 @@ pub fn update_settings(settings: Settings) -> Result<()> {
     if let Some(refresh_on_start) = settings.refresh_on_start {
         map.insert(REFRESH_ON_START.to_string(), refresh_on_start.to_string());
     }
+    if let Some(port) = settings.restream_port {
+        map.insert(RESTREAM_PORT.to_string(), port.to_string());
+    }
     sql::update_settings(map)?;
     Ok(())
 }

src-tauri/src/settings.rs

@@ -50,6 +50,7 @@ pub struct Settings {
     pub default_view: Option<u8>,
     pub volume: Option<u8>,
     pub refresh_on_start: Option<bool>,
+    pub restream_port: Option<u16>,
 }
 
 #[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
@@ -144,3 +145,10 @@ pub struct AppState {
     pub web_server_tx: Option<tokio::sync::oneshot::Sender<bool>>,
     pub web_server_handle: Option<tokio::task::JoinHandle<()>>,
 }
+
+#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
+pub struct NetworkInfo {
+    pub port: u16,
+    pub local_ips: Vec<String>,
+    pub wan_ip: String,
+}

src-tauri/src/types.rs

@@ -0,0 +1,5 @@
+export class NetworkInfo {
+  port!: number;
+  local_ips!: Array<string>;
+  wan_ip!: Array<string>;
+}

src/app/models/networkInfo.ts

@@ -14,16 +14,15 @@ <h4 class="modal-title lbl">Re-streaming: {{ channel?.name }}</h4>
     </p>
   </div>
   <div *ngIf="started" class="selectable box mt-3">
-    <p>Running...</p>
+    <p>Running and accessible from the following ips...</p>
     <br />
-    <div class="row">
-      <div class="col-5 col-lg-3 col-xl-2">LAN service address:</div>
-      <div class="col">{{ address }}</div>
-    </div>
-    <div class="row">
-      <div class="col-5 col-lg-3 col-xl-2">WAN service address:</div>
-      <div class="col">{{ wanAddress }}</div>
-    </div>
+    <p>Local ips:</p>
+    <p *ngFor="let local of networkInfo?.local_ips">
+      {{ local }}
+    </p>
+    <br />
+    <p>WAN address:</p>
+    <p>{{ networkInfo?.wan_ip }}</p>
   </div>
   <div *ngIf="started">
     <br />
@@ -64,7 +63,7 @@ <h4 class="modal-title lbl">Re-streaming: {{ channel?.name }}</h4>
   <button
     class="btn btn-success d-inline-flex align-items-center"
     (click)="watch()"
-    [disabled]="loading"
+    [disabled]="loading || watching"
     *ngIf="started"
   >
     <span>Watch</span>

src/app/restream-modal/restream-modal.component.html

@@ -1,20 +1,30 @@
-import { Component } from "@angular/core";
+import { Component, OnInit } from "@angular/core";
 import { Channel } from "../models/channel";
 import { invoke } from "@tauri-apps/api/core";
 import { ErrorService } from "../error.service";
+import { NetworkInfo } from "../models/networkInfo";
 
 @Component({
   selector: "app-restream-modal",
   templateUrl: "./restream-modal.component.html",
   styleUrl: "./restream-modal.component.css",
 })
-export class RestreamModalComponent {
+export class RestreamModalComponent implements OnInit {
   channel?: Channel;
   loading = false;
+  watching = false;
   started = false;
   address = "http://192.168.2.10/stream.m3u8";
   wanAddress = "http://10.145.22.12/stream.m3u8";
+  networkInfo?: NetworkInfo;
   constructor(private error: ErrorService) {}
+
+  ngOnInit(): void {
+    invoke("get_network_info").then((network) => {
+      this.networkInfo = network as NetworkInfo;
+    });
+  }
+
   async start() {
     this.loading = true;
     try {
@@ -40,13 +50,13 @@ export class RestreamModalComponent {
   }
 
   async watch() {
-    this.loading = true;
+    this.watching = true;
     try {
-      await invoke("watch_self");
+      await invoke("watch_self", { port: this.networkInfo?.port });
     } catch (e) {
       this.error.handleError(e);
     }
-    this.loading = false;
+    this.watching = false;
   }
 
   share() {}