Upload main.rs

src/main.rs

@@ -808,6 +808,145 @@ async fn stream_info(State(state): State<AppState>, Query(q): Query<StreamParams
     }))).into_response()
 }
 
+/// /download — like /stream but downloads full track into memory and returns with Content-Length.
+/// Telegram requires Content-Length for sendAudio by URL; this endpoint ensures it.
+async fn download(
+    State(state): State<AppState>,
+    Query(q): Query<StreamParams>,
+) -> impl IntoResponse {
+    let formats = match q.format.as_deref().unwrap_or("AUTO") {
+        "FLAC"     => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
+        "MP3_320"  => vec![Format::MP3_320, Format::MP3_128],
+        "MP3_MISC" => vec![Format::MP3_MISC, Format::MP3_128],
+        "MP3_128"  => vec![Format::MP3_128],
+        _          => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
+    };
+
+    let arl_key = q.arl.as_ref().map(|s| s.trim().to_string()).filter(|s| !s.is_empty());
+    if arl_key.is_none() {
+        return (StatusCode::SERVICE_UNAVAILABLE, "arl required").into_response();
+    }
+
+    // Resolve correct FALLBACK_ID for decryption
+    let client = api_client_for_arl(&state, arl_key.clone()).await;
+    let target_id = {
+        let mut c = client.lock().await;
+        resolve_fallback_id(&mut c, q.id).await
+    };
+    let mut decrypt_id = target_id;
+
+    let mut url: Option<String> = None;
+    let mut used_fmt = String::new();
+    let mut last_err: Option<String> = None;
+
+    // Try DZMEDIA_UPSTREAM first for highest quality
+    if url.is_none() {
+        if let Ok(text) = upstream_get_url_text(&formats, &vec![target_id]).await {
+            if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) {
+                let format_strings: Vec<String> = formats.iter().map(|f| format!("{:?}", f)).collect();
+                let format_strs: Vec<&str> = format_strings.iter().map(|s| s.as_str()).collect();
+                let (u, f, _) = extract_media_url_and_format(&v, &format_strs);
+                if !u.is_empty() {
+                    url = Some(u);
+                    used_fmt = f;
+                }
+            }
+        }
+    }
+
+    // Fallback: ARL path
+    for attempt in 0..2u8 {
+        if url.is_some() { break; }
+        if attempt >= 1 {
+            if let Some(ref arl) = arl_key {
+                state.api_by_arl.write().await.remove(arl);
+            }
+        }
+        let client = api_client_for_arl(&state, arl_key.clone()).await;
+        let res = {
+            let mut c = client.lock().await;
+            if attempt >= 1 {
+                if let Err(e) = c.force_renew().await {
+                    last_err = Some(format!("renew:{}", e));
+                    continue;
+                }
+            }
+            match timeout(Duration::from_secs(15), media_url_for_track(&mut c, target_id, &formats)).await {
+                Ok(v) => v,
+                Err(_) => Err("timeout".to_string()),
+            }
+        };
+        match res {
+            Ok((u, f, id_used)) => { url = Some(u); used_fmt = f; decrypt_id = id_used; break; }
+            Err(e) => { last_err = Some(e); }
+        }
+    }
+
+    let cdn_url = match url {
+        Some(u) => u,
+        None => {
+            let err = last_err.unwrap_or_else(|| "download:no_url".to_string());
+            tracing::error!("download {} failed: {}", q.id, err);
+            return (StatusCode::NOT_FOUND, "Not Found").into_response();
+        }
+    };
+
+    // Download the full encrypted file
+    let http = reqwest::Client::builder().no_proxy().timeout(Duration::from_secs(120)).build().unwrap();
+    let resp = match http.get(&cdn_url).send().await {
+        Ok(r) => r,
+        Err(e) => {
+            tracing::error!("download {} cdn fetch failed: {}", q.id, e);
+            return (StatusCode::BAD_GATEWAY, "CDN fetch failed").into_response();
+        }
+    };
+    if !resp.status().is_success() {
+        return (StatusCode::BAD_GATEWAY, "CDN error").into_response();
+    }
+    let content_type = resp.headers()
+        .get(reqwest::header::CONTENT_TYPE)
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("audio/mpeg")
+        .to_string();
+    let enc_bytes = match resp.bytes().await {
+        Ok(b) => b,
+        Err(e) => {
+            tracing::error!("download {} cdn read failed: {}", q.id, e);
+            return (StatusCode::BAD_GATEWAY, "CDN read failed").into_response();
+        }
+    };
+
+    // Decrypt in-memory (every 3rd 2048-byte block)
+    let key = blowfish_key(decrypt_id);
+    let mut dec = enc_bytes.to_vec();
+    let block_size = 2048usize;
+    let mut bi = 0usize;
+    let mut pos = 0usize;
+    while pos + block_size <= dec.len() {
+        if bi % 3 == 0 {
+            let _ = decrypt_stripe(&mut dec[pos..pos + block_size], &key);
+        }
+        bi += 1;
+        pos += block_size;
+    }
+
+    // Determine file extension
+    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
+    let filename = format!("track_{}.{}", q.id, ext);
+    let ct = if ext == "flac" { "audio/flac" } else { "audio/mpeg" };
+
+    axum::response::Response::builder()
+        .status(200)
+        .header("Content-Type", ct)
+        .header("Content-Length", dec.len().to_string())
+        .header("Content-Disposition", format!("attachment; filename=\"{}\"", filename))
+        .header("Accept-Ranges", "none")
+        .header("Access-Control-Allow-Origin", "*")
+        .body(axum::body::Body::from(dec))
+        .unwrap()
+        .into_response()
+}
+
 async fn stream(
     State(state): State<AppState>,
     Query(q): Query<StreamParams>,
@@ -3351,6 +3490,7 @@ async fn main() {
         .route("/get_url", post(get_url))
         .route("/fetch", get(fetch))
         .route("/stream", get(stream))
+        .route("/download", get(download))
         .route("/stream_info", get(stream_info))
         .route("/user_data", post(user_data))
         .route("/playlists", post(playlists))