Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
use super::{hubcloud, parser};
use crate::providers::models::{
CatalogItem, MediaDetails, PlaybackSource, ProviderKind, Release, ResolutionIntent,
};
use reqwest::Url;
const DEFAULT_BASE_URL: &str = "https://4khdhub.one/";
const BROWSER_UA: &str = crate::net::DEFAULT_BROWSER_USER_AGENT;
#[derive(thiserror::Error, Debug)]
pub enum FourKHdHubError {
#[error("network error: {0}")]
Network(#[from] reqwest::Error),
#[error("invalid provider URL: {0}")]
InvalidUrl(String),
#[error("parse error: {0}")]
Parse(String),
#[error("no playable mirrors: {0}")]
NoPlayableMirror(String),
}
impl FourKHdHubError {
pub fn user_message(&self) -> &'static str {
match self {
Self::Network(err) => {
if err.is_timeout() {
"4KHDHub timed out."
} else if let Some(status) = err.status() {
match status.as_u16() {
403 => "4KHDHub blocked (HTTP 403).",
404 => "4KHDHub page not found (HTTP 404).",
429 => "4KHDHub rate limited (HTTP 429).",
500..=599 => "4KHDHub server error.",
_ => "Cannot reach 4KHDHub.",
}
} else {
"Cannot reach 4KHDHub."
}
}
Self::InvalidUrl(_) => "Invalid 4KHDHub URL.",
Self::Parse(_) => "4KHDHub parse error.",
Self::NoPlayableMirror(reason) => {
let lower = reason.to_ascii_lowercase();
if lower.contains("timed out") || lower.contains("timeout") {
"4KHDHub mirror probe timed out."
} else if lower.contains("quota") {
"4KHDHub mirror quota exceeded."
} else if lower.contains("expired") {
"4KHDHub mirror link expired."
} else {
"No working 4KHDHub mirrors found."
}
}
}
}
}
type PageCache = std::sync::Arc<std::sync::Mutex<Option<(String, std::time::Instant, String)>>>;
#[derive(Clone)]
pub struct FourKHdHubClient {
client: reqwest::Client,
base_url: Url,
page_cache: PageCache,
}
impl FourKHdHubClient {
pub fn new() -> Result<Self, FourKHdHubError> {
let base = std::env::var("MOVIEBOX_FOURKHDHUB_URL")
.unwrap_or_else(|_| DEFAULT_BASE_URL.to_string());
Self::with_base_url(&base)
}
pub fn with_base_url(base: &str) -> Result<Self, FourKHdHubError> {
let base_url =
Url::parse(base).map_err(|_| FourKHdHubError::InvalidUrl(base.to_string()))?;
if base_url.scheme() != "https" {
return Err(FourKHdHubError::InvalidUrl(base.to_string()));
}
Ok(Self {
client: build_client(),
base_url,
page_cache: std::sync::Arc::new(std::sync::Mutex::new(None)),
})
}
pub async fn health_check(&self) -> Result<(), FourKHdHubError> {
let response = self.client.get(self.base_url.clone()).send().await?;
if !response.status().is_success() {
return Err(FourKHdHubError::Parse(format!(
"health check returned {}",
response.status()
)));
}
Ok(())
}
pub async fn search(&self, query: &str) -> Result<Vec<CatalogItem>, FourKHdHubError> {
let mut url = self.base_url.clone();
url.query_pairs_mut().append_pair("s", query);
let html = self.fetch_text(url).await?;
parser::parse_search(&self.base_url, &html)
}
async fn fetch_cached_page(&self, id: &str) -> Result<String, FourKHdHubError> {
let url = self.provider_url(id)?;
let key = url.as_str().to_string();
if let Ok(lock) = self.page_cache.lock()
&& let Some((cached_key, ts, html)) = lock.as_ref()
&& cached_key == &key
&& ts.elapsed() < std::time::Duration::from_secs(60)
{
return Ok(html.clone());
}
let html = self.fetch_text(url).await?;
if let Ok(mut lock) = self.page_cache.lock() {
*lock = Some((key, std::time::Instant::now(), html.clone()));
}
Ok(html)
}
pub async fn details(&self, id: &str) -> Result<MediaDetails, FourKHdHubError> {
let html = self.fetch_cached_page(id).await?;
parser::parse_details(id, &html)
}
pub async fn releases(
&self,
id: &str,
season: usize,
episode: usize,
) -> Result<Vec<Release>, FourKHdHubError> {
let html = self.fetch_cached_page(id).await?;
parser::parse_releases(&html, season, episode)
}
pub async fn resolve_release(
&self,
release: &Release,
intent: ResolutionIntent,
) -> Result<PlaybackSource, FourKHdHubError> {
if release.provider != ProviderKind::FourKHdHub {
return Err(FourKHdHubError::Parse(
"release belongs to another provider".into(),
));
}
let referer = self.base_url.as_str().trim_end_matches('/').to_string();
use futures::StreamExt;
let mut resolve_tasks = futures::stream::FuturesUnordered::new();
for mirror in &release.mirrors {
let client = self.client.clone();
let mirror_url = mirror.resolver_url.clone();
let mirror_label = mirror.label.clone();
let mirror_headers = mirror.headers.clone();
resolve_tasks.push(async move {
let fetch = async {
if mirror_url.contains("hubcloud.") {
hubcloud::resolve(&client, &mirror_url, intent).await
} else if mirror_url.contains("hubdrive.") {
hubcloud::resolve_hubdrive(&client, &mirror_url, intent).await
} else if mirror_url.contains("greenmotors.")
|| mirror_url.contains("greenmountmotors.")
{
hubcloud::resolve_greenmotors(&client, &mirror_url, intent).await
} else {
hubcloud::validate_playback_url(&mirror_url)
.map(|url| vec![(url, mirror_label, mirror_headers)])
}
};
tokio::time::timeout(std::time::Duration::from_millis(7000), fetch)
.await
.map_err(|_| {
FourKHdHubError::NoPlayableMirror("mirror resolver timed out".into())
})
.and_then(|res| res)
});
}
let mut preflight_tasks = futures::stream::FuturesUnordered::new();
let mut seen = std::collections::HashSet::new();
let mut spawned_preflights = 0usize;
let mut fallbacks = Vec::new();
loop {
tokio::select! {
Some(resolve_res) = resolve_tasks.next(), if !resolve_tasks.is_empty() => {
if let Ok(mut cand_list) = resolve_res {
cand_list.sort_by_key(|(url, label, _)| hubcloud::score(url, label, intent));
for (url, label, headers) in cand_list {
if spawned_preflights >= 6 || !seen.insert(url.clone()) {
continue;
}
spawned_preflights += 1;
let cand_score = hubcloud::score(&url, &label, intent);
let this = self.clone();
let mut merged = headers;
if !merged
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case("referer"))
{
merged.push(("Referer".to_string(), referer.clone()));
}
if !merged
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case("user-agent"))
{
merged.push(("User-Agent".to_string(), BROWSER_UA.to_string()));
}
preflight_tasks.push(async move {
let (playable_url, is_seekable) =
this.preflight_with_seekable(&url, &merged).await?;
let resolved_score =
cand_score.min(hubcloud::score(&playable_url, &label, intent));
Ok::<_, FourKHdHubError>((
is_seekable,
resolved_score,
playable_url,
label,
merged,
))
});
}
}
}
Some(preflight_res) = preflight_tasks.next(), if !preflight_tasks.is_empty() => {
if let Ok((is_seekable, resolved_score, playable_url, label, headers)) =
preflight_res
{
if is_seekable && resolved_score <= 1 {
log::info!(
"4KHDHub seekable mirror playable: {label} ({})",
crate::logging::sanitize_url(&playable_url)
);
return Ok(PlaybackSource {
provider: ProviderKind::FourKHdHub,
url: playable_url,
headers,
subtitle: None,
source_label: label,
max_height: None,
});
}
fallbacks.push((is_seekable, resolved_score, playable_url, label, headers));
}
}
else => break,
}
}
if spawned_preflights == 0 {
return Err(FourKHdHubError::NoPlayableMirror(
"no working mirror links extracted".into(),
));
}
fallbacks
.sort_by_key(|(is_seekable, resolved_score, _, _, _)| (!*is_seekable, *resolved_score));
if let Some((_, _, playable_url, label, headers)) = fallbacks.into_iter().next() {
log::info!(
"4KHDHub fallback mirror playable: {label} ({})",
crate::logging::sanitize_url(&playable_url)
);
return Ok(PlaybackSource {
provider: ProviderKind::FourKHdHub,
url: playable_url,
headers,
subtitle: None,
source_label: label,
max_height: None,
});
}
log::error!(
"4KHDHub: no playable mirror for release {:?}",
release.filename
);
Err(FourKHdHubError::NoPlayableMirror(
"all candidate mirrors failed preflight".into(),
))
}
pub async fn preflight(
&self,
url: &str,
headers: &[(String, String)],
) -> Result<String, FourKHdHubError> {
self.preflight_with_seekable(url, headers)
.await
.map(|(u, _)| u)
}
async fn preflight_with_seekable(
&self,
url: &str,
headers: &[(String, String)],
) -> Result<(String, bool), FourKHdHubError> {
let probe = async {
hubcloud::validate_playback_url(url)?;
let mut request = self
.client
.get(url)
.header(reqwest::header::RANGE, "bytes=0-8191");
for (name, value) in headers {
request = request.header(name, value);
}
let response = request.send().await?.error_for_status()?;
let mut is_seekable = response.status() == reqwest::StatusCode::PARTIAL_CONTENT;
let mut final_url = response.url().clone();
hubcloud::validate_playback_url(final_url.as_str())?;
let content_type = response
.headers()
.get(reqwest::header::CONTENT_TYPE)
.and_then(|value| value.to_str().ok())
.unwrap_or_default()
.to_ascii_lowercase();
if content_type.contains("text/html")
|| content_type.contains("application/zip")
|| content_type.contains("text/plain")
{
let body_bytes = response.bytes().await.unwrap_or_default();
let body_lower = String::from_utf8_lossy(&body_bytes).to_ascii_lowercase();
if body_lower.contains("failed to extract link")
|| body_lower.contains("token expired")
|| body_lower.contains("file not found")
|| body_lower.contains("404 not found")
|| body_lower.contains("link has expired")
|| body_lower.contains("expired")
|| body_lower.contains("access denied")
|| body_lower.contains("downloadquotaexceeded")
|| body_lower.contains("generate link again")
{
return Err(FourKHdHubError::NoPlayableMirror(
"upstream mirror reported expired file link".into(),
));
}
let wrapped = final_url
.query_pairs()
.find(|(name, _)| name == "link")
.map(|(_, value)| value.into_owned())
.filter(|value| value.starts_with("https://"))
.ok_or_else(|| {
FourKHdHubError::NoPlayableMirror(format!(
"invalid media content type: {content_type}"
))
})?;
hubcloud::validate_playback_url(&wrapped)?;
let mut wrapped_request = self
.client
.get(&wrapped)
.header(reqwest::header::RANGE, "bytes=0-8191");
for (name, value) in headers {
wrapped_request = wrapped_request.header(name, value);
}
let wrapped_response = wrapped_request.send().await?.error_for_status()?;
is_seekable = wrapped_response.status() == reqwest::StatusCode::PARTIAL_CONTENT;
final_url = wrapped_response.url().clone();
hubcloud::validate_playback_url(final_url.as_str())?;
let wrapped_type = wrapped_response
.headers()
.get(reqwest::header::CONTENT_TYPE)
.and_then(|value| value.to_str().ok())
.unwrap_or_default()
.to_ascii_lowercase();
if wrapped_type.contains("text/html")
|| wrapped_type.contains("application/zip")
|| wrapped_type.contains("text/plain")
{
let wrapped_bytes = wrapped_response.bytes().await.unwrap_or_default();
let wrapped_lower =
String::from_utf8_lossy(&wrapped_bytes).to_ascii_lowercase();
if wrapped_lower.contains("failed to extract link")
|| wrapped_lower.contains("token expired")
|| wrapped_lower.contains("file not found")
|| wrapped_lower.contains("404 not found")
|| wrapped_lower.contains("expired")
|| wrapped_lower.contains("access denied")
|| wrapped_lower.contains("downloadquotaexceeded")
|| wrapped_lower.contains("generate link again")
{
return Err(FourKHdHubError::NoPlayableMirror(
"upstream mirror reported expired file link".into(),
));
}
return Err(FourKHdHubError::NoPlayableMirror(format!(
"invalid wrapped media content type: {wrapped_type}"
)));
}
}
Ok((final_url.to_string(), is_seekable))
};
tokio::time::timeout(std::time::Duration::from_millis(3500), probe)
.await
.map_err(|_| {
FourKHdHubError::NoPlayableMirror("mirror preflight probe timed out (3.5s)".into())
})?
}
async fn fetch_text(&self, url: Url) -> Result<String, FourKHdHubError> {
let response = self.client.get(url).send().await?.error_for_status()?;
Ok(response.text().await?)
}
fn provider_url(&self, id: &str) -> Result<Url, FourKHdHubError> {
let url = self
.base_url
.join(id.trim_start_matches('/'))
.map_err(|_| FourKHdHubError::InvalidUrl(id.to_string()))?;
if url.host_str() != self.base_url.host_str() {
return Err(FourKHdHubError::InvalidUrl(id.to_string()));
}
Ok(url)
}
}
fn build_client() -> reqwest::Client {
crate::net::http_client_builder()
.timeout(std::time::Duration::from_secs(20))
.connect_timeout(std::time::Duration::from_secs(5))
.user_agent(BROWSER_UA)
.redirect(reqwest::redirect::Policy::limited(5))
.build()
.unwrap_or_default()
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn rejects_non_fourkhdhub_release() {
let client = FourKHdHubClient::new().expect("client creation");
let release = Release {
provider: ProviderKind::MovieBox,
filename: "test.mkv".into(),
quality: None,
codec: None,
language: None,
size_bytes: None,
season: None,
episode: None,
mirrors: Vec::new(),
resource_id: None,
};
assert!(
client
.resolve_release(&release, ResolutionIntent::Playback)
.await
.is_err()
);
}
#[test]
fn validates_provider_url_host_matching() {
let client = FourKHdHubClient::new().expect("client creation");
assert!(client.provider_url("movie/inception-2010").is_ok());
assert!(client.provider_url("https://evil.com/movie").is_err());
}
#[tokio::test]
async fn preflight_blocks_loopback_ssrf_and_prioritizes_seekable_mirrors() {
let client = FourKHdHubClient::new().expect("client");
assert!(
client
.preflight("http://127.0.0.1:8080/video.mkv", &[])
.await
.is_err()
);
let mut candidates = [
(
false,
0_u8,
"https://r2.dev/unseekable.mkv",
"10Gbps Server",
),
(false, 4_u8, "https://workers.dev/quota.mkv", "HubCloud"),
(
true,
1_u8,
"https://pixeldrain.dev/seekable.mkv",
"PixelDrain",
),
];
candidates.sort_by_key(|(is_seekable, score, _, _)| (!*is_seekable, *score));
assert_eq!(candidates[0].2, "https://pixeldrain.dev/seekable.mkv");
assert_eq!(candidates[1].2, "https://r2.dev/unseekable.mkv");
assert_eq!(candidates[2].2, "https://workers.dev/quota.mkv");
}
}