first commit
build / test (push) Canceled after 0s
build / deb (amd64) (push) Canceled after 0s
build / deb (arm64) (push) Canceled after 0s
build / deb (armhf) (push) Canceled after 0s

This commit is contained in:
Mateusz Gruszczyński committed 2026-11-16 16:19:21 +01:00
commit c30064b531
93 files changed
+26367

No files matched your search

+308
View File
@@ -0,0 +1,308 @@
//! HTTP server: panel (SPA), JSON API and public stream endpoints.
pub mod api;
pub mod assets;
pub mod public;
pub mod tvh;
mod tvhapi;
use crate::app::State;
use crate::auth;
use crate::db::User;
use crate::settings::ip_in;
use axum::extract::{ConnectInfo, Request, State as AxState};
use axum::http::{Method, StatusCode};
use axum::middleware::{self, Next};
use axum::response::{IntoResponse, Response};
use axum::routing::{get, post, put};
use axum::{Json, Router};
use std::net::SocketAddr;
#[derive(Debug)]
pub struct ApiError(pub StatusCode, pub String);
impl ApiError {
pub fn bad(msg: impl Into<String>) -> Self {
ApiError(StatusCode::BAD_REQUEST, msg.into())
}
pub fn not_found(msg: impl Into<String>) -> Self {
ApiError(StatusCode::NOT_FOUND, msg.into())
}
pub fn forbidden() -> Self {
ApiError(StatusCode::FORBIDDEN, "permission denied".into())
}
}
impl From<anyhow::Error> for ApiError {
fn from(e: anyhow::Error) -> Self {
ApiError(StatusCode::INTERNAL_SERVER_ERROR, format!("{e:#}"))
}
}
impl IntoResponse for ApiError {
fn into_response(self) -> Response {
(self.0, Json(serde_json::json!({ "error": self.1 }))).into_response()
}
}
pub type ApiResult<T> = Result<Json<T>, ApiError>;
/// Signed-in user (inserted by middleware).
#[derive(Clone)]
pub struct CurrentUser(pub User);
async fn api_guard(
AxState(state): AxState<State>,
ConnectInfo(peer): ConnectInfo<SocketAddr>,
mut req: Request,
next: Next,
) -> Response {
let ip = auth::client_ip(&state, peer, req.headers());
{
let s = state.settings.read().unwrap();
if !s.panel_allow_cidrs.is_empty() && !ip_in(&s.panel_allow_cidrs, ip) {
return ApiError(
StatusCode::FORBIDDEN,
"panel not available from this network".into(),
)
.into_response();
}
}
let path = req.uri().path().to_string();
let method = req.method().clone();
let mutating = !matches!(method, Method::GET | Method::HEAD | Method::OPTIONS);
// CSRF protection: state-changing requests must carry a header that only the panel JS sets.
if mutating
&& req
.headers()
.get("x-requested-with")
.and_then(|v| v.to_str().ok())
!= Some("simply-dvb")
{
return ApiError(
StatusCode::FORBIDDEN,
"missing X-Requested-With header".into(),
)
.into_response();
}
if path == "/api/login" || path == "/api/info" {
return next.run(req).await;
}
let Some(user) = auth::session_user(&state, req.headers()).await else {
return ApiError(StatusCode::UNAUTHORIZED, "login required".into()).into_response();
};
let viewer_ok = path == "/api/logout" || path == "/api/me/password";
if mutating && user.role != "admin" && !viewer_ok {
return ApiError::forbidden().into_response();
}
req.extensions_mut().insert(CurrentUser(user));
next.run(req).await
}
/// Logs every request on the stream port (category "access"), so it is visible what a
/// TV or app asks for – including paths simply-dvb does not provide.
async fn request_log(
AxState(state): AxState<State>,
ConnectInfo(peer): ConnectInfo<SocketAddr>,
req: Request,
next: Next,
) -> Response {
let method = req.method().clone();
let uri = req.uri().clone();
let ip = auth::client_ip(&state, peer, req.headers());
let ua: String = req
.headers()
.get(axum::http::header::USER_AGENT)
.and_then(|v| v.to_str().ok())
.unwrap_or("-")
.chars()
.take(120)
.collect();
let started = std::time::Instant::now();
let res = next.run(req).await;
let status = res.status();
let path = uri.path();
// hide tokens in the logged query string
let query = uri
.query()
.map(|q| {
url::form_urlencoded::parse(q.as_bytes())
.map(|(k, v)| {
if matches!(&*k, "token" | "auth" | "ticket") {
format!("{k}=***")
} else {
format!("{k}={v}")
}
})
.collect::<Vec<_>>()
.join("&")
})
.filter(|q| !q.is_empty())
.map(|q| format!("?{q}"))
.unwrap_or_default();
let ms = started.elapsed().as_millis();
let noisy = path.starts_with("/hls/")
|| path.starts_with("/imagecache/")
|| path.starts_with("/icons/")
|| path == "/healthz"
|| path == "/metrics";
if status.is_client_error() || status.is_server_error() {
tracing::warn!(target: "access", "{ip} {method} {path}{query} → {} ({ms} ms) · {ua}", status.as_u16());
} else if noisy {
tracing::debug!(target: "access", "{ip} {method} {path}{query} → {} ({ms} ms) · {ua}", status.as_u16());
} else {
tracing::info!(target: "access", "{ip} {method} {path}{query} → {} ({ms} ms) · {ua}", status.as_u16());
}
res
}
async fn security_headers(req: Request, next: Next) -> Response {
let mut res = next.run(req).await;
let h = res.headers_mut();
h.entry("x-content-type-options")
.or_insert("nosniff".parse().unwrap());
h.entry("referrer-policy")
.or_insert("same-origin".parse().unwrap());
res
}
pub fn router(state: State) -> Router {
let api = Router::new()
.route("/api/info", get(api::info))
.route("/api/login", post(api::login))
.route("/api/logout", post(api::logout))
.route("/api/me", get(api::me))
.route("/api/me/password", post(api::change_password))
.route("/api/status", get(api::status))
.route("/api/stats", get(api::stats))
.route("/api/logs", get(api::logs))
.route("/api/logs/download", get(api::logs_download))
.route("/api/recordings/schedule", get(api::recordings_schedule))
.route("/api/adapters", get(api::adapters))
.route("/api/adapters/refresh", post(api::adapters_refresh))
.route("/api/adapters/{id}", put(api::adapter_update))
.route("/api/muxes", get(api::muxes).post(api::mux_create))
.route(
"/api/muxes/{id}",
put(api::mux_update).delete(api::mux_delete),
)
.route("/api/services", get(api::services))
.route(
"/api/scan",
get(api::scan_status)
.post(api::scan_start)
.delete(api::scan_cancel),
)
.route("/api/scan/presets", get(api::scan_presets))
.route(
"/api/channels",
get(api::channels).post(api::channel_create),
)
.route("/api/channels/order", post(api::channels_order))
.route("/api/channels/probe", post(api::channels_probe))
.route(
"/api/channels/icons/search",
post(api::icons_search).get(api::icons_search_status),
)
.route(
"/api/channels/{id}",
put(api::channel_update).delete(api::channel_delete),
)
.route("/api/channels/{id}/share", post(api::channel_share))
.route(
"/api/channels/{id}/icon",
post(api::channel_icon_upload).delete(api::channel_icon_delete),
)
.route("/api/epg", get(api::epg))
.route("/api/epg/grab", post(api::epg_grab))
.route("/api/epg/xmltv", post(api::epg_xmltv))
.route("/api/epg/status", get(api::epg_status))
.route("/api/epg/xmltv/channels", get(api::xmltv_channels))
.route(
"/api/recordings",
get(api::recordings).post(api::recording_create),
)
.route(
"/api/recordings/{id}",
put(api::recording_update).delete(api::recording_delete),
)
.route("/api/recordings/{id}/stop", post(api::recording_stop))
.route("/api/autorec", get(api::autorecs).post(api::autorec_create))
.route("/api/autorec/preview", get(api::autorec_preview))
.route(
"/api/autorec/{id}",
put(api::autorec_update).delete(api::autorec_delete),
)
.route("/api/backup", get(api::backup))
.route("/api/restore", post(api::restore))
.route(
"/api/settings",
get(api::settings_get).put(api::settings_put),
)
.route("/api/users", get(api::users).post(api::user_create))
.route(
"/api/users/{id}",
put(api::user_update).delete(api::user_delete),
)
.route("/api/tokens", get(api::tokens).post(api::token_create))
.route(
"/api/tokens/{id}",
put(api::token_update).delete(api::token_delete),
)
.route("/api/clients", get(api::clients))
.route("/api/links", get(api::links))
.layer(axum::extract::DefaultBodyLimit::max(16 * 1024 * 1024))
.layer(middleware::from_fn_with_state(state.clone(), api_guard));
// streams and the tvheadend JSON API work on the panel port as well (tvheadend serves both on
// one port, so apps keep working whichever port they are pointed at); requests are logged
let shared = public_routes()
.merge(tvhapi::routes())
.layer(middleware::from_fn_with_state(state.clone(), request_log));
Router::new()
.merge(api)
.merge(shared)
.merge(assets::routes())
.layer(middleware::from_fn(security_headers))
.with_state(state)
}
/// Stream, playlist and EPG endpoints – shared by the panel port and the stream port.
fn public_routes() -> Router<State> {
Router::new()
// natywne
.route("/playlist.m3u", get(public::playlist))
.route("/playlist.m3u8", get(public::playlist))
.route("/epg.xml", get(public::epg_xml))
.route("/hls/{ch}/index.m3u8", get(public::hls_playlist))
.route("/hls/{ch}/{seg}", get(public::hls_segment))
.route("/stream/{ch}", get(public::ts_stream))
.route("/icons/{id}", get(public::icon))
.route("/watch/{token}", get(public::watch_page))
.route(
"/recordings/{id}/index.m3u8",
get(public::recording_playlist),
)
.route("/recordings/{id}/file", get(public::recording_file))
.route("/metrics", get(public::metrics))
.route("/healthz", get(|| async { "ok" }))
// tvheadend-compatible
.route("/playlist", get(tvh::playlist_all))
.route("/playlist/{a}", get(tvh::playlist_all_sub))
.route("/playlist/{kind}/{key}", get(tvh::playlist_one))
.route("/stream/{kind}/{key}", get(tvh::stream))
.route("/xmltv", get(public::epg_xml))
.route("/xmltv/{a}", get(public::epg_xml))
.route("/imagecache/{id}", get(public::icon))
}
/// Stream port router (9981 by default, like tvheadend's HTTP): no panel and no API.
pub fn stream_router(state: State) -> Router {
Router::new()
.merge(public_routes())
.merge(tvhapi::routes())
.merge(assets::stream_routes())
.layer(middleware::from_fn(security_headers))
.layer(middleware::from_fn_with_state(state.clone(), request_log))
.with_state(state)
}