|
| 1 | +use hyper::{Body, Request, Response}; |
| 2 | +use serde_json::Value; |
| 3 | +use std::sync::LazyLock; |
| 4 | + |
| 5 | +use crate::client::{proxy, CLIENT}; |
| 6 | +use crate::server::RequestExt; |
| 7 | + |
| 8 | +// RedGifs token cache: (token, expiry_timestamp) |
| 9 | +static REDGIFS_TOKEN: LazyLock<std::sync::Mutex<(String, i64)>> = LazyLock::new(|| std::sync::Mutex::new((String::new(), 0))); |
| 10 | + |
| 11 | +/// Check if a domain is a legitimate RedGifs domain |
| 12 | +pub fn is_redgifs_domain(domain: &str) -> bool { |
| 13 | + domain == "redgifs.com" || domain == "www.redgifs.com" || domain.ends_with(".redgifs.com") |
| 14 | +} |
| 15 | + |
| 16 | +/// HTTP handler for /redgifs/* routes |
| 17 | +/// Handles both video IDs (redirects) and actual video files (proxies) |
| 18 | +pub async fn handler(req: Request<Body>) -> Result<Response<Body>, String> { |
| 19 | + let path = req.param("path").unwrap_or_default(); |
| 20 | + |
| 21 | + // If path ends with .mp4, it's the actual video file - proxy it directly |
| 22 | + if path.ends_with(".mp4") { |
| 23 | + return proxy(req, &format!("https://media.redgifs.com/{}", path)).await; |
| 24 | + } |
| 25 | + |
| 26 | + // Otherwise it's a video ID - fetch from RedGifs API and redirect |
| 27 | + match fetch_video_url(&format!("https://www.redgifs.com/watch/{}", path)).await.ok() { |
| 28 | + Some(video_url) => { |
| 29 | + let filename = video_url.strip_prefix("https://media.redgifs.com/").unwrap_or(&video_url); |
| 30 | + Ok(Response::builder() |
| 31 | + .status(302) |
| 32 | + .header("Location", format!("/redgifs/{}", filename)) |
| 33 | + .body(Body::empty()) |
| 34 | + .unwrap_or_default()) |
| 35 | + } |
| 36 | + None => Ok(Response::builder().status(404).body("RedGifs video not found".into()).unwrap_or_default()), |
| 37 | + } |
| 38 | +} |
| 39 | + |
| 40 | +/// Fetches the HD video URL with audio from RedGifs API |
| 41 | +async fn fetch_video_url(redgifs_url: &str) -> Result<String, String> { |
| 42 | + // Extract video ID from URL (e.g., "firstawkwardrhinoceros" from watch/firstawkwardrhinoceros) |
| 43 | + let video_id = redgifs_url |
| 44 | + .split('/') |
| 45 | + .last() |
| 46 | + .and_then(|s| s.split('?').next()) |
| 47 | + .ok_or("Invalid RedGifs URL")?; |
| 48 | + |
| 49 | + let token = get_token().await?; |
| 50 | + let api_url = format!("https://api.redgifs.com/v2/gifs/{}?views=yes", video_id); |
| 51 | + |
| 52 | + let req = create_request(&api_url, Some(&token))?; |
| 53 | + let res = CLIENT.request(req).await.map_err(|e| e.to_string())?; |
| 54 | + let body_bytes = hyper::body::to_bytes(res.into_body()).await.map_err(|e| e.to_string())?; |
| 55 | + let json: Value = serde_json::from_slice(&body_bytes).map_err(|e| e.to_string())?; |
| 56 | + |
| 57 | + // Prefer HD, fallback to SD |
| 58 | + let hd_url = json["gif"]["urls"]["hd"].as_str(); |
| 59 | + let sd_url = json["gif"]["urls"]["sd"].as_str(); |
| 60 | + |
| 61 | + hd_url |
| 62 | + .or(sd_url) |
| 63 | + .map(String::from) |
| 64 | + .ok_or_else(|| "No video URL in RedGifs response".to_string()) |
| 65 | +} |
| 66 | + |
| 67 | +async fn get_token() -> Result<String, String> { |
| 68 | + let now = std::time::SystemTime::now() |
| 69 | + .duration_since(std::time::UNIX_EPOCH) |
| 70 | + .map_err(|_| "Time error")? |
| 71 | + .as_secs() as i64; |
| 72 | + |
| 73 | + // Return cached token if still valid (without holding lock across await) |
| 74 | + { |
| 75 | + let cache = REDGIFS_TOKEN.lock().map_err(|_| "Lock error")?; |
| 76 | + if !cache.0.is_empty() && now < cache.1 { |
| 77 | + return Ok(cache.0.clone()); |
| 78 | + } |
| 79 | + } |
| 80 | + |
| 81 | + // Fetch new token |
| 82 | + let req = create_request("https://api.redgifs.com/v2/auth/temporary", None)?; |
| 83 | + let res = CLIENT.request(req).await.map_err(|e| e.to_string())?; |
| 84 | + let body_bytes = hyper::body::to_bytes(res.into_body()).await.map_err(|e| e.to_string())?; |
| 85 | + let json: Value = serde_json::from_slice(&body_bytes).map_err(|e| e.to_string())?; |
| 86 | + let token = json["token"].as_str().map(String::from).ok_or_else(|| "No token in RedGifs response".to_string())?; |
| 87 | + |
| 88 | + // Cache the token |
| 89 | + let mut cache = REDGIFS_TOKEN.lock().map_err(|_| "Lock error")?; |
| 90 | + cache.0 = token.clone(); |
| 91 | + cache.1 = now + 86000; // 24h - 400s buffer |
| 92 | + Ok(token) |
| 93 | +} |
| 94 | + |
| 95 | +fn create_request(url: &str, token: Option<&str>) -> Result<Request<Body>, String> { |
| 96 | + let mut builder = hyper::Request::get(url) |
| 97 | + .header("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36") |
| 98 | + .header("referer", "https://www.redgifs.com/") |
| 99 | + .header("origin", "https://www.redgifs.com") |
| 100 | + .header("content-type", "application/json"); |
| 101 | + |
| 102 | + if let Some(t) = token { |
| 103 | + builder = builder.header("Authorization", format!("Bearer {}", t)); |
| 104 | + } |
| 105 | + |
| 106 | + builder.body(Body::empty()).map_err(|e| e.to_string()) |
| 107 | +} |
0 commit comments