Proxy podcast audio from publishers on request

Browsers stream episode audio from the publisher by default. For
publishers they cannot play directly (CORS, mixed content), the
administrator can enable podcast_audio_proxy_enabled (admin Settings,
FURU_PODCAST_AUDIO_PROXY_ENABLED). The endpoints live in a new app at
/api/podcasts:

- GET /episodes/{episode_id}/audio streams an episode of the signed-in
  account. The URL comes from the account's catalog, never from the
  request. Requests go through SafeHttp with one sanitized byte Range and
  no client headers; 200/206/416 pass through, only audio content types
  are served, with nosniff and a sandbox CSP, and responses stop at 1 GiB
  or 4 hours.
- GET /episodes/{episode_id}/source returns the publisher URL and, when
  enabled, the proxy URL.
- POST /{podcast_id}/refresh refreshes one subscribed feed now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
sanapachandClaude Opus 5.5 committed 2026-11-20 15:12:38 +02:00
1 parent bf9a6abc3f
commit 2c0c3d21aa
12 files changed
+1164 -5

No files matched your search

+11
View File
@@ -545,6 +545,8 @@ struct AdminSettingsValues {
youtube_proxy_id: String,
#[serde(default)]
youtube_cookie_id: String,
#[serde(default)]
podcast_audio_proxy_enabled: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
@@ -615,6 +617,7 @@ struct AdminSettingsSources {
torrent_proxy_id: &'static str,
youtube_proxy_id: &'static str,
youtube_cookie_id: &'static str,
podcast_audio_proxy_enabled: &'static str,
}
#[derive(Debug, Deserialize)]
@@ -667,6 +670,8 @@ pub(super) struct UpdateSettingsRequest {
youtube_proxy_id: String,
#[serde(default)]
youtube_cookie_id: String,
#[serde(default)]
podcast_audio_proxy_enabled: bool,
}
fn default_similarity_model() -> String {
@@ -1370,6 +1375,10 @@ pub async fn update_settings(
("torrent_proxy_id", torrent_proxy_id),
("youtube_proxy_id", youtube_proxy_id),
("youtube_cookie_id", youtube_cookie_id),
(
"podcast_audio_proxy_enabled",
body.podcast_audio_proxy_enabled.to_string(),
),
];
for (key, value) in fields {
let mut entry = ConfigEntry::new(key.to_string(), value);
@@ -1714,6 +1723,7 @@ fn settings_dto(
torrent_proxy_id: config.torrent_proxy_id,
youtube_proxy_id: config.youtube_proxy_id,
youtube_cookie_id: config.youtube_cookie_id,
podcast_audio_proxy_enabled: config.podcast_audio_proxy_enabled,
},
sources: AdminSettingsSources {
auth_password_enabled: sources.auth_password_enabled.code(),
@@ -1750,6 +1760,7 @@ fn settings_dto(
torrent_proxy_id: sources.torrent_proxy_id.code(),
youtube_proxy_id: sources.youtube_proxy_id.code(),
youtube_cookie_id: sources.youtube_cookie_id.code(),
podcast_audio_proxy_enabled: sources.podcast_audio_proxy_enabled.code(),
},
}
}
+10
View File
@@ -149,6 +149,7 @@ pub struct ConfigSources {
pub torrent_proxy_id: ConfigSource,
pub youtube_proxy_id: ConfigSource,
pub youtube_cookie_id: ConfigSource,
pub podcast_audio_proxy_enabled: ConfigSource,
}
impl Default for ConfigSources {
@@ -190,6 +191,7 @@ impl Default for ConfigSources {
torrent_proxy_id: ConfigSource::Default,
youtube_proxy_id: ConfigSource::Default,
youtube_cookie_id: ConfigSource::Default,
podcast_audio_proxy_enabled: ConfigSource::Default,
}
}
}
@@ -407,6 +409,10 @@ pub struct AppConfig {
pub youtube_proxy_id: String,
/// Saved cookie-file id used by yt-dlp; empty means no cookies.
pub youtube_cookie_id: String,
/// Whether the server proxies podcast episode audio from publishers for
/// browsers that cannot load it directly (CORS, mixed content). Off by
/// default: browsers stream from the publisher URL.
pub podcast_audio_proxy_enabled: bool,
}
impl Default for AppConfig {
@@ -451,6 +457,7 @@ impl Default for AppConfig {
torrent_proxy_id: String::new(),
youtube_proxy_id: String::new(),
youtube_cookie_id: String::new(),
podcast_audio_proxy_enabled: false,
}
}
}
@@ -493,6 +500,7 @@ impl_env_overrides!(
torrent_proxy_id,
youtube_proxy_id,
youtube_cookie_id,
podcast_audio_proxy_enabled,
);
impl AppConfig {
@@ -636,6 +644,7 @@ impl AppConfig {
apply_db_field!(torrent_proxy_id);
apply_db_field!(youtube_proxy_id);
apply_db_field!(youtube_cookie_id);
apply_db_field!(podcast_audio_proxy_enabled);
}
pub fn parsed_download_proxies(&self) -> anyhow::Result<Vec<DownloadProxy>> {
@@ -693,6 +702,7 @@ mod tests {
assert!(cfg.torrent_downloads_enabled);
assert!(cfg.youtube_downloads_enabled);
assert!(cfg.parsed_download_proxies().unwrap().is_empty());
assert!(!cfg.podcast_audio_proxy_enabled);
}
#[test]
+8
View File
@@ -477,6 +477,10 @@ impl Project for FuruProject {
" API:\n",
" FURU_SWAGGER_ENABLED Enable Swagger UI at /swagger/ (default: false)\n",
"\n",
" Podcasts:\n",
" FURU_PODCAST_AUDIO_PROXY_ENABLED Stream episode audio through this\n",
" server (default: false)\n",
"\n",
"QUICK START\n",
" export FURU_DATABASE_URL=postgres://user:pass@localhost/furumusic\n",
" furumusic run",
@@ -581,6 +585,10 @@ impl Project for FuruProject {
"/admin",
);
apps.register_with_views(api::ApiApp, "/api");
apps.register_with_views(
podcasts::http::PodcastsApp::new(Arc::clone(&self.app_config)),
"/api/podcasts",
);
apps.register_with_views(
player::PlayerApp::new(
Arc::clone(&self.app_config),
+379
View File
@@ -0,0 +1,379 @@
//! HTTP endpoints of the podcast runtime, mounted at `/api/podcasts`:
//!
//! * `POST /{podcast_id}/refresh` — manual feed refresh of a subscribed
//! podcast (ignores the failure backoff, at most every 30 s).
//! * `GET /episodes/{episode_id}/source` — how the browser gets the audio:
//! the publisher URL (default, the browser streams it directly) and the
//! proxy URL when the administrator enabled the proxy.
//! * `GET /episodes/{episode_id}/audio` — the optional audio proxy
//! (`podcast_audio_proxy_enabled`). It takes an episode id, never a URL,
//! and only serves episodes of the signed-in account.
use std::sync::Arc;
use cot::db::Database;
use cot::http::StatusCode;
use cot::http::header::{
ACCEPT_RANGES, CACHE_CONTROL, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, RANGE, RETRY_AFTER,
};
use cot::json::Json;
use cot::request::extractors::Path;
use cot::response::IntoResponse;
use cot::router::method::{get, post};
use cot::router::{Route, Router};
use cot::session::Session;
use cot::{App, Body};
use futures_util::TryStreamExt;
use music_dht::podcast::{EpisodeId, PodcastId};
use serde::{Deserialize, Serialize};
use super::fetch::FeedFetcher;
use super::proxy::AudioProxy;
use super::runner::{self, ManualRefreshError, TargetResult};
use super::{PodcastStore, now_ms};
use crate::auth;
use crate::config::AppConfig;
fn json_error(status: StatusCode, message: &str) -> cot::response::Response {
let body = serde_json::json!({ "error": message });
cot::http::Response::builder()
.status(status)
.header(CONTENT_TYPE, "application/json")
.header(CACHE_CONTROL, "private, no-store")
.body(Body::fixed(body.to_string()))
.expect("valid response")
}
fn internal(error: impl std::fmt::Display) -> cot::Error {
cot::Error::internal(error.to_string())
}
/// Shared state of the handlers.
#[derive(Clone)]
struct State {
config: Arc<AppConfig>,
pool: Arc<tokio::sync::OnceCell<sqlx::PgPool>>,
fetcher: Arc<tokio::sync::OnceCell<FeedFetcher>>,
proxy: Arc<tokio::sync::OnceCell<AudioProxy>>,
}
impl State {
async fn store(&self) -> cot::Result<PodcastStore> {
let pool = self
.pool
.get_or_try_init(|| async {
sqlx::postgres::PgPoolOptions::new()
.max_connections(5)
.connect(&self.config.database_url)
.await
})
.await
.map_err(internal)?;
Ok(PodcastStore::new(pool.clone()))
}
async fn fetcher(&self) -> cot::Result<&FeedFetcher> {
self.fetcher
.get_or_try_init(|| async { FeedFetcher::new() })
.await
.map_err(internal)
}
async fn proxy(&self) -> cot::Result<&AudioProxy> {
self.proxy
.get_or_try_init(|| async { AudioProxy::new() })
.await
.map_err(internal)
}
}
/// The podcast runtime endpoints (see the module documentation).
pub(crate) struct PodcastsApp {
state: State,
}
impl PodcastsApp {
pub(crate) fn new(config: Arc<AppConfig>) -> Self {
Self {
state: State {
config,
pool: Arc::new(tokio::sync::OnceCell::new()),
fetcher: Arc::new(tokio::sync::OnceCell::new()),
proxy: Arc::new(tokio::sync::OnceCell::new()),
},
}
}
}
#[derive(Debug, Deserialize)]
struct PodcastPath {
podcast_id: String,
}
#[derive(Debug, Deserialize)]
struct EpisodePath {
episode_id: String,
}
/// Path of the proxy endpoint for an episode.
pub(crate) fn proxy_path(episode_id: &EpisodeId) -> String {
format!("/api/podcasts/episodes/{episode_id}/audio")
}
#[derive(Debug, Serialize)]
struct RefreshResponse {
status: &'static str,
new_episodes: usize,
updated_episodes: usize,
unchanged_episodes: usize,
skipped_items: usize,
feed_url: Option<String>,
error: Option<String>,
next_check_at_ms: Option<i64>,
}
impl RefreshResponse {
fn from_result(result: TargetResult) -> Self {
let mut response = Self {
status: "",
new_episodes: 0,
updated_episodes: 0,
unchanged_episodes: 0,
skipped_items: 0,
feed_url: None,
error: None,
next_check_at_ms: None,
};
match result {
TargetResult::Updated(outcome) => {
response.status = "updated";
response.new_episodes = outcome.new_episodes;
response.updated_episodes = outcome.updated_episodes;
response.unchanged_episodes = outcome.unchanged_episodes;
response.skipped_items = outcome.skipped_items;
response.feed_url = outcome.feed_url.map(String::from);
}
TargetResult::NotModified => response.status = "not_modified",
TargetResult::Failed {
error,
next_check_at_ms,
..
} => {
response.status = "failed";
response.error = Some(error);
response.next_check_at_ms = Some(next_check_at_ms);
}
TargetResult::Skipped(reason) => {
response.status = "skipped";
response.error = Some(reason);
}
}
response
}
}
async fn refresh_handler(
state: State,
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<PodcastPath>,
) -> cot::Result<cot::response::Response> {
let Some(user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let Ok(podcast_id) = PodcastId::parse(&path.0.podcast_id) else {
return Ok(json_error(StatusCode::BAD_REQUEST, "invalid podcast id"));
};
let store = state.store().await?;
let fetcher = state.fetcher().await?;
match runner::refresh_now(&store, fetcher, user.id, &podcast_id, now_ms()).await {
Ok(result) => Json(RefreshResponse::from_result(result)).into_response(),
Err(error) => match error.downcast_ref::<ManualRefreshError>() {
Some(ManualRefreshError::UnknownPodcast) => {
Ok(json_error(StatusCode::NOT_FOUND, "unknown podcast"))
}
Some(ManualRefreshError::NotSubscribed) => {
Ok(json_error(StatusCode::CONFLICT, &error.to_string()))
}
Some(ManualRefreshError::TooSoon { retry_after_ms }) => {
let mut response = json_error(StatusCode::TOO_MANY_REQUESTS, &error.to_string());
response.headers_mut().insert(
RETRY_AFTER,
((retry_after_ms + 999) / 1000)
.to_string()
.parse()
.expect("digits"),
);
Ok(response)
}
None => Err(internal(format!("{error:#}"))),
},
}
}
#[derive(Debug, Serialize)]
struct SourceResponse {
episode_id: String,
/// Publisher URL; the browser streams it directly by default.
direct_url: String,
/// Same-origin proxy path, only when the proxy is enabled.
proxy_url: Option<String>,
mime: Option<String>,
}
async fn source_handler(
state: State,
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<EpisodePath>,
) -> cot::Result<cot::response::Response> {
let Some(user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let Ok(episode_id) = EpisodeId::parse(&path.0.episode_id) else {
return Ok(json_error(StatusCode::BAD_REQUEST, "invalid episode id"));
};
let store = state.store().await?;
let Some((audio_url, mime)) = store
.audio_source(user.id, &episode_id)
.await
.map_err(internal)?
else {
return Ok(json_error(StatusCode::NOT_FOUND, "unknown episode"));
};
let (config, _) = AppConfig::load_with_db(&db).await;
let mut response = Json(SourceResponse {
proxy_url: config
.podcast_audio_proxy_enabled
.then(|| proxy_path(&episode_id)),
episode_id: episode_id.to_string(),
direct_url: audio_url,
mime,
})
.into_response()?;
response
.headers_mut()
.insert(CACHE_CONTROL, "private, no-store".parse().expect("static"));
Ok(response)
}
async fn audio_handler(
state: State,
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<EpisodePath>,
request: cot::request::Request,
) -> cot::Result<cot::response::Response> {
let Some(user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let (config, _) = AppConfig::load_with_db(&db).await;
if !config.podcast_audio_proxy_enabled {
return Ok(json_error(
StatusCode::NOT_FOUND,
"the podcast audio proxy is disabled; stream from the publisher URL",
));
}
let Ok(episode_id) = EpisodeId::parse(&path.0.episode_id) else {
return Ok(json_error(StatusCode::BAD_REQUEST, "invalid episode id"));
};
let store = state.store().await?;
// The URL comes from this account's catalog, never from the request.
let Some((audio_url, mime)) = store
.audio_source(user.id, &episode_id)
.await
.map_err(internal)?
else {
return Ok(json_error(StatusCode::NOT_FOUND, "unknown episode"));
};
let range = request
.headers()
.get(RANGE)
.and_then(|value| value.to_str().ok());
let proxy = state.proxy().await?;
let audio = match proxy.fetch(&audio_url, mime.as_deref(), range).await {
Ok(audio) => audio,
Err(error) => {
tracing::info!(user_id = user.id, episode = %episode_id, "podcast proxy: {error}");
let status =
StatusCode::from_u16(error.http_status()).unwrap_or(StatusCode::BAD_GATEWAY);
return Ok(json_error(status, &error.to_string()));
}
};
let mut builder = cot::http::Response::builder()
.status(StatusCode::from_u16(audio.status).unwrap_or(StatusCode::BAD_GATEWAY))
.header(CACHE_CONTROL, "private, no-store")
.header("X-Content-Type-Options", "nosniff")
.header("Content-Security-Policy", "default-src 'none'; sandbox")
.header("Content-Disposition", "inline");
if let Some(content_type) = &audio.content_type {
builder = builder.header(CONTENT_TYPE, content_type.as_str());
}
if let Some(length) = audio.content_length {
builder = builder.header(CONTENT_LENGTH, length.to_string());
}
if let Some(content_range) = &audio.content_range {
builder = builder.header(CONTENT_RANGE, content_range.as_str());
}
if audio.accept_ranges {
builder = builder.header(ACCEPT_RANGES, "bytes");
}
let body = audio
.body
.map_err(|error| cot::Error::internal(error.to_string()));
builder.body(Body::streaming(body)).map_err(internal)
}
impl App for PodcastsApp {
fn name(&self) -> &'static str {
"podcasts"
}
fn router(&self) -> Router {
let refresh_state = self.state.clone();
let source_state = self.state.clone();
let audio_state = self.state.clone();
Router::with_urls([
Route::with_handler_and_name(
"/episodes/{episode_id}/source",
get(
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<EpisodePath>| {
source_handler(source_state.clone(), auth_ctx, session, db, path)
},
),
"podcasts_episode_source",
),
Route::with_handler_and_name(
"/episodes/{episode_id}/audio",
get(
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<EpisodePath>,
request: cot::request::Request| {
audio_handler(audio_state.clone(), auth_ctx, session, db, path, request)
},
),
"podcasts_episode_audio",
),
Route::with_handler_and_name(
"/{podcast_id}/refresh",
post(
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<PodcastPath>| {
refresh_handler(refresh_state.clone(), auth_ctx, session, db, path)
},
),
"podcasts_refresh",
),
])
}
}
+19 -3
View File
@@ -41,17 +41,31 @@
//!
//! RSS refreshes ([`PodcastStore::apply_feed`]) touch the catalog and the
//! alias set only; they never write a register, progress or a session.
//!
//! # Runtime
//!
//! * `net` — the SSRF-guarded HTTP client used for every feed and audio
//! request (public addresses only, checked per connection and per
//! redirect hop).
//! * `fetch` and [`runner`] — conditional feed downloads and their schedule
//! (hourly checks, exponential backoff, one request per feed URL), run by
//! the `podcast_refresh` job and the manual refresh endpoint.
//! * `proxy` and [`http`] — the optional audio proxy and the
//! `/api/podcasts` endpoints. Audio is streamed from the publisher, never
//! stored.
// The podcast UI and its HTTP API, which call the local actions and most
// queries, land in the next commits of this series; until then only sync,
// the refresh job and the tests use the store. Remove this allowance with
// them.
// the refresh job, the proxy endpoints and the tests use the store. Remove
// this allowance with them.
#![allow(dead_code, unused_imports)]
mod actions;
mod apply;
mod fetch;
pub(crate) mod http;
mod net;
mod proxy;
mod queries;
mod refresh;
pub(crate) mod runner;
@@ -64,6 +78,8 @@ mod net_tests;
#[cfg(test)]
pub(crate) mod postgres_tests;
#[cfg(test)]
mod proxy_tests;
#[cfg(test)]
pub(crate) mod test_server;
#[cfg(test)]
mod tests;
@@ -80,11 +96,11 @@ use sqlx::postgres::PgRow;
pub(crate) use actions::{CheckpointOutcome, ProgressSession, ProgressWrite, SubscribeOutcome};
pub(crate) use apply::{ApplyOutcome, SnapshotApplyStats};
pub(crate) use fetch::FeedFetcher;
pub(crate) use queries::{
EpisodeListItem, EpisodeQuery, EpisodeSort, PlayedFilter, PodcastListFilter,
PodcastListenEntry, PodcastSummary, SeasonFilter, SeasonSummary,
};
pub(crate) use fetch::FeedFetcher;
pub(crate) use refresh::{FeedRefresh, FetchState, RefreshOutcome};
/// Typed errors of [`PodcastStore`]; other failures are database errors.
+7
View File
@@ -1566,6 +1566,13 @@ async fn postgres_podcast_refresh_job_schedules_backs_off_and_moves_feeds() {
let episode_id = episodes[0].episode.episode_id.clone();
assert_eq!(episodes[0].episode.audio_url, server.url("/audio/one.mp3"));
// The proxy and the source endpoint only find episodes of the account.
assert_eq!(
store.audio_source(a, &episode_id).await.unwrap(),
Some((server.url("/audio/one.mp3"), Some("audio/mpeg".to_string())))
);
assert_eq!(store.audio_source(c, &episode_id).await.unwrap(), None);
// Nothing is due before the interval; afterwards the request is
// conditional and the catalog stays as it is.
assert!(due_for(&store, &users, t0 + 1000).await.is_empty());
+360
View File
@@ -0,0 +1,360 @@
//! Optional audio proxy: streams a stored episode enclosure from the
//! publisher for browsers that cannot load it directly (CORS, mixed
//! content). Audio is passed through, never stored or imported.
//!
//! The caller resolves the URL from the database for an episode of the
//! authenticated account; a client never supplies a URL. Requests go
//! through [`SafeHttp`] (SSRF guard, every redirect hop checked), carry
//! only `Range`, `Accept`, `Accept-Encoding: identity` and the user agent,
//! and responses are limited in size, time and content type.
use std::fmt;
use std::time::Duration;
use bytes::Bytes;
use futures_util::StreamExt;
use futures_util::stream::BoxStream;
use reqwest::header::{
ACCEPT, ACCEPT_ENCODING, ACCEPT_RANGES, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, HeaderMap,
HeaderValue, RANGE,
};
use reqwest::{StatusCode, Url};
use super::net::{GuardError, SafeHttp, SafeHttpConfig};
/// Largest response body passed through (a long episode at a high bitrate
/// stays far below).
pub(crate) const MAX_PROXY_BYTES: u64 = 1024 * 1024 * 1024;
/// Upstream must answer with headers within this time.
pub(crate) const PROXY_HEADER_TIMEOUT: Duration = Duration::from_secs(20);
/// Longest a single proxied response may stream.
pub(crate) const PROXY_MAX_DURATION: Duration = Duration::from_secs(4 * 60 * 60);
/// Redirect hops followed (enclosures often go through tracking redirects).
pub(crate) const MAX_PROXY_REDIRECTS: usize = 5;
/// HTTP client settings of the proxy (no whole-request timeout: bodies are
/// streamed; the idle read timeout and [`PROXY_MAX_DURATION`] bound them).
pub(crate) const PROXY_HTTP: SafeHttpConfig = SafeHttpConfig {
connect_timeout: Duration::from_secs(10),
read_timeout: Duration::from_secs(30),
total_timeout: None,
max_redirects: MAX_PROXY_REDIRECTS,
};
/// Why a proxied request failed.
#[derive(Debug)]
pub(crate) enum ProxyError {
/// The stored URL is not a valid URL.
InvalidUrl(String),
/// Refused or failed in transport (see [`GuardError`]).
Upstream(GuardError),
/// The publisher answered with an unusable status.
Status(u16),
/// The publisher's content type is not audio.
ContentType(String),
/// Declared body larger than [`MAX_PROXY_BYTES`].
TooLarge(u64),
/// No response headers within [`PROXY_HEADER_TIMEOUT`].
Timeout,
/// The body stream stopped (limit reached or upstream failure).
Body(String),
}
impl ProxyError {
/// Status the proxy answers the browser with.
pub(crate) fn http_status(&self) -> u16 {
match self {
Self::Timeout => 504,
Self::Upstream(error) if error.is_timeout() => 504,
_ => 502,
}
}
}
impl fmt::Display for ProxyError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidUrl(reason) => write!(f, "stored audio URL is invalid: {reason}"),
Self::Upstream(error) => write!(f, "publisher request failed: {error}"),
Self::Status(status) => write!(f, "publisher answered HTTP {status}"),
Self::ContentType(value) => write!(f, "publisher content type {value:?} is not audio"),
Self::TooLarge(len) => write!(
f,
"publisher response is too large ({len} bytes, limit {MAX_PROXY_BYTES})"
),
Self::Timeout => write!(
f,
"publisher did not answer within {} s",
PROXY_HEADER_TIMEOUT.as_secs()
),
Self::Body(reason) => write!(f, "publisher stream failed: {reason}"),
}
}
}
impl std::error::Error for ProxyError {}
impl From<GuardError> for ProxyError {
fn from(error: GuardError) -> Self {
Self::Upstream(error)
}
}
/// A proxied response, ready to be sent to the browser.
pub(crate) struct ProxiedAudio {
/// 200, 206 or 416.
pub(crate) status: u16,
/// Allow-listed audio type (absent on 416).
pub(crate) content_type: Option<String>,
pub(crate) content_length: Option<u64>,
/// `bytes a-b/n` (206) or `bytes */n` (416).
pub(crate) content_range: Option<String>,
/// Whether the publisher advertised byte ranges.
pub(crate) accept_ranges: bool,
/// The body, cut off at [`MAX_PROXY_BYTES`] and [`PROXY_MAX_DURATION`].
pub(crate) body: BoxStream<'static, Result<Bytes, ProxyError>>,
}
impl fmt::Debug for ProxiedAudio {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ProxiedAudio")
.field("status", &self.status)
.field("content_type", &self.content_type)
.field("content_length", &self.content_length)
.field("content_range", &self.content_range)
.field("accept_ranges", &self.accept_ranges)
.finish_non_exhaustive()
}
}
/// Keeps a browser `Range` header only when it is one well-formed byte
/// range (`bytes=a-`, `bytes=a-b`, `bytes=-n`); anything else is dropped
/// and the full resource is requested.
pub(crate) fn sanitize_range(value: &str) -> Option<String> {
let spec = value.trim().strip_prefix("bytes=")?.trim();
if spec.len() > 64 {
return None;
}
let (start, end) = spec.split_once('-')?;
let digits = |s: &str| !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit());
let ok = match (start.is_empty(), end.is_empty()) {
(false, true) => digits(start) && start.parse::<u64>().is_ok(),
(false, false) => {
digits(start)
&& digits(end)
&& matches!((start.parse::<u64>(), end.parse::<u64>()), (Ok(a), Ok(b)) if a <= b)
}
(true, false) => digits(end) && end.parse::<u64>().is_ok_and(|n| n > 0),
(true, true) => false,
};
ok.then(|| format!("bytes={start}-{end}"))
}
/// `Content-Range` of a 206/416 passed through only when well-formed.
fn sanitize_content_range(value: &str) -> Option<String> {
let rest = value.trim().strip_prefix("bytes ")?;
let (range, total) = rest.split_once('/')?;
let total_ok = total == "*" || total.parse::<u64>().is_ok();
let range_ok = range == "*"
|| range.split_once('-').is_some_and(
|(a, b)| matches!((a.parse::<u64>(), b.parse::<u64>()), (Ok(a), Ok(b)) if a <= b),
);
(total_ok && range_ok && !(range == "*" && total == "*")).then(|| value.trim().to_string())
}
fn is_audio_type(mime: &str) -> bool {
let mime = mime.trim().to_ascii_lowercase();
let essence = mime.split(';').next().unwrap_or_default().trim();
(essence.starts_with("audio/") && essence.len() > "audio/".len())
|| matches!(essence, "application/ogg" | "application/x-ogg")
}
/// Audio type implied by the URL path's extension.
fn audio_type_from_url(url: &Url) -> Option<&'static str> {
let ext = url.path().rsplit('/').next()?.rsplit_once('.')?.1;
Some(match ext.to_ascii_lowercase().as_str() {
"mp3" => "audio/mpeg",
"m4a" | "m4b" | "mp4" => "audio/mp4",
"aac" => "audio/aac",
"ogg" | "oga" => "audio/ogg",
"opus" => "audio/ogg",
"flac" => "audio/flac",
"wav" => "audio/wav",
_ => return None,
})
}
/// The content type sent to the browser: the publisher's when it is audio;
/// for a generic binary type, the stored enclosure type or the URL
/// extension when those are audio; otherwise the response is refused.
fn audio_content_type(
upstream: Option<&str>,
stored: Option<&str>,
url: &Url,
) -> Result<String, ProxyError> {
let upstream = upstream.map(str::trim).filter(|value| !value.is_empty());
if let Some(value) = upstream
&& is_audio_type(value)
{
return Ok(value.to_string());
}
let generic = upstream.is_none_or(|value| {
let essence = value.split(';').next().unwrap_or_default().trim();
essence.eq_ignore_ascii_case("application/octet-stream")
|| essence.eq_ignore_ascii_case("binary/octet-stream")
});
if generic {
if let Some(stored) = stored.filter(|value| is_audio_type(value)) {
return Ok(stored.trim().to_string());
}
if let Some(guess) = audio_type_from_url(url) {
return Ok(guess.to_string());
}
}
Err(ProxyError::ContentType(
upstream.unwrap_or("(none)").to_string(),
))
}
/// Streams episode enclosures from publishers.
#[derive(Debug, Clone)]
pub(crate) struct AudioProxy {
http: SafeHttp,
max_bytes: u64,
max_duration: Duration,
}
impl AudioProxy {
/// The production proxy (public addresses only).
pub(crate) fn new() -> anyhow::Result<Self> {
Ok(Self::with_http(SafeHttp::public(PROXY_HTTP)?))
}
pub(crate) fn with_http(http: SafeHttp) -> Self {
Self {
http,
max_bytes: MAX_PROXY_BYTES,
max_duration: PROXY_MAX_DURATION,
}
}
#[cfg(test)]
pub(crate) fn with_limits(mut self, max_bytes: u64, max_duration: Duration) -> Self {
self.max_bytes = max_bytes;
self.max_duration = max_duration;
self
}
/// Requests `audio_url` (from the database) with the browser's `Range`
/// (sanitized). `stored_mime` is the enclosure type from the feed.
pub(crate) async fn fetch(
&self,
audio_url: &str,
stored_mime: Option<&str>,
range: Option<&str>,
) -> Result<ProxiedAudio, ProxyError> {
let url =
Url::parse(audio_url).map_err(|error| ProxyError::InvalidUrl(error.to_string()))?;
let mut headers = HeaderMap::new();
headers.insert(ACCEPT, HeaderValue::from_static("audio/*, */*;q=0.1"));
// Byte ranges must address the stored bytes, not a compressed form.
headers.insert(ACCEPT_ENCODING, HeaderValue::from_static("identity"));
let range = range.and_then(sanitize_range);
if let Some(range) = &range {
headers.insert(
RANGE,
HeaderValue::from_str(range).expect("sanitized range is a valid header"),
);
}
let followed = tokio::time::timeout(PROXY_HEADER_TIMEOUT, self.http.get(url, &headers))
.await
.map_err(|_| ProxyError::Timeout)??;
let response = followed.response;
let final_url = followed.final_url;
let status = response.status();
let header = |name| {
response
.headers()
.get(name)
.and_then(|value: &HeaderValue| value.to_str().ok())
.map(str::to_string)
};
let content_range = header(CONTENT_RANGE)
.as_deref()
.and_then(sanitize_content_range);
if status == StatusCode::RANGE_NOT_SATISFIABLE {
return Ok(ProxiedAudio {
status: 416,
content_type: None,
content_length: Some(0),
content_range,
accept_ranges: true,
body: futures_util::stream::empty().boxed(),
});
}
let partial = status == StatusCode::PARTIAL_CONTENT;
// 206 only answers a range we asked for, and must say which bytes.
if !(status == StatusCode::OK || (partial && range.is_some() && content_range.is_some())) {
return Err(ProxyError::Status(status.as_u16()));
}
let content_type =
audio_content_type(header(CONTENT_TYPE).as_deref(), stored_mime, &final_url)?;
let content_length = header(CONTENT_LENGTH).and_then(|value| value.parse::<u64>().ok());
if let Some(len) = content_length
&& len > self.max_bytes
{
return Err(ProxyError::TooLarge(len));
}
let accept_ranges = partial
|| header(ACCEPT_RANGES)
.is_some_and(|value| value.trim().eq_ignore_ascii_case("bytes"));
Ok(ProxiedAudio {
status: status.as_u16(),
content_type: Some(content_type),
content_length,
content_range: if partial { content_range } else { None },
accept_ranges,
body: limited_body(response, self.max_bytes, self.max_duration),
})
}
}
/// The upstream body, ending with an error once `max_bytes` would be
/// exceeded or `max_duration` has passed. Dropping it (browser gone or
/// seeking elsewhere) closes the upstream connection.
fn limited_body(
response: reqwest::Response,
max_bytes: u64,
max_duration: Duration,
) -> BoxStream<'static, Result<Bytes, ProxyError>> {
let deadline = tokio::time::Instant::now() + max_duration;
async_stream::stream! {
let mut upstream = response.bytes_stream();
let mut sent: u64 = 0;
loop {
let next = match tokio::time::timeout_at(deadline, upstream.next()).await {
Ok(next) => next,
Err(_) => {
yield Err(ProxyError::Body("time limit reached".to_string()));
break;
}
};
match next {
None => break,
Some(Ok(chunk)) => {
sent += chunk.len() as u64;
if sent > max_bytes {
yield Err(ProxyError::Body(format!("size limit of {max_bytes} bytes reached")));
break;
}
yield Ok(chunk);
}
Some(Err(error)) => {
yield Err(ProxyError::Body(GuardError::from(error).to_string()));
break;
}
}
}
}
.boxed()
}
+323
View File
@@ -0,0 +1,323 @@
//! Audio proxy: Range pass-through, servers without ranges, redirects,
//! content types and limits, against the local test server.
use std::time::Duration;
use futures_util::StreamExt;
use futures_util::stream::BoxStream;
use super::net::{AddressClass, GuardError};
use super::proxy::{AudioProxy, ProxyError, sanitize_range};
use std::sync::Arc;
use super::test_server::{Route, ScriptedLookup, TestServer, noise, test_http};
// ---------------------------------------------------------------------------
// Audio proxy
// ---------------------------------------------------------------------------
#[test]
fn only_single_byte_ranges_are_forwarded() {
assert_eq!(sanitize_range("bytes=0-").as_deref(), Some("bytes=0-"));
assert_eq!(
sanitize_range("bytes=100-199").as_deref(),
Some("bytes=100-199")
);
assert_eq!(
sanitize_range(" bytes=-500 ").as_deref(),
Some("bytes=-500")
);
for invalid in [
"bytes=1-2,5-6",
"items=0-10",
"bytes=5-1",
"bytes=-",
"bytes=-0",
"bytes=a-b",
"bytes=1-2\r\nCookie: x",
"bytes=99999999999999999999999-",
"",
] {
assert_eq!(sanitize_range(invalid), None, "{invalid:?}");
}
}
async fn collect(
mut body: BoxStream<'static, Result<bytes::Bytes, ProxyError>>,
) -> (Vec<u8>, Option<String>) {
let mut out = Vec::new();
while let Some(chunk) = body.next().await {
match chunk {
Ok(chunk) => out.extend_from_slice(&chunk),
Err(error) => return (out, Some(error.to_string())),
}
}
(out, None)
}
fn proxy(lookup: Arc<ScriptedLookup>) -> AudioProxy {
AudioProxy::with_http(test_http(lookup))
}
#[tokio::test]
async fn proxy_passes_ranges_through() {
let server = TestServer::start();
let audio = noise(300_000, 7);
server.set("/ep.mp3", Route::new(audio.clone(), "audio/mpeg"));
let proxy = proxy(ScriptedLookup::with(&[]));
let target = server.url("/ep.mp3");
let full = proxy.fetch(&target, None, None).await.unwrap();
assert_eq!(full.status, 200);
assert_eq!(full.content_type.as_deref(), Some("audio/mpeg"));
assert_eq!(full.content_length, Some(audio.len() as u64));
assert!(full.accept_ranges);
assert_eq!(full.content_range, None);
assert_eq!(collect(full.body).await, (audio.clone(), None));
for (range, start, end) in [
("bytes=1000-1999", 1000, 2000),
("bytes=299000-", 299_000, 300_000),
("bytes=-500", 299_500, 300_000),
("bytes=0-", 0, 300_000),
] {
let part = proxy.fetch(&target, None, Some(range)).await.unwrap();
assert_eq!(part.status, 206, "{range}");
assert_eq!(
part.content_range,
Some(format!("bytes {start}-{}/{}", end - 1, audio.len())),
"{range}"
);
assert_eq!(part.content_length, Some((end - start) as u64));
assert_eq!(collect(part.body).await, (audio[start..end].to_vec(), None));
}
let unsatisfiable = proxy
.fetch(&target, None, Some("bytes=400000-"))
.await
.unwrap();
assert_eq!(unsatisfiable.status, 416);
assert_eq!(
unsatisfiable.content_range,
Some(format!("bytes */{}", audio.len()))
);
assert_eq!(collect(unsatisfiable.body).await, (Vec::new(), None));
// Malformed or multi-range requests fetch the whole file.
let whole = proxy
.fetch(&target, None, Some("bytes=5-6,9-10"))
.await
.unwrap();
assert_eq!(whole.status, 200);
let requests = server.requests("/ep.mp3");
let ranges: Vec<Option<&str>> = requests
.iter()
.map(|request| request.get("range").map(String::as_str))
.collect();
assert_eq!(
ranges,
vec![
None,
Some("bytes=1000-1999"),
Some("bytes=299000-"),
Some("bytes=-500"),
Some("bytes=0-"),
Some("bytes=400000-"),
None,
]
);
for request in &requests {
assert_eq!(request["accept-encoding"], "identity");
assert!(!request.contains_key("cookie"));
assert!(!request.contains_key("authorization"));
}
}
#[tokio::test]
async fn proxy_handles_servers_without_ranges_and_redirects() {
let server = TestServer::start();
let audio = noise(50_000, 3);
server.set(
"/plain.mp3",
Route::new(audio.clone(), "audio/mpeg").no_ranges(),
);
server.set("/track/ep.mp3", Route::redirect(302, "/cdn/ep.mp3"));
server.set("/cdn/ep.mp3", Route::new(audio.clone(), "audio/mpeg"));
server.set(
"/track/private.mp3",
Route::redirect(302, "http://172.20.0.3/ep.mp3"),
);
let proxy = proxy(ScriptedLookup::with(&[]));
// No range support: the whole file with 200 and no Accept-Ranges, so the
// browser knows it cannot seek by range.
let plain = proxy
.fetch(&server.url("/plain.mp3"), None, Some("bytes=100-"))
.await
.unwrap();
assert_eq!(plain.status, 200);
assert!(!plain.accept_ranges);
assert_eq!(plain.content_range, None);
assert_eq!(collect(plain.body).await.0, audio);
// Tracking redirects keep the range on every hop.
let part = proxy
.fetch(&server.url("/track/ep.mp3"), None, Some("bytes=10-19"))
.await
.unwrap();
assert_eq!(part.status, 206);
assert_eq!(collect(part.body).await.0, audio[10..20].to_vec());
assert_eq!(server.requests("/track/ep.mp3")[0]["range"], "bytes=10-19");
assert_eq!(server.requests("/cdn/ep.mp3")[0]["range"], "bytes=10-19");
match proxy
.fetch(&server.url("/track/private.mp3"), None, None)
.await
{
Err(ProxyError::Upstream(GuardError::Blocked(blocked))) => {
assert_eq!(blocked.class, AddressClass::Private)
}
other => panic!("{other:?}"),
}
}
#[tokio::test]
async fn proxy_only_serves_audio() {
let server = TestServer::start();
let audio = noise(1000, 5);
server.set(
"/page.mp3",
Route::new("<script>alert(1)</script>", "text/html"),
);
server.set("/video.mp4", Route::new(audio.clone(), "video/mp4"));
server.set(
"/binary",
Route::new(audio.clone(), "application/octet-stream"),
);
server.set(
"/binary.m4a",
Route::new(audio.clone(), "binary/octet-stream"),
);
server.set(
"/untyped.ogg",
Route::new(audio.clone(), "x").no_content_type(),
);
server.set("/ogg", Route::new(audio.clone(), "application/ogg"));
server.set(
"/typed",
Route::new(audio.clone(), "audio/mp4; codecs=\"mp4a.40.2\""),
);
server.set("/missing", Route::new("", "text/plain").status(404));
server.set("/error", Route::new("", "audio/mpeg").status(500));
let proxy = proxy(ScriptedLookup::with(&[]));
let content_type = |path: &'static str, stored: Option<&'static str>| {
let proxy = proxy.clone();
let target = server.url(path);
async move {
proxy
.fetch(&target, stored, None)
.await
.map(|audio| audio.content_type.unwrap())
}
};
assert!(matches!(
content_type("/page.mp3", Some("audio/mpeg")).await,
Err(ProxyError::ContentType(_))
));
assert!(matches!(
content_type("/video.mp4", Some("audio/mpeg")).await,
Err(ProxyError::ContentType(_))
));
assert_eq!(
content_type("/binary", Some("audio/mpeg")).await.unwrap(),
"audio/mpeg"
);
assert!(matches!(
content_type("/binary", Some("text/html")).await,
Err(ProxyError::ContentType(_))
));
assert_eq!(
content_type("/binary.m4a", None).await.unwrap(),
"audio/mp4"
);
assert_eq!(
content_type("/untyped.ogg", None).await.unwrap(),
"audio/ogg"
);
assert_eq!(content_type("/ogg", None).await.unwrap(), "application/ogg");
assert_eq!(
content_type("/typed", None).await.unwrap(),
"audio/mp4; codecs=\"mp4a.40.2\""
);
let missing = content_type("/missing", None).await.unwrap_err();
assert!(matches!(missing, ProxyError::Status(404)));
assert_eq!(missing.http_status(), 502);
assert!(matches!(
content_type("/error", None).await,
Err(ProxyError::Status(500))
));
assert!(matches!(
proxy.fetch("not a url", None, None).await,
Err(ProxyError::InvalidUrl(_))
));
}
#[tokio::test]
async fn proxy_limits_size_and_reports_dropped_streams() {
let server = TestServer::start();
let audio = noise(100_000, 9);
server.set("/sized.mp3", Route::new(audio.clone(), "audio/mpeg"));
server.set(
"/chunked.mp3",
Route::new(audio.clone(), "audio/mpeg").no_length(),
);
server.set(
"/cut.mp3",
Route::new(audio.clone(), "audio/mpeg").cut(40_000),
);
let limited = proxy(ScriptedLookup::with(&[])).with_limits(60_000, Duration::from_secs(60));
assert!(matches!(
limited.fetch(&server.url("/sized.mp3"), None, None).await,
Err(ProxyError::TooLarge(100_000))
));
// A range below the limit is fine.
let part = limited
.fetch(&server.url("/sized.mp3"), None, Some("bytes=0-49999"))
.await
.unwrap();
assert_eq!(collect(part.body).await, (audio[..50_000].to_vec(), None));
// Without a declared length the stream stops at the limit.
let chunked = limited
.fetch(&server.url("/chunked.mp3"), None, None)
.await
.unwrap();
let (received, error) = collect(chunked.body).await;
assert!(received.len() <= 60_000);
assert!(error.unwrap().contains("size limit"));
// A connection dropped mid-body ends the stream with an error instead
// of a silently truncated success.
let cut = proxy(ScriptedLookup::with(&[]))
.fetch(&server.url("/cut.mp3"), None, None)
.await
.unwrap();
let (received, error) = collect(cut.body).await;
assert!(received.len() <= 40_000);
assert!(error.is_some());
}
#[tokio::test]
async fn proxy_stream_has_a_time_limit() {
let server = TestServer::start();
server.set(
"/slow.mp3",
Route::new(noise(10, 1), "audio/mpeg").delay_body(Duration::from_secs(3)),
);
let limited = proxy(ScriptedLookup::with(&[])).with_limits(1 << 20, Duration::from_millis(300));
let audio = limited
.fetch(&server.url("/slow.mp3"), None, None)
.await
.unwrap();
let (_, error) = collect(audio.body).await;
assert!(error.unwrap().contains("time limit"));
}
+21
View File
@@ -661,4 +661,25 @@ impl PodcastStore {
.await?;
Ok(count(total))
}
/// Audio URL and enclosure type of an episode in this account's catalog
/// (`None` when the account does not know the episode). The audio proxy
/// and the playback source endpoint take URLs only from here.
pub(crate) async fn audio_source(
&self,
user_id: i64,
episode_id: &EpisodeId,
) -> Result<Option<(String, Option<String>)>> {
let row = sqlx::query(
"SELECT audio_url, mime FROM furumusic__podcast_episode
WHERE user_id = $1 AND episode_id = $2",
)
.bind(user_id)
.bind(episode_id.as_str())
.fetch_optional(&self.pool)
.await?;
Ok(row
.map(|row| Ok::<_, sqlx::Error>((row.try_get("audio_url")?, row.try_get("mime")?)))
.transpose()?)
}
}