Upload 2 files

src/main.rs

@@ -40,6 +40,13 @@ fn json_error(status: StatusCode, message: impl Into<String>) -> axum::response:
     (status, Json(json!({ "error": message.into() }))).into_response()
 }
 
+fn now_ms() -> u128 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis())
+        .unwrap_or(0)
+}
+
 async fn api_client_for_arl(state: &AppState, arl: Option<String>) -> Arc<Mutex<APIClient>> {
     let Some(arl) = arl.map(|s| s.trim().to_string()).filter(|s| !s.is_empty()) else {
         return state.api.clone();
@@ -57,6 +64,65 @@ async fn api_client_for_arl(state: &AppState, arl: Option<String>) -> Arc<Mutex<
     c
 }
 
+fn extract_media_url(media_json: &serde_json::Value) -> String {
+    let data = media_json.get("data").and_then(|v| v.as_array());
+    let Some(data0) = data.and_then(|a| a.get(0)) else {
+        return String::new();
+    };
+    let media_arr = data0.get("media").and_then(|v| v.as_array());
+    let Some(media_arr) = media_arr else {
+        return String::new();
+    };
+    for m in media_arr {
+        if let Some(sources) = m.get("sources").and_then(|v| v.as_array()) {
+            for s in sources {
+                if let Some(url) = s.get("url").and_then(|v| v.as_str()) {
+                    let url = url.trim();
+                    if !url.is_empty() {
+                        return url.to_string();
+                    }
+                }
+            }
+        }
+    }
+    String::new()
+}
+
+async fn media_url_for_track(
+    client: &mut APIClient,
+    id: u32,
+    formats: &Vec<Format>,
+) -> Result<String, String> {
+    let resp: Result<DeezerTrackList, APIError> = client
+        .api_call(
+            "song.getListData",
+            &json!({"sng_ids":[id],"array_default":["SNG_ID","TRACK_TOKEN"]}),
+        )
+        .await;
+
+    let track_list = resp.map_err(|e| e.to_string())?;
+    if track_list.data.is_empty() {
+        return Err("No valid ID".to_string());
+    }
+
+    let track_token = track_list.data[0].TRACK_TOKEN.as_str();
+    let media_resp = client
+        .get_media(formats, vec![track_token])
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let media_json: serde_json::Value = media_resp
+        .json()
+        .await
+        .map_err(|_| "Bad media response".to_string())?;
+
+    let url = extract_media_url(&media_json);
+    if url.is_empty() {
+        return Err("No url in media response".to_string());
+    }
+    Ok(url)
+}
+
 #[derive(Deserialize)]
 struct DeezerTrackList {
     data: Vec<DeezerTrack>
@@ -203,73 +269,47 @@ async fn stream(State(state): State<AppState>, Query(q): Query<StreamParams>) ->
         "AUTO" | _ => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
     };
 
-    fn extract_media_url(media_json: &serde_json::Value) -> String {
-        let data = media_json.get("data").and_then(|v| v.as_array());
-        let Some(data0) = data.and_then(|a| a.get(0)) else {
-            return String::new();
+    let arl_key = q
+        .arl
+        .clone()
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty());
+
+    let mut url: Option<String> = None;
+    let mut last_err: Option<String> = None;
+    for attempt in 0..2 {
+        let client = api_client_for_arl(&state, arl_key.clone()).await;
+        let res = {
+            let mut client = client.lock().await;
+            media_url_for_track(&mut client, q.id, &formats).await
         };
-        let media_arr = data0.get("media").and_then(|v| v.as_array());
-        let Some(media_arr) = media_arr else {
-            return String::new();
-        };
-        for m in media_arr {
-            if let Some(sources) = m.get("sources").and_then(|v| v.as_array()) {
-                for s in sources {
-                    if let Some(url) = s.get("url").and_then(|v| v.as_str()) {
-                        let url = url.trim();
-                        if !url.is_empty() {
-                            return url.to_string();
-                        }
+
+        match res {
+            Ok(u) => {
+                url = Some(u);
+                break;
+            }
+            Err(e) => {
+                last_err = Some(e);
+                if attempt == 0 {
+                    if let Some(arl) = arl_key.clone() {
+                        let mut map = state.api_by_arl.write().await;
+                        map.remove(&arl);
+                    } else {
+                        let mut global = state.api.lock().await;
+                        *global = APIClient::new();
                     }
                 }
             }
         }
-        String::new()
     }
 
-    let client = api_client_for_arl(&state, q.arl.clone()).await;
-    let url = {
-        let mut client = client.lock().await;
-        let resp: Result<DeezerTrackList, APIError> = client
-            .api_call(
-                "song.getListData",
-                &json!({"sng_ids":[q.id],"array_default":["SNG_ID","TRACK_TOKEN"]}),
-            )
-            .await;
-
-        let track_list = match resp {
-            Ok(t) => t,
-            Err(e) => return (StatusCode::SERVICE_UNAVAILABLE, e.to_string()).into_response(),
-        };
-
-        if track_list.data.is_empty() {
-            return (StatusCode::BAD_REQUEST, "No valid ID".to_string()).into_response();
-        }
-
-        let track_token = track_list.data[0].TRACK_TOKEN.as_str();
-        let media_resp = match client.get_media(&formats, vec![track_token]).await {
-            Ok(r) => r,
-            Err(e) => return (StatusCode::SERVICE_UNAVAILABLE, e.to_string()).into_response(),
-        };
-
-        let media_json: serde_json::Value = match media_resp.json().await {
-            Ok(v) => v,
-            Err(_) => {
-                return (StatusCode::SERVICE_UNAVAILABLE, "Bad media response".to_string())
-                    .into_response()
-            }
-        };
-
-        let url = extract_media_url(&media_json);
-
-        if url.is_empty() {
-            return (
-                StatusCode::SERVICE_UNAVAILABLE,
-                "No url in media response".to_string(),
-            )
-                .into_response();
-        }
-        url
+    let Some(url) = url else {
+        return (
+            StatusCode::SERVICE_UNAVAILABLE,
+            last_err.unwrap_or_else(|| "stream:error".to_string()),
+        )
+            .into_response();
     };
 
     let http = reqwest::Client::builder()
@@ -707,10 +747,7 @@ struct PairSession {
 }
 
 fn gen_pair_code() -> String {
-    let ms = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis())
-        .unwrap_or(0);
+    let ms = now_ms();
     let hex = format!("{:x}", md5::compute(format!("pair:{ms}:{SECRET}").as_bytes()));
     hex.chars().take(10).collect::<String>()
 }
@@ -722,12 +759,15 @@ struct PairStatusQuery {
 
 async fn pair_start(State(state): State<AppState>) -> impl IntoResponse {
     let code = gen_pair_code();
-    let created_ms = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis())
-        .unwrap_or(0);
+    let created_ms = now_ms();
     {
         let mut map = state.pair.write().await;
+        let now = created_ms;
+        let ttl_ms: u128 = 10 * 60 * 1000;
+        map.retain(|_, v| now.saturating_sub(v.created_ms) <= ttl_ms);
+        if map.len() >= 512 {
+            map.clear();
+        }
         map.insert(
             code.clone(),
             PairSession {
@@ -749,10 +789,16 @@ async fn pair_status(State(state): State<AppState>, Query(q): Query<PairStatusQu
         return json_error(StatusCode::BAD_REQUEST, "code required");
     }
 
-    let map = state.pair.read().await;
+    let now = now_ms();
+    let ttl_ms: u128 = 10 * 60 * 1000;
+    let mut map = state.pair.write().await;
     let Some(sess) = map.get(&code) else {
         return json_error(StatusCode::NOT_FOUND, "no such code");
     };
+    if now.saturating_sub(sess.created_ms) > ttl_ms {
+        map.remove(&code);
+        return json_error(StatusCode::NOT_FOUND, "code expired");
+    }
 
     if let Some(err) = &sess.error {
         return (StatusCode::OK, Json(json!({ "status": "error", "error": err }))).into_response();
@@ -1053,22 +1099,82 @@ async fn oauth_arl(Json(req): Json<OauthArlReq>) -> impl IntoResponse {
 
     let jar = Arc::new(Jar::default());
     let url_deezer = "https://www.deezer.com".parse::<Url>().unwrap();
+    let url_api = "https://api.deezer.com".parse::<Url>().unwrap();
     jar.add_cookie_str("comeback=1; Domain=.deezer.com", &url_deezer);
+    jar.add_cookie_str("dzr_uniq_id=; Domain=.deezer.com", &url_deezer);
     let client = reqwest::Client::builder()
-        .cookie_provider(jar)
+        .cookie_provider(jar.clone())
         .timeout(std::time::Duration::from_secs(20))
         .build()
         .unwrap();
 
+    let _ = client
+        .get("https://www.deezer.com/")
+        .header(ACCEPT, "*/*")
+        .header("Accept-Language", "en-US,en;q=0.9")
+        .header(
+            "User-Agent",
+            "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0",
+        )
+        .send()
+        .await;
+
     let _ = client
         .get("https://api.deezer.com/platform/generic/track/80085")
         .header("Authorization", format!("Bearer {}", token))
+        .header(ACCEPT, "*/*")
+        .header("Accept-Language", "en-US,en;q=0.9")
+        .header(
+            "User-Agent",
+            "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0",
+        )
         .send()
         .await;
 
-    let ud = match gw_light_call(&client, "deezer.getUserData", "null", json!({})).await {
-        Ok(v) => v,
-        Err(e) => return json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    if !jar_has_cookie(&jar, &url_deezer, "sid=") && !jar_has_cookie(&jar, &url_api, "sid=") {
+        let _ = client
+            .get("https://api.deezer.com/platform/generic/track/3135556")
+            .header("Authorization", format!("Bearer {}", token))
+            .header(ACCEPT, "*/*")
+            .header("Accept-Language", "en-US,en;q=0.9")
+            .header(
+                "User-Agent",
+                "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0",
+            )
+            .send()
+            .await;
+    }
+
+    let mut ud: Option<serde_json::Value> = None;
+    let mut ud_err: Option<String> = None;
+    for attempt in 0..2 {
+        match gw_light_call(&client, "deezer.getUserData", "null", json!({})).await {
+            Ok(v) => {
+                ud = Some(v);
+                break;
+            }
+            Err(e) => {
+                ud_err = Some(e);
+                if attempt == 0 {
+                    let _ = client
+                        .get("https://www.deezer.com/")
+                        .header(ACCEPT, "*/*")
+                        .header("Accept-Language", "en-US,en;q=0.9")
+                        .header(
+                            "User-Agent",
+                            "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0",
+                        )
+                        .send()
+                        .await;
+                }
+            }
+        }
+    }
+    let Some(ud) = ud else {
+        return json_error(
+            StatusCode::SERVICE_UNAVAILABLE,
+            ud_err.unwrap_or_else(|| "gw:getUserData".to_string()),
+        );
     };
 
     let check_form = ud["checkForm"].as_str().unwrap_or("").to_string();