heavyfetish and other changes

src/providers/mod.rs

@@ -47,6 +47,7 @@ pub mod youjizz;
 // pub mod pornxp;
 pub mod chaturbate;
 pub mod freepornvideosxxx;
+pub mod heavyfetish;
 pub mod hentaihaven;
 pub mod hqporner;
 pub mod hypnotube;
@@ -205,6 +206,10 @@ pub static ALL_PROVIDERS: Lazy<HashMap<&'static str, DynProvider>> = Lazy::new(|
         "freepornvideosxxx",
         Arc::new(freepornvideosxxx::FreepornvideosxxxProvider::new()) as DynProvider,
     );
+    m.insert(
+        "heavyfetish",
+        Arc::new(heavyfetish::HeavyfetishProvider::new()) as DynProvider,
+    );
     m.insert(
         "hentaihaven",
         Arc::new(hentaihaven::HentaihavenProvider::new()) as DynProvider,

src/providers/pimpbunny.rs

@@ -204,8 +204,12 @@ impl PimpbunnyProvider {
     }
 
     fn root_headers(&self) -> Vec<(String, String)> {
+        Self::html_headers_with_referer(&self.root_referer())
+    }
+
+    fn html_headers_with_referer(referer: &str) -> Vec<(String, String)> {
         vec![
-            ("Referer".to_string(), self.root_referer()),
+            ("Referer".to_string(), referer.to_string()),
             (
                 "User-Agent".to_string(),
                 Self::FIREFOX_USER_AGENT.to_string(),
@@ -215,20 +219,52 @@ impl PimpbunnyProvider {
         ]
     }
 
+    fn headers_with_cookies(
+        &self,
+        requester: &Requester,
+        request_url: &str,
+        referer: &str,
+    ) -> Vec<(String, String)> {
+        let mut headers = Self::html_headers_with_referer(referer);
+        if let Some(cookie) = requester.cookie_header_for_url(request_url) {
+            headers.push(("Cookie".to_string(), cookie));
+        }
+        headers
+    }
+
+    async fn warm_root_session(&self, requester: &mut Requester) {
+        let root_url = self.root_referer();
+        let _ = requester
+            .get_with_headers(&root_url, self.root_headers(), Some(Version::HTTP_11))
+            .await;
+    }
+
+    async fn warm_root_session_for_base(base: &str, requester: &mut Requester) {
+        let root_url = format!("{}/", base.trim_end_matches('/'));
+        let _ = requester
+            .get_with_headers(
+                &root_url,
+                Self::html_headers_with_referer(&root_url),
+                Some(Version::HTTP_11),
+            )
+            .await;
+    }
+
     async fn load_stars(base: &str, stars: Arc<RwLock<Vec<FilterOption>>>) -> Result<()> {
         let mut requester = Requester::new();
-        let headers = vec![
+        Self::warm_root_session_for_base(base, &mut requester).await;
-            ("Referer".to_string(), format!("{}/", base.trim_end_matches('/'))),
+        let request_url = format!("{base}/onlyfans-models/?models_per_page=20");
-            (
+        let headers = {
-                "User-Agent".to_string(),
+            let root_url = format!("{}/", base.trim_end_matches('/'));
-                Self::FIREFOX_USER_AGENT.to_string(),
+            let mut headers = Self::html_headers_with_referer(&root_url);
-            ),
+            if let Some(cookie) = requester.cookie_header_for_url(&request_url) {
-            ("Accept".to_string(), Self::HTML_ACCEPT.to_string()),
+                headers.push(("Cookie".to_string(), cookie));
-            ("Accept-Language".to_string(), "en-US,en;q=0.9".to_string()),
+            }
-        ];
+            headers
+        };
         let text = requester
             .get_with_headers(
-                &format!("{base}/onlyfans-models/?models_per_page=20"),
+                &request_url,
                 headers,
                 Some(Version::HTTP_2),
             )
@@ -271,18 +307,19 @@ impl PimpbunnyProvider {
 
     async fn load_categories(base: &str, cats: Arc<RwLock<Vec<FilterOption>>>) -> Result<()> {
         let mut requester = Requester::new();
-        let headers = vec![
+        Self::warm_root_session_for_base(base, &mut requester).await;
-            ("Referer".to_string(), format!("{}/", base.trim_end_matches('/'))),
+        let request_url = format!("{base}/categories/?items_per_page=120");
-            (
+        let headers = {
-                "User-Agent".to_string(),
+            let root_url = format!("{}/", base.trim_end_matches('/'));
-                Self::FIREFOX_USER_AGENT.to_string(),
+            let mut headers = Self::html_headers_with_referer(&root_url);
-            ),
+            if let Some(cookie) = requester.cookie_header_for_url(&request_url) {
-            ("Accept".to_string(), Self::HTML_ACCEPT.to_string()),
+                headers.push(("Cookie".to_string(), cookie));
-            ("Accept-Language".to_string(), "en-US,en;q=0.9".to_string()),
+            }
-        ];
+            headers
+        };
         let text = requester
             .get_with_headers(
-                &format!("{base}/categories/?items_per_page=120"),
+                &request_url,
                 headers,
                 Some(Version::HTTP_2),
             )
@@ -347,8 +384,10 @@ impl PimpbunnyProvider {
         };
         let mut requester =
             crate::providers::requester_or_default(&options, module_path!(), "missing_requester");
+        self.warm_root_session(&mut requester).await;
+        let headers = self.headers_with_cookies(&requester, &video_url, &self.root_referer());
         let text = match requester
-            .get_with_headers(&video_url, self.root_headers(), Some(Version::HTTP_11))
+            .get_with_headers(&video_url, headers, Some(Version::HTTP_11))
             .await
         {
             Ok(text) => text,
@@ -446,9 +485,11 @@ impl PimpbunnyProvider {
 
         let mut requester =
             crate::providers::requester_or_default(&options, module_path!(), "missing_requester");
+        self.warm_root_session(&mut requester).await;
         println!("Fetching URL: {}", video_url);
+        let headers = self.headers_with_cookies(&requester, &video_url, &self.root_referer());
         let text = match requester
-            .get_with_headers(&video_url, self.root_headers(), Some(Version::HTTP_2))
+            .get_with_headers(&video_url, headers, Some(Version::HTTP_2))
             .await
         {
             Ok(text) => text,
@@ -577,8 +618,10 @@ impl PimpbunnyProvider {
         url: &str,
         requester: &mut Requester,
     ) -> Result<(Vec<String>, Vec<VideoFormat>, u32, u32)> {
+        self.warm_root_session(requester).await;
+        let headers = self.headers_with_cookies(requester, url, &self.root_referer());
         let text = requester
-            .get_with_headers(url, self.root_headers(), Some(Version::HTTP_2))
+            .get_with_headers(url, headers, Some(Version::HTTP_2))
             .await
             .map_err(|e| Error::from(format!("{}", e)))?;
 
@@ -610,17 +653,17 @@ impl PimpbunnyProvider {
             .map(|d| parse_time_to_seconds(&d.replace(['P', 'T', 'H', 'M', 'S'], "")).unwrap_or(0))
             .unwrap_or(0) as u32;
 
-        Ok((
+        let mut format = VideoFormat::new(video_url.clone(), quality, "video/mp4".into())
-            vec![],
+            .http_header("Referer".to_string(), url.to_string())
-            vec![VideoFormat::new(video_url, quality, "video/mp4".into())
+            .http_header(
-                .http_header("Referer".to_string(), url.to_string())
+                "User-Agent".to_string(),
-                .http_header(
+                Self::FIREFOX_USER_AGENT.to_string(),
-                    "User-Agent".to_string(),
+            );
-                    Self::FIREFOX_USER_AGENT.to_string(),
+        if let Some(cookie) = requester.cookie_header_for_url(&video_url) {
-                )],
+            format.add_http_header("Cookie".to_string(), cookie);
-            views,
+        }
-            duration,
+
-        ))
+        Ok((vec![], vec![format], views, duration))
     }
 }
 

src/proxies/pimpbunnythumb.rs

@@ -10,9 +10,37 @@ use crate::util::requester::Requester;
 
 const FIREFOX_USER_AGENT: &str =
     "Mozilla/5.0 (X11; Linux x86_64; rv:147.0) Gecko/20100101 Firefox/147.0";
+const HTML_ACCEPT: &str =
+    "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8";
 const IMAGE_ACCEPT: &str =
     "image/avif,image/webp,image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5";
 
+fn root_referer() -> &'static str {
+    "https://pimpbunny.com/"
+}
+
+fn root_html_headers() -> Vec<(String, String)> {
+    vec![
+        ("Referer".to_string(), root_referer().to_string()),
+        ("User-Agent".to_string(), FIREFOX_USER_AGENT.to_string()),
+        ("Accept".to_string(), HTML_ACCEPT.to_string()),
+        ("Accept-Language".to_string(), "en-US,en;q=0.9".to_string()),
+    ]
+}
+
+fn image_headers(requester: &Requester, image_url: &str) -> Vec<(String, String)> {
+    let mut headers = vec![
+        ("Referer".to_string(), root_referer().to_string()),
+        ("User-Agent".to_string(), FIREFOX_USER_AGENT.to_string()),
+        ("Accept".to_string(), IMAGE_ACCEPT.to_string()),
+        ("Accept-Language".to_string(), "en-US,en;q=0.9".to_string()),
+    ];
+    if let Some(cookie) = requester.cookie_header_for_url(image_url) {
+        headers.push(("Cookie".to_string(), cookie));
+    }
+    headers
+}
+
 fn is_allowed_thumb_url(url: &str) -> bool {
     let Some(url) = Url::parse(url).ok() else {
         return false;
@@ -43,13 +71,12 @@ pub async fn get_image(
         return Ok(web::HttpResponse::BadRequest().finish());
     }
 
-    let headers = vec![
-        ("Referer".to_string(), "https://pimpbunny.com/".to_string()),
-        ("User-Agent".to_string(), FIREFOX_USER_AGENT.to_string()),
-        ("Accept".to_string(), IMAGE_ACCEPT.to_string()),
-        ("Accept-Language".to_string(), "en-US,en;q=0.9".to_string()),
-    ];
     let mut requester = requester.get_ref().clone();
+    let _ = requester
+        .get_with_headers(root_referer(), root_html_headers(), Some(Version::HTTP_11))
+        .await;
+
+    let mut headers = image_headers(&requester, image_url.as_str());
 
     let mut upstream = requester
         .get_raw_with_headers(image_url.as_str(), headers.clone())
@@ -63,21 +90,9 @@ pub async fn get_image(
 
     if needs_warmup {
         let _ = requester
-            .get_with_headers(
+            .get_with_headers(root_referer(), root_html_headers(), Some(Version::HTTP_11))
-                "https://pimpbunny.com/",
-                vec![
-                    ("Referer".to_string(), "https://pimpbunny.com/".to_string()),
-                    ("User-Agent".to_string(), FIREFOX_USER_AGENT.to_string()),
-                    (
-                        "Accept".to_string(),
-                        "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8"
-                            .to_string(),
-                    ),
-                    ("Accept-Language".to_string(), "en-US,en;q=0.9".to_string()),
-                ],
-                Some(Version::HTTP_11),
-            )
             .await;
+        headers = image_headers(&requester, image_url.as_str());
 
         upstream = requester
             .get_raw_with_headers(image_url.as_str(), headers.clone())
@@ -94,6 +109,7 @@ pub async fn get_image(
         let _ = requester
             .get_with_headers(image_url.as_str(), headers.clone(), Some(Version::HTTP_11))
             .await;
+        headers = image_headers(&requester, image_url.as_str());
 
         upstream = requester
             .get_raw_with_headers(image_url.as_str(), headers)

src/util/requester.rs

@@ -5,8 +5,9 @@ use std::sync::Arc;
 use wreq::Client;
 use wreq::Proxy;
 use wreq::Response;
+use wreq::Uri;
 use wreq::Version;
-use wreq::cookie::Jar;
+use wreq::cookie::{CookieStore, Cookies, Jar};
 use wreq::header::{HeaderMap, HeaderValue, USER_AGENT};
 use wreq::multipart::Form;
 use wreq::redirect::Policy;
@@ -83,6 +84,23 @@ impl Requester {
         self.proxy = proxy;
     }
 
+    pub fn cookie_header_for_url(&self, url: &str) -> Option<String> {
+        let parsed = url.parse::<Uri>().ok()?;
+        match self.cookie_jar.cookies(&parsed) {
+            Cookies::Compressed(value) => value.to_str().ok().map(ToOwned::to_owned),
+            Cookies::Uncompressed(values) => {
+                let joined = values
+                    .into_iter()
+                    .filter_map(|value| value.to_str().ok().map(ToOwned::to_owned))
+                    .collect::<Vec<_>>()
+                    .join("; ");
+                (!joined.is_empty()).then_some(joined)
+            }
+            Cookies::Empty => None,
+            _ => None,
+        }
+    }
+
     pub async fn get_raw(&mut self, url: &str) -> Result<Response, wreq::Error> {
         let client = Self::build_client(self.cookie_jar.clone(), self.user_agent.as_deref());