342 lines
11 KiB
Rust
342 lines
11 KiB
Rust
use ntex::web;
|
|
use regex::Regex;
|
|
use std::collections::HashMap;
|
|
use url::Url;
|
|
|
|
use crate::util::requester::Requester;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct HqpornerProxy {}
|
|
|
|
impl HqpornerProxy {
|
|
pub fn new() -> Self {
|
|
Self {}
|
|
}
|
|
|
|
fn normalize_detail_request(endpoint: &str) -> Option<(String, Option<u16>)> {
|
|
let endpoint = endpoint.trim().trim_start_matches('/');
|
|
if endpoint.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
let (detail_part, quality) = match endpoint.split_once("/__quality__/") {
|
|
Some((detail, quality)) => {
|
|
let requested = quality
|
|
.trim()
|
|
.trim_end_matches('/')
|
|
.trim_end_matches('p')
|
|
.parse::<u16>()
|
|
.ok();
|
|
(detail, requested)
|
|
}
|
|
None => (endpoint, None),
|
|
};
|
|
|
|
let detail_url = if detail_part.starts_with("http://") || detail_part.starts_with("https://")
|
|
{
|
|
detail_part.to_string()
|
|
} else {
|
|
format!("https://{}", detail_part.trim_start_matches('/'))
|
|
};
|
|
|
|
Self::is_allowed_detail_url(&detail_url).then_some((detail_url, quality))
|
|
}
|
|
|
|
fn is_allowed_detail_url(url: &str) -> bool {
|
|
let Some(url) = Url::parse(url).ok() else {
|
|
return false;
|
|
};
|
|
if url.scheme() != "https" {
|
|
return false;
|
|
}
|
|
let Some(host) = url.host_str() else {
|
|
return false;
|
|
};
|
|
(host == "hqporner.com" || host == "www.hqporner.com") && url.path().starts_with("/hdporn/")
|
|
}
|
|
|
|
fn normalize_url(raw: &str) -> String {
|
|
let value = raw.trim();
|
|
if value.is_empty() {
|
|
return String::new();
|
|
}
|
|
if value.starts_with("//") {
|
|
return format!("https:{value}");
|
|
}
|
|
if value.starts_with('/') {
|
|
return format!("https://www.hqporner.com{value}");
|
|
}
|
|
if value.starts_with("http://") {
|
|
return value.replacen("http://", "https://", 1);
|
|
}
|
|
value.to_string()
|
|
}
|
|
|
|
fn regex(value: &str) -> Option<Regex> {
|
|
Regex::new(value).ok()
|
|
}
|
|
|
|
fn extract_player_url(detail_html: &str) -> Option<String> {
|
|
let pattern = r#"(?is)url\s*:\s*['"](/blocks/(?:altplayer|nativeplayer)\.php\?i=[^'"]+)['"]"#;
|
|
let captures = Self::regex(pattern)?.captures(detail_html)?;
|
|
let path = captures.get(1)?.as_str();
|
|
Some(Self::normalize_url(path))
|
|
}
|
|
|
|
fn extract_source_url(player_html: &str) -> Option<String> {
|
|
for source in player_html.split("<source ").skip(1) {
|
|
let src = source
|
|
.split("src=\\\"")
|
|
.nth(1)
|
|
.and_then(|s| s.split("\\\"").next())
|
|
.or_else(|| {
|
|
source
|
|
.split("src=\"")
|
|
.nth(1)
|
|
.and_then(|s| s.split('"').next())
|
|
})
|
|
.unwrap_or_default();
|
|
let url = Self::normalize_url(src);
|
|
if !url.is_empty() {
|
|
return Some(url);
|
|
}
|
|
}
|
|
|
|
let iframe_regexes = [
|
|
r#"(?is)<iframe[^>]+src="([^"]+)""#,
|
|
r#"(?is)<iframe[^>]+src='([^']+)'"#,
|
|
r#"(?is)src=\\\"([^\\"]+)\\\""#,
|
|
r#"(?is)src=\\'([^\\']+)\\'"#,
|
|
];
|
|
for pattern in iframe_regexes {
|
|
let Some(regex) = Self::regex(pattern) else {
|
|
continue;
|
|
};
|
|
if let Some(url) = regex
|
|
.captures(player_html)
|
|
.and_then(|caps| caps.get(1))
|
|
.map(|m| Self::normalize_url(m.as_str()))
|
|
.filter(|value| !value.is_empty())
|
|
{
|
|
return Some(url);
|
|
}
|
|
}
|
|
|
|
let source_regex = Self::regex(r#"src=\\\"([^\\"]+)\\\""#)?;
|
|
source_regex
|
|
.captures(player_html)
|
|
.and_then(|caps| caps.get(1))
|
|
.map(|m| Self::normalize_url(m.as_str()))
|
|
.filter(|value| !value.is_empty())
|
|
}
|
|
|
|
fn extract_quality_urls(video_page_html: &str) -> HashMap<u16, String> {
|
|
let mut urls = HashMap::new();
|
|
let Some(regex) =
|
|
Self::regex(r#"(?i)(?:https?:)?//[^"'\\\s]+/pubs/[A-Za-z0-9._-]+/(360|720|1080)\.mp4"#)
|
|
else {
|
|
return urls;
|
|
};
|
|
|
|
for captures in regex.captures_iter(video_page_html) {
|
|
let Some(full_match) = captures.get(0) else {
|
|
continue;
|
|
};
|
|
let Some(quality_match) = captures.get(1) else {
|
|
continue;
|
|
};
|
|
let Some(quality) = quality_match.as_str().parse::<u16>().ok() else {
|
|
continue;
|
|
};
|
|
let normalized = Self::normalize_url(full_match.as_str());
|
|
if !normalized.is_empty() {
|
|
urls.insert(quality, normalized);
|
|
}
|
|
}
|
|
|
|
urls
|
|
}
|
|
|
|
fn select_quality_url(quality_urls: &HashMap<u16, String>, requested: Option<u16>) -> Option<String> {
|
|
let fallbacks = match requested.unwrap_or(1080) {
|
|
1080 => [1080u16, 720, 360].as_slice(),
|
|
720 => [720u16, 360].as_slice(),
|
|
360 => [360u16].as_slice(),
|
|
other if other > 1080 => [1080u16, 720, 360].as_slice(),
|
|
other if other > 720 => [720u16, 360].as_slice(),
|
|
_ => [360u16].as_slice(),
|
|
};
|
|
|
|
for quality in fallbacks {
|
|
if let Some(url) = quality_urls.get(quality) {
|
|
return Some(url.clone());
|
|
}
|
|
}
|
|
|
|
if let Some(url) = quality_urls.get(&1080) {
|
|
return Some(url.clone());
|
|
}
|
|
if let Some(url) = quality_urls.get(&720) {
|
|
return Some(url.clone());
|
|
}
|
|
quality_urls.get(&360).cloned()
|
|
}
|
|
}
|
|
|
|
impl crate::proxies::Proxy for HqpornerProxy {
|
|
async fn get_video_url(&self, url: String, requester: web::types::State<Requester>) -> String {
|
|
let Some((detail_url, requested_quality)) = Self::normalize_detail_request(&url) else {
|
|
return String::new();
|
|
};
|
|
|
|
let mut requester = requester.get_ref().clone();
|
|
let headers = vec![("Referer".to_string(), "https://hqporner.com/".to_string())];
|
|
|
|
let detail_html = requester
|
|
.get_with_headers(&detail_url, headers.clone(), None)
|
|
.await
|
|
.unwrap_or_default();
|
|
if detail_html.is_empty() {
|
|
return String::new();
|
|
}
|
|
|
|
let mut source_page_url = String::new();
|
|
if let Some(player_url) = Self::extract_player_url(&detail_html) {
|
|
let player_html = requester
|
|
.get_with_headers(&player_url, headers.clone(), None)
|
|
.await
|
|
.unwrap_or_default();
|
|
if !player_html.is_empty() {
|
|
if let Some(url) = Self::extract_source_url(&player_html) {
|
|
source_page_url = url;
|
|
}
|
|
}
|
|
}
|
|
if source_page_url.is_empty() {
|
|
source_page_url = Self::extract_source_url(&detail_html).unwrap_or_default();
|
|
}
|
|
if source_page_url.is_empty() {
|
|
return String::new();
|
|
}
|
|
|
|
let source_page_html = requester
|
|
.get_with_headers(&source_page_url, headers, None)
|
|
.await
|
|
.unwrap_or_default();
|
|
if source_page_html.is_empty() {
|
|
return String::new();
|
|
}
|
|
|
|
let quality_urls = Self::extract_quality_urls(&source_page_html);
|
|
if quality_urls.is_empty() {
|
|
return String::new();
|
|
}
|
|
|
|
Self::select_quality_url(&quality_urls, requested_quality).unwrap_or_default()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::HqpornerProxy;
|
|
use std::collections::HashMap;
|
|
|
|
#[test]
|
|
fn extract_source_url_supports_iframe_src() {
|
|
let html = r#"<iframe width="560" height="350" src="//mydaddy.cc/video/f7cbb41e218d3b1dca/&alt" frameborder="0" allowfullscreen=""></iframe>"#;
|
|
let extracted = HqpornerProxy::extract_source_url(html);
|
|
assert_eq!(
|
|
extracted.as_deref(),
|
|
Some("https://mydaddy.cc/video/f7cbb41e218d3b1dca/&alt")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn extract_source_url_supports_source_tag_src() {
|
|
let html =
|
|
r#"<video><source src=\"https://cdn.example.com/video.mp4\" type=\"video/mp4\"></video>"#;
|
|
let extracted = HqpornerProxy::extract_source_url(html);
|
|
assert_eq!(
|
|
extracted.as_deref(),
|
|
Some("https://cdn.example.com/video.mp4")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn extract_player_url_supports_altplayer_path() {
|
|
let html = r#"
|
|
<script>
|
|
function altPlayer() {
|
|
$.ajax({
|
|
type: 'POST',
|
|
url: '/blocks/altplayer.php?i=//mydaddy.cc/video/f7cbb41e218d3b1dca/',
|
|
success: function(data) {}
|
|
});
|
|
}
|
|
</script>
|
|
"#;
|
|
let extracted = HqpornerProxy::extract_player_url(html);
|
|
assert_eq!(
|
|
extracted.as_deref(),
|
|
Some(
|
|
"https://www.hqporner.com/blocks/altplayer.php?i=//mydaddy.cc/video/f7cbb41e218d3b1dca/"
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn extract_quality_urls_from_mydaddy_html() {
|
|
let html = r#"
|
|
timelinePreview:{file:"//s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/tile.vtt",spriteRelativePath:true,type:"VTT"}
|
|
<source src="//s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/360.mp4" title="360p" type="video/mp4" />
|
|
<source src="//s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/720.mp4" title="720p HD" type="video/mp4" />
|
|
<source src="//s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/1080.mp4" title="1080p Full HD" type="video/mp4" />
|
|
"#;
|
|
|
|
let urls = HqpornerProxy::extract_quality_urls(html);
|
|
assert_eq!(
|
|
urls.get(&360).map(String::as_str),
|
|
Some("https://s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/360.mp4")
|
|
);
|
|
assert_eq!(
|
|
urls.get(&720).map(String::as_str),
|
|
Some("https://s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/720.mp4")
|
|
);
|
|
assert_eq!(
|
|
urls.get(&1080).map(String::as_str),
|
|
Some("https://s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/1080.mp4")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn select_quality_url_falls_back_to_next_lower_quality() {
|
|
let mut urls = HashMap::new();
|
|
urls.insert(
|
|
360,
|
|
"https://s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/360.mp4".to_string(),
|
|
);
|
|
urls.insert(
|
|
720,
|
|
"https://s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/720.mp4".to_string(),
|
|
);
|
|
|
|
let requested_1080 = HqpornerProxy::select_quality_url(&urls, Some(1080));
|
|
assert_eq!(
|
|
requested_1080.as_deref(),
|
|
Some("https://s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/720.mp4")
|
|
);
|
|
|
|
let requested_720 = HqpornerProxy::select_quality_url(&urls, Some(720));
|
|
assert_eq!(
|
|
requested_720.as_deref(),
|
|
Some("https://s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/720.mp4")
|
|
);
|
|
|
|
let requested_360 = HqpornerProxy::select_quality_url(&urls, Some(360));
|
|
assert_eq!(
|
|
requested_360.as_deref(),
|
|
Some("https://s43.bigcdn.cc/pubs/69ecfb39b17117.73515587/360.mp4")
|
|
);
|
|
}
|
|
}
|