#![allow(clippy::result_large_err)] //! Public endpoints: M3U, XMLTV, HLS, MPEG-TS, icons, sharing, recordings. use super::ApiError; use crate::app::State; use crate::auth::{self, AuthQuery, StreamAccess}; use crate::clients::NewClient; use crate::pipeline; use crate::tuner::Priority; use axum::body::Body; use axum::extract::{ConnectInfo, Path, Query, State as AxState}; use axum::http::{header, HeaderMap, HeaderValue, StatusCode}; use axum::response::{Html, IntoResponse, Redirect, Response}; use futures_util::StreamExt; use serde::Deserialize; use std::net::SocketAddr; use std::time::Duration; use tokio::io::{AsyncReadExt, AsyncSeekExt}; use tokio_util::io::ReaderStream; #[derive(Deserialize, Default)] pub struct StreamQuery { token: Option, /// tvheadend: persistent authentication code (`?auth=`) auth: Option, /// tvheadend: ticket (`?ticket=`) ticket: Option, share: Option, profile: Option, format: Option, /// M3U: only these channels (comma separated channel ids, e.g. the favourites) channels: Option, /// M3U: only this channel group group: Option, /// HLS: viewer id of a player instance (lets the server end its old sessions at once) v: Option, } impl StreamQuery { fn viewer(&self) -> Option<&str> { self.v .as_deref() .filter(|v| (8..=40).contains(&v.len()) && v.chars().all(|c| c.is_ascii_alphanumeric())) } } impl StreamQuery { pub(crate) fn auth(&self) -> AuthQuery { AuthQuery { token: self .token .clone() .or_else(|| self.auth.clone()) .or_else(|| self.ticket.clone()), share: self.share.clone(), } } pub(crate) fn profile(&self) -> Result { Ok(pipeline::normalize_profile(self.profile.as_deref().unwrap_or("pass")).to_string()) } } pub(crate) fn unauthorized() -> Response { ( StatusCode::UNAUTHORIZED, [(header::WWW_AUTHENTICATE, "Basic realm=\"simply-dvb\"")], "access denied – use a token (?token=...) or the local network", ) .into_response() } pub struct Ctx { pub(crate) access: StreamAccess, ip: String, ua: String, } #[allow(clippy::result_large_err)] pub(crate) async fn access( state: &State, peer: SocketAddr, headers: &HeaderMap, q: &StreamQuery, ) -> Result { let ip = auth::client_ip(state, peer, headers); let ua = headers .get(header::USER_AGENT) .and_then(|v| v.to_str().ok()) .unwrap_or(""); let a = match auth::stream_access(state, ip, headers, &q.auth()).await { Some(a) => a, None => { tracing::warn!(target: "access", "stream access denied for {ip} ({ua}) – no token, outside open networks"); return Err(unauthorized()); } }; if !matches!(a, auth::StreamAccess::Network) { tracing::debug!(target: "access", "stream access for {ip}: {}", a.who()); } Ok(Ctx { access: a, ip: ip.to_string(), ua: ua.to_string(), }) } fn strip_ext(s: &str) -> &str { s.split('.').next().unwrap_or(s) } #[allow(clippy::result_large_err)] fn parse_id(s: &str) -> Result { strip_ext(s) .parse() .map_err(|_| (StatusCode::NOT_FOUND, "not found").into_response()) } // ------------------------------------------------------------ M3U / XMLTV pub async fn playlist( AxState(state): AxState, ConnectInfo(peer): ConnectInfo, headers: HeaderMap, Query(q): Query, ) -> Response { let ctx = match access(&state, peer, &headers, &q).await { Ok(c) => c, Err(r) => return r, }; if matches!(ctx.access, StreamAccess::Share(_)) { return unauthorized(); } let s = state.settings(); let base = auth::base_url(&state, peer, &headers); let format = q.format.clone().unwrap_or(s.m3u_format.clone()); let profile = match q.profile() { Ok(p) => p, Err(e) => return e.into_response(), }; let mut channels = match state.db.channels().await { Ok(c) => c, Err(e) => return ApiError::from(e).into_response(), }; if let Some(ids) = q.channels.as_deref().filter(|s| !s.is_empty()) { // keeps the given order (e.g. favourites in the order they were added) let ids: Vec = ids .split(',') .filter_map(|x| x.trim().parse().ok()) .collect(); let mut picked: Vec = ids .iter() .filter_map(|id| channels.iter().find(|c| c.id == *id).cloned()) .collect(); picked.sort_by_key(|c| ids.iter().position(|i| *i == c.id)); channels = picked; } if let Some(g) = q.group.as_deref().filter(|s| !s.is_empty()) { channels.retain(|c| c.grp == g); } let auth_q = ctx.access.query(); let body = crate::m3u::build( &channels, &crate::m3u::M3uOptions { base: &base, format: if format == "hls" { "hls" } else { "ts" }, profile: &profile, auth: &auth_q, }, ); ( [ (header::CONTENT_TYPE, "audio/x-mpegurl; charset=utf-8"), ( header::CONTENT_DISPOSITION, "inline; filename=\"simply-dvb.m3u\"", ), (header::CACHE_CONTROL, "no-cache"), ], body, ) .into_response() } pub async fn epg_xml( AxState(state): AxState, ConnectInfo(peer): ConnectInfo, headers: HeaderMap, Query(q): Query, ) -> Response { let ctx = match access(&state, peer, &headers, &q).await { Ok(c) => c, Err(r) => return r, }; if matches!(ctx.access, StreamAccess::Share(_)) { return unauthorized(); } let base = auth::base_url(&state, peer, &headers); let aq = ctx.access.query(); let query = if aq.is_empty() { String::new() } else { format!("?{aq}") }; match crate::epg::export_xmltv(&state, &base, &query).await { Ok(x) => ( [ (header::CONTENT_TYPE, "application/xml; charset=utf-8"), (header::CACHE_CONTROL, "no-cache"), ], x, ) .into_response(), Err(e) => ApiError::from(e).into_response(), } } // ------------------------------------------------------------ HLS fn hls_suffix(ctx: &Ctx, q: &StreamQuery, profile: &str) -> String { let mut parts = Vec::new(); if profile != "pass" { parts.push(format!("profile={profile}")); } if let Some(v) = q.viewer() { parts.push(format!("v={v}")); } match &ctx.access { StreamAccess::Token(t) => parts.push(format!("token={}", t.token)), StreamAccess::Share(_) => { parts.push(format!("share={}", q.share.clone().unwrap_or_default())) } _ => {} } if parts.is_empty() { String::new() } else { format!("?{}", parts.join("&")) } } pub async fn hls_playlist( AxState(state): AxState, ConnectInfo(peer): ConnectInfo, headers: HeaderMap, Path(ch): Path, Query(q): Query, ) -> Response { let ctx = match access(&state, peer, &headers, &q).await { Ok(c) => c, Err(r) => return r, }; let id = match parse_id(&ch) { Ok(i) => i, Err(r) => return r, }; if !ctx.access.allows_channel(id) { return unauthorized(); } let profile = match q.profile() { Ok(p) => p, Err(e) => return e.into_response(), }; let sess = state.hls.get_or_start(&state, id, &profile, q.viewer()); sess.touch(); if let Err(e) = sess.wait_ready(Duration::from_secs(25)).await { return ( StatusCode::SERVICE_UNAVAILABLE, [(header::RETRY_AFTER, "3")], format!("{e:#}"), ) .into_response(); } let name = state .db .channel(id) .await .ok() .flatten() .map(|c| c.name) .unwrap_or_default(); state.clients.touch_hls( NewClient { kind: "hls", channel_id: id, channel_name: &name, ip: &ctx.ip, user_agent: &ctx.ua, who: &ctx.access.who(), profile: &profile, }, 0, ); let body = sess.playlist(&hls_suffix(&ctx, &q, &profile)); ( [ (header::CONTENT_TYPE, "application/vnd.apple.mpegurl"), (header::CACHE_CONTROL, "no-cache, no-store"), (header::ACCESS_CONTROL_ALLOW_ORIGIN, "*"), ], body, ) .into_response() } /// `POST /hls/leave?v=` – a player stopped (channel change, page closed). pub async fn hls_leave(AxState(state): AxState, Query(q): Query) -> Response { if let Some(v) = q.viewer() { state.hls.leave(v); } StatusCode::NO_CONTENT.into_response() } pub async fn hls_segment( AxState(state): AxState, ConnectInfo(peer): ConnectInfo, headers: HeaderMap, Path((ch, seg)): Path<(String, String)>, Query(q): Query, ) -> Response { let ctx = match access(&state, peer, &headers, &q).await { Ok(c) => c, Err(r) => return r, }; let id = match parse_id(&ch) { Ok(i) => i, Err(r) => return r, }; if !ctx.access.allows_channel(id) { return unauthorized(); } let Ok(seq) = strip_ext(&seg).parse::() else { return (StatusCode::NOT_FOUND, "not found").into_response(); }; let profile = match q.profile() { Ok(p) => p, Err(e) => return e.into_response(), }; let Some(sess) = state.hls.get(id, &profile) else { return ( StatusCode::NOT_FOUND, "session expired – reload the playlist", ) .into_response(); }; sess.touch(); if let Some(v) = q.viewer() { sess.see(v); } let Some(data) = sess.wait_segment(seq, Duration::from_secs(12)).await else { return (StatusCode::NOT_FOUND, "segment unavailable").into_response(); }; let name = state .db .channel(id) .await .ok() .flatten() .map(|c| c.name) .unwrap_or_default(); state.clients.touch_hls( NewClient { kind: "hls", channel_id: id, channel_name: &name, ip: &ctx.ip, user_agent: &ctx.ua, who: &ctx.access.who(), profile: &profile, }, data.len() as u64, ); ( [ (header::CONTENT_TYPE, "video/mp2t"), (header::CACHE_CONTROL, "max-age=60"), (header::ACCESS_CONTROL_ALLOW_ORIGIN, "*"), ], data, ) .into_response() } // ------------------------------------------------------------ MPEG-TS pub async fn ts_stream( AxState(state): AxState, ConnectInfo(peer): ConnectInfo, headers: HeaderMap, Path(ch): Path, Query(q): Query, ) -> Response { let id = match parse_id(&ch) { Ok(i) => i, Err(r) => return r, }; ts_stream_id(&state, peer, &headers, id, &q).await } /// Continuous MPEG-TS of the given channel id (shared by native and tvheadend paths). pub(crate) async fn ts_stream_id( state: &State, peer: SocketAddr, headers: &HeaderMap, id: i64, q: &StreamQuery, ) -> Response { let state = state.clone(); let ctx = match access(&state, peer, headers, q).await { Ok(c) => c, Err(r) => return r, }; if !ctx.access.allows_channel(id) { return unauthorized(); } let profile = match q.profile() { Ok(p) => p, Err(e) => return e.into_response(), }; let stream = match pipeline::open_service(&state, id, &profile, Priority::Normal).await { Ok(s) => s, Err(e) => return (StatusCode::SERVICE_UNAVAILABLE, format!("{e:#}")).into_response(), }; let guard = state.clients.register(NewClient { kind: "ts", channel_id: id, channel_name: &stream.source.channel.name, ip: &ctx.ip, user_agent: &ctx.ua, who: &ctx.access.who(), profile: &profile, }); tracing::info!( "TS: {} -> {} ({})", stream.source.channel.name, ctx.ip, ctx.access.who() ); let name = stream.source.channel.name.clone(); let body = futures_util::stream::unfold((stream, guard), |(mut s, g)| async move { let b = s.rx.recv().await?; g.add_bytes(b.len() as u64); Some((Ok::<_, std::io::Error>(b), (s, g))) }); let mut res = Response::new(Body::from_stream(body.boxed())); let h = res.headers_mut(); h.insert(header::CONTENT_TYPE, HeaderValue::from_static("video/mp2t")); h.insert( header::CACHE_CONTROL, HeaderValue::from_static("no-cache, no-store"), ); if let Ok(v) = HeaderValue::from_str(&format!( "inline; filename=\"{}.ts\"", crate::recorder::sanitize(&name) )) { h.insert(header::CONTENT_DISPOSITION, v); } res } // ------------------------------------------------------------ ikony pub async fn icon(AxState(state): AxState, Path(id): Path) -> Response { let id = match parse_id(&id) { Ok(i) => i, Err(r) => return r, }; let Ok(Some(c)) = state.db.channel(id).await else { return (StatusCode::NOT_FOUND, "").into_response(); }; if c.icon == "local" { match tokio::fs::read(crate::icons::icon_path(&state, id)).await { Ok(data) => { let ct = crate::icons::sniff_image(&data).unwrap_or("application/octet-stream"); ( [ (header::CONTENT_TYPE, ct), (header::CACHE_CONTROL, "public, max-age=3600"), ], data, ) .into_response() } Err(_) => (StatusCode::NOT_FOUND, "").into_response(), } } else if c.icon.starts_with("http") { Redirect::temporary(&c.icon).into_response() } else { (StatusCode::NOT_FOUND, "").into_response() } } // ------------------------------------------------------------ public player pub async fn watch_page(AxState(state): AxState, Path(token): Path) -> Response { let Ok(Some(c)) = state.db.channel_by_share(&token).await else { return ( StatusCode::NOT_FOUND, Html(super::assets::message_page( "Link inactive", "This stream link has expired or was disabled.", )), ) .into_response(); }; let codec = match c.service_id { Some(sid) => state.db.service(sid).await.ok().flatten().map(|s| { let st = s.streams(); ( st.iter() .find(|x| x.kind.is_video()) .map(|x| x.kind.label().to_string()) .unwrap_or_default(), st.iter() .filter(|x| x.kind.is_audio()) .map(|x| x.kind.label().to_string()) .collect::>() .join("|"), ) }), None => None, } .unwrap_or_default(); Html(super::assets::watch_page( c.id, &c.name, &token, &codec.0, &codec.1, &state.settings().server_name, state.has_ffmpeg(), )) .into_response() } // ------------------------------------------------------------ recordings async fn recording_access( state: &State, peer: SocketAddr, headers: &HeaderMap, q: &StreamQuery, ) -> Result<(), Response> { let ctx = access(state, peer, headers, q).await?; if matches!(ctx.access, StreamAccess::Share(_)) { return Err(unauthorized()); } Ok(()) } pub async fn recording_playlist( AxState(state): AxState, ConnectInfo(peer): ConnectInfo, headers: HeaderMap, Path(id): Path, Query(q): Query, ) -> Response { if let Err(r) = recording_access(&state, peer, &headers, &q).await { return r; } let Ok(Some(rec)) = state.db.recording(id).await else { return (StatusCode::NOT_FOUND, "").into_response(); }; let url = match &q.token { Some(t) => format!("file?token={t}"), None => "file".to_string(), }; match crate::recorder::vod_playlist(&rec, &url).await { Ok(p) => ( [ (header::CONTENT_TYPE, "application/vnd.apple.mpegurl"), (header::CACHE_CONTROL, "no-cache"), ], p, ) .into_response(), Err(e) => (StatusCode::NOT_FOUND, format!("{e:#}")).into_response(), } } /// Recording file with Range header support (HLS byte-range, download, VLC). pub async fn recording_file( AxState(state): AxState, ConnectInfo(peer): ConnectInfo, headers: HeaderMap, Path(id): Path, Query(q): Query, ) -> Response { recording_file_inner(&state, peer, &headers, id, &q).await } /// Recording file for the tvheadend `/dvrfile/` path (raw query string). pub async fn recording_file_by_id( state: &State, peer: SocketAddr, headers: &HeaderMap, id: i64, raw_query: Option, ) -> Response { let q: StreamQuery = serde_urlencoded_query(raw_query.as_deref().unwrap_or("")); recording_file_inner(state, peer, headers, id, &q).await } fn serde_urlencoded_query(q: &str) -> StreamQuery { let m: std::collections::HashMap = url::form_urlencoded::parse(q.as_bytes()) .map(|(k, v)| (k.to_string(), v.to_string())) .collect(); serde_json::from_value(serde_json::json!(m)).unwrap_or_default() } async fn recording_file_inner( state: &State, peer: SocketAddr, headers: &HeaderMap, id: i64, q: &StreamQuery, ) -> Response { let state = state.clone(); let headers = headers.clone(); if let Err(r) = recording_access(&state, peer, &headers, q).await { return r; } let Ok(Some(rec)) = state.db.recording(id).await else { return (StatusCode::NOT_FOUND, "").into_response(); }; let Ok(mut f) = tokio::fs::File::open(&rec.file).await else { return (StatusCode::NOT_FOUND, "file missing").into_response(); }; let Ok(meta) = f.metadata().await else { return (StatusCode::NOT_FOUND, "").into_response(); }; let size = meta.len(); let range = headers .get(header::RANGE) .and_then(|v| v.to_str().ok()) .and_then(|r| parse_range(r, size)); let fname = std::path::Path::new(&rec.file) .file_name() .map(|f| f.to_string_lossy().to_string()) .unwrap_or_default(); let disp = HeaderValue::from_str(&format!("inline; filename=\"{}\"", fname.replace('"', ""))) .unwrap_or(HeaderValue::from_static("inline")); match range { Some((start, end)) => { if f.seek(std::io::SeekFrom::Start(start)).await.is_err() { return (StatusCode::RANGE_NOT_SATISFIABLE, "").into_response(); } let len = end - start + 1; let body = Body::from_stream(ReaderStream::new(f.take(len))); let mut res = Response::new(body); *res.status_mut() = StatusCode::PARTIAL_CONTENT; let h = res.headers_mut(); h.insert(header::CONTENT_TYPE, HeaderValue::from_static("video/mp2t")); h.insert(header::CONTENT_LENGTH, HeaderValue::from(len)); h.insert(header::ACCEPT_RANGES, HeaderValue::from_static("bytes")); h.insert( header::CONTENT_RANGE, HeaderValue::from_str(&format!("bytes {start}-{end}/{size}")).unwrap(), ); h.insert(header::CONTENT_DISPOSITION, disp); res } None if headers.contains_key(header::RANGE) => ( [(header::CONTENT_RANGE, format!("bytes */{size}"))], StatusCode::RANGE_NOT_SATISFIABLE, ) .into_response(), None => { let mut res = Response::new(Body::from_stream(ReaderStream::new(f))); let h = res.headers_mut(); h.insert(header::CONTENT_TYPE, HeaderValue::from_static("video/mp2t")); h.insert(header::CONTENT_LENGTH, HeaderValue::from(size)); h.insert(header::ACCEPT_RANGES, HeaderValue::from_static("bytes")); h.insert(header::CONTENT_DISPOSITION, disp); res } } } /// Pojedynczy zakres "bytes=a-b" / "bytes=a-" / "bytes=-n". pub fn parse_range(h: &str, size: u64) -> Option<(u64, u64)> { let r = h.trim().strip_prefix("bytes=")?; if r.contains(',') || size == 0 { return None; } let (a, b) = r.split_once('-')?; let (start, end) = if a.is_empty() { let n: u64 = b.parse().ok()?; (size.saturating_sub(n), size - 1) } else { let s: u64 = a.parse().ok()?; let e: u64 = if b.is_empty() { size - 1 } else { b.parse::().ok()?.min(size - 1) }; (s, e) }; (start <= end && start < size).then_some((start, end)) } // ------------------------------------------------------------ Prometheus /// Prometheus metrics (access like streams: local network, token or session). pub async fn metrics( AxState(state): AxState, ConnectInfo(peer): ConnectInfo, headers: HeaderMap, Query(q): Query, ) -> Response { if let Err(r) = recording_access(&state, peer, &headers, &q).await { return r; } use std::fmt::Write; let mut o = String::new(); let lbl = |s: &str| s.replace('\\', "\\\\").replace('"', "\\\""); let _ = writeln!(o, "# HELP simply_dvb_info Wersja serwera\n# TYPE simply_dvb_info gauge\nsimply_dvb_info{{version=\"{}\"}} 1", env!("CARGO_PKG_VERSION")); let _ = writeln!( o, "# TYPE simply_dvb_uptime_seconds counter\nsimply_dvb_uptime_seconds {}", state.started.elapsed().as_secs() ); let tuners = state.tuners.status(); let gauges = [ ("simply_dvb_tuner_active", "Tuner dostrojony (1/0)"), ("simply_dvb_tuner_locked", "Synchronizacja (lock)"), ("simply_dvb_tuner_signal_percent", "Signal strength %"), ("simply_dvb_tuner_signal_dbm", "Signal strength dBm"), ("simply_dvb_tuner_snr_db", "SNR dB"), ("simply_dvb_tuner_uncorrected_blocks", "Uncorrected blocks"), ("simply_dvb_tuner_bitrate_bps", "Multiplex bitrate b/s"), ("simply_dvb_tuner_subscribers", "Klienci tunera"), ]; for (name, help) in gauges { let _ = writeln!(o, "# HELP {name} {help}\n# TYPE {name} gauge"); for t in &tuners { let a = t.active.as_ref(); let sig = a.map(|a| &a.signal); let v: Option = match name { "simply_dvb_tuner_active" => Some(a.is_some() as u8 as f64), "simply_dvb_tuner_locked" => Some(sig.is_some_and(|s| s.locked) as u8 as f64), "simply_dvb_tuner_signal_percent" => sig.and_then(|s| s.strength_pct), "simply_dvb_tuner_signal_dbm" => sig.and_then(|s| s.strength_dbm), "simply_dvb_tuner_snr_db" => sig.and_then(|s| s.snr_db), "simply_dvb_tuner_uncorrected_blocks" => { sig.and_then(|s| s.uncorrected).map(|x| x as f64) } "simply_dvb_tuner_bitrate_bps" => Some(a.map_or(0, |a| a.bitrate_bps) as f64), _ => Some(a.map_or(0, |a| a.subscribers) as f64), }; if let Some(v) = v { let mux = a.map(|a| a.tuning.clone()).unwrap_or_default(); let _ = writeln!( o, "{name}{{adapter=\"{}\",name=\"{}\",mux=\"{}\"}} {v}", lbl(&t.id), lbl(&t.name), lbl(&mux) ); } } } let clients = state.clients.list(); let _ = writeln!(o, "# TYPE simply_dvb_clients gauge"); for kind in ["ts", "hls", "recording"] { let n = clients.iter().filter(|c| c.kind == kind).count(); let _ = writeln!(o, "simply_dvb_clients{{kind=\"{kind}\"}} {n}"); } let sent: u64 = clients .iter() .map(|c| c.bytes.load(std::sync::atomic::Ordering::Relaxed)) .sum(); let _ = writeln!( o, "# TYPE simply_dvb_clients_bytes gauge\nsimply_dvb_clients_bytes {sent}" ); if let Ok(chs) = state.db.channels().await { let _ = writeln!(o, "# TYPE simply_dvb_channels gauge\nsimply_dvb_channels{{enabled=\"true\"}} {}\nsimply_dvb_channels{{enabled=\"false\"}} {}", chs.iter().filter(|c| c.enabled).count(), chs.iter().filter(|c| !c.enabled).count()); } if let Ok(n) = state.db.epg_count().await { let _ = writeln!( o, "# TYPE simply_dvb_epg_events gauge\nsimply_dvb_epg_events {n}" ); } if let Ok(recs) = state.db.recordings().await { let _ = writeln!(o, "# TYPE simply_dvb_recordings gauge"); for st in ["scheduled", "recording", "completed", "failed", "cancelled"] { let _ = writeln!( o, "simply_dvb_recordings{{status=\"{st}\"}} {}", recs.iter().filter(|r| r.status == st).count() ); } let _ = writeln!( o, "# TYPE simply_dvb_recordings_bytes gauge\nsimply_dvb_recordings_bytes {}", recs.iter().map(|r| r.size).sum::() ); } if let Some(free) = crate::recorder::free_space(&state.recordings_dir()) { let _ = writeln!(o, "# TYPE simply_dvb_recordings_free_bytes gauge\nsimply_dvb_recordings_free_bytes {free}"); } let sessions = state .hls .list() .iter() .filter(|s| !s.done.load(std::sync::atomic::Ordering::Relaxed)) .count(); let _ = writeln!( o, "# TYPE simply_dvb_hls_sessions gauge\nsimply_dvb_hls_sessions {sessions}" ); ( [( header::CONTENT_TYPE, "text/plain; version=0.0.4; charset=utf-8", )], o, ) .into_response() } #[cfg(test)] mod tests { use super::parse_range; #[test] fn ranges() { assert_eq!(parse_range("bytes=0-99", 1000), Some((0, 99))); assert_eq!(parse_range("bytes=900-", 1000), Some((900, 999))); assert_eq!(parse_range("bytes=-100", 1000), Some((900, 999))); assert_eq!(parse_range("bytes=500-5000", 1000), Some((500, 999))); assert_eq!(parse_range("bytes=1000-", 1000), None); assert_eq!(parse_range("bytes=0-1,5-6", 1000), None); } }