Upload 2 files

src/api.rs

@@ -1,6 +1,6 @@
 use serde::{Serialize, Deserialize, de::DeserializeOwned};
 use std::{env, marker::Sized, time::Instant, sync::Arc};
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use thiserror::Error;
 use serde_json::{json, value::from_value};
 use reqwest::{Client, Response, cookie::Jar, Url, header::ACCEPT};
@@ -73,22 +73,48 @@ impl APIClient {
     }
 
     pub fn new_with_arl(arl: String) -> Self {
+        Self::new_with_arl_session(arl, String::new(), String::new())
+    }
+
+    pub fn new_with_arl_session(
+        arl: String,
+        check_form: String,
+        license_token: String,
+    ) -> Self {
         let builder = Client::builder().no_proxy();
 
-        let cookie = format!("arl={}; Domain=.deezer.com", arl);
-        let comeback = "comeback=1; Domain=.deezer.com";
+        let cookie = format!("arl={}; Domain=.deezer.com; Path=/", arl);
+        let comeback = "comeback=1; Domain=.deezer.com; Path=/";
         let url = "https://www.deezer.com".parse::<Url>().unwrap();
 
         let jar = Jar::default();
         jar.add_cookie_str(&cookie, &url);
         jar.add_cookie_str(comeback, &url);
-        let builder = builder.cookie_provider(Arc::new(jar));
+        let builder = builder
+            .cookie_provider(Arc::new(jar))
+            .timeout(std::time::Duration::from_secs(30));
+
+        let renew_instant = if !license_token.is_empty() && !check_form.is_empty() {
+            Some(Instant::now())
+        } else {
+            None
+        };
 
         Self {
             client: builder.build().unwrap(),
-            license_token: String::new(),
-            check_form: String::new(),
-            renew_instant: None,
+            license_token,
+            check_form,
+            renew_instant,
+        }
+    }
+
+    pub fn seed_session(&mut self, check_form: String, license_token: String) {
+        if !check_form.is_empty() {
+            self.check_form = check_form;
+        }
+        if !license_token.is_empty() {
+            self.license_token = license_token;
+            self.renew_instant = Some(Instant::now());
         }
     }
 
@@ -222,7 +248,12 @@ impl APIClient {
             "track_tokens": track_tokens
         });
 
-        self.client.post("https://media.deezer.com/v1/get_url")
+        self.client
+            .post("https://media.deezer.com/v1/get_url")
+            .header(ACCEPT, "application/json")
+            .header("Content-Type", "application/json")
+            .header("Origin", "https://www.deezer.com")
+            .header("Referer", "https://www.deezer.com/")
             .json(&req)
             .send()
             .await

src/main.rs

@@ -30,14 +30,46 @@ type BoxErr = Box<dyn std::error::Error + Send + Sync + 'static>;
 mod api;
 use api::{APIClient, APIError, Format};
 
+#[derive(Clone)]
+struct ArlSession {
+    check_form: String,
+    license_token: String,
+}
+
 #[derive(Clone)]
 struct AppState {
     api: Arc<Mutex<APIClient>>,
     api_by_arl: Arc<RwLock<HashMap<String, Arc<Mutex<APIClient>>>>>,
+    arl_sessions: Arc<RwLock<HashMap<String, ArlSession>>>,
     pair: Arc<RwLock<HashMap<String, PairSession>>>,
     pair_store_path: String,
 }
 
+fn license_token_from_ud(ud: &serde_json::Value) -> String {
+    ud.pointer("/USER/OPTIONS/license_token")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .trim()
+        .to_string()
+}
+
+async fn store_arl_session(state: &AppState, arl: &str, check_form: &str, license_token: &str) {
+    if arl.len() < 20 {
+        return;
+    }
+    let mut map = state.arl_sessions.write().await;
+    if map.len() >= 64 {
+        map.clear();
+    }
+    map.insert(
+        arl.to_string(),
+        ArlSession {
+            check_form: check_form.to_string(),
+            license_token: license_token.to_string(),
+        },
+    );
+}
+
 fn json_error(status: StatusCode, message: impl Into<String>) -> axum::response::Response {
     (status, Json(json!({ "error": message.into() }))).into_response()
 }
@@ -61,7 +93,13 @@ async fn api_client_for_arl(state: &AppState, arl: Option<String>) -> Arc<Mutex<
     if map.len() >= 32 {
         map.clear();
     }
-    let c = Arc::new(Mutex::new(APIClient::new_with_arl(arl.clone())));
+    let session = state.arl_sessions.read().await.get(&arl).cloned();
+    let client = if let Some(s) = session {
+        APIClient::new_with_arl_session(arl.clone(), s.check_form, s.license_token)
+    } else {
+        APIClient::new_with_arl(arl.clone())
+    };
+    let c = Arc::new(Mutex::new(client));
     map.insert(arl, c.clone());
     c
 }
@@ -139,11 +177,62 @@ fn total_from_content_range(v: &str) -> Option<u64> {
     rest.trim().parse::<u64>().ok()
 }
 
+    String::new()
+}
+
+fn media_response_err(json: &serde_json::Value) -> String {
+    if let Some(errs) = json.get("errors").and_then(|v| v.as_array()) {
+        if let Some(first) = errs.first() {
+            let s = first.to_string();
+            return s.chars().take(160).collect();
+        }
+    }
+    json.to_string().chars().take(160).collect()
+}
+
+async fn fetch_media_url(
+    client: &APIClient,
+    formats: &[Format],
+    track_token: &str,
+) -> Result<String, String> {
+    if client.license_token.is_empty() {
+        return Err("license_token empty".to_string());
+    }
+
+    let media_resp = client
+        .get_media(&formats.to_vec(), vec![track_token])
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let status = media_resp.status();
+    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 Ok(url);
+    }
+
+    Err(format!(
+        "media:{}:{}",
+        status.as_u16(),
+        media_response_err(&media_json)
+    ))
+}
+
 async fn media_url_for_track(
     client: &mut APIClient,
     id: u32,
     formats: &Vec<Format>,
 ) -> Result<String, String> {
+    if client.license_token.is_empty() {
+        if let Err(e) = client.force_renew().await {
+            return Err(format!("renew:{e}"));
+        }
+    }
+
     let resp: Result<DeezerTrackList, APIError> = client
         .api_call(
             "song.getListData",
@@ -157,21 +246,26 @@ async fn media_url_for_track(
     }
 
     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())?;
+    if track_token.is_empty() {
+        return Err("empty TRACK_TOKEN".to_string());
+    }
 
-    let media_json: serde_json::Value = media_resp
-        .json()
-        .await
-        .map_err(|_| "Bad media response".to_string())?;
+    let mut last_err = String::from("no_url");
 
-    let url = extract_media_url(&media_json);
-    if url.is_empty() {
-        return Err("No url in media response".to_string());
+    for fmt in formats {
+        match fetch_media_url(client, std::slice::from_ref(fmt), track_token).await {
+            Ok(url) => return Ok(url),
+            Err(e) => last_err = e,
+        }
     }
-    Ok(url)
+
+    if formats.len() > 1 {
+        if let Ok(url) = fetch_media_url(client, formats, track_token).await {
+            return Ok(url);
+        }
+    }
+
+    Err(last_err)
 }
 
 fn upstream_dzmedia_base() -> Option<String> {
@@ -417,28 +511,12 @@ async fn stream_info(State(state): State<AppState>, Query(q): Query<StreamParams
                     state.api_by_arl.write().await.remove(&arl);
                 }
                 let client = api_client_for_arl(&state, Some(arl.clone())).await;
-                let res = async {
+                let res = {
                     let mut c = client.lock().await;
-                    if attempt == 1 { let _ = c.force_renew().await; }
-                    let resp: Result<DeezerTrackList, APIError> = c
-                        .api_call(
-                            "song.getListData",
-                            &json!({"sng_ids":[q.id],"array_default":["SNG_ID","TRACK_TOKEN","DURATION"]}),
-                        )
-                        .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 token = track_list.data[0].TRACK_TOKEN.as_str();
-                    let media_resp = c.get_media(&formats, vec![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 u = extract_media_url(&media_json);
-                    let f = extract_media_format(&media_json);
-                    if u.is_empty() { return Err("No url in media response".to_string()); }
-                    Ok::<(String, String), String>((u, f))
-                }.await;
+                    media_url_for_track(&mut c, q.id, &formats).await
+                };
                 match res {
-                    Ok((u, f)) => { url = u; used = f; break 'arl; }
+                    Ok(u) => { url = u; break 'arl; }
                     Err(e)     => { last_err = Some(e); }
                 }
             }
@@ -525,12 +603,11 @@ async fn stream(
         }
     }
 
-    // До 3 попыток: 0 — обычная, 1 — после сброса кэша клиента, 2 — принудительный renew внутри
+    // До 3 попыток: 0 — renew+запрос, 1 — сброс кэша клиента, 2 — ещё раз renew
     for attempt in 0..3u8 {
         if url.is_some() { break; }
 
-        // На попытке 1 — выбрасываем кэшированный клиент чтобы пересоздать его
-        if attempt == 1 {
+        if attempt >= 1 {
             if let Some(ref arl) = arl_key {
                 state.api_by_arl.write().await.remove(arl);
             } else {
@@ -541,11 +618,10 @@ async fn stream(
         let client = api_client_for_arl(&state, arl_key.clone()).await;
         let res = {
             let mut c = client.lock().await;
-            // На попытке 2 — принудительно обновляем токены перед запросом
-            if attempt == 2 {
+            if attempt >= 1 {
                 if let Err(e) = c.force_renew().await {
                     last_err = Some(format!("renew:{}", e));
-                    break;
+                    continue;
                 }
             }
             media_url_for_track(&mut c, q.id, &formats).await
@@ -1027,6 +1103,7 @@ struct WebLoginResult {
     token: String,
     uid: String,
     access_token: String,
+    license_token: String,
 }
 
 fn gw_browser_ua() -> &'static str {
@@ -1099,7 +1176,7 @@ async fn gw_fetch_arl(
     email: &str,
     password_md5: &str,
     user_id: Option<&str>,
-) -> Result<(String, String, String), String> {
+) -> Result<(String, String, String, String), String> {
     let mut last_err = String::from("getArl:none");
 
     for attempt in 0..3u8 {
@@ -1151,7 +1228,8 @@ async fn gw_fetch_arl(
             Ok(v) => {
                 let arl = v.as_str().unwrap_or("").to_string();
                 if arl.len() >= 100 {
-                    return Ok((arl, check_form, uid));
+                    let license_token = license_token_from_ud(&ud);
+                    return Ok((arl, check_form, uid, license_token));
                 }
                 last_err = format!("arl_too_short:{}", arl.len());
             }
@@ -1183,11 +1261,11 @@ async fn gw_fetch_arl(
 async fn try_fetch_arl_for_token(
     access_token: &str,
     user_id: Option<&str>,
-) -> (Option<String>, Option<String>) {
+) -> (Option<String>, Option<String>, Option<String>) {
     let jar = Arc::new(Jar::default());
     let url_deezer = match "https://www.deezer.com".parse::<Url>() {
         Ok(u) => u,
-        Err(_) => return (None, None),
+        Err(_) => return (None, None, None),
     };
     jar.add_cookie_str("comeback=1; Domain=.deezer.com; Path=/", &url_deezer);
 
@@ -1198,7 +1276,7 @@ async fn try_fetch_arl_for_token(
         .build()
     {
         Ok(c) => c,
-        Err(_) => return (None, None),
+        Err(_) => return (None, None, None),
     };
 
     let _ = client
@@ -1209,7 +1287,7 @@ async fn try_fetch_arl_for_token(
         .await;
 
     if ensure_anonymous_sid(&client, &jar).await.is_err() {
-        return (None, None);
+        return (None, None, None);
     }
 
     establish_oauth_session(&client, &jar, access_token).await;
@@ -1226,11 +1304,12 @@ async fn try_fetch_arl_for_token(
     };
 
     match gw_fetch_arl(&client, "", "", uid.as_deref()).await {
-        Ok((arl, token, _)) if arl.len() >= 20 => {
+        Ok((arl, token, _, license_token)) if arl.len() >= 20 => {
             let gw_token = if token.is_empty() { None } else { Some(token) };
-            (Some(arl), gw_token)
+            let lic = if license_token.is_empty() { None } else { Some(license_token) };
+            (Some(arl), gw_token, lic)
         }
-        _ => (None, None),
+        _ => (None, None, None),
     }
 }
 
@@ -1370,7 +1449,7 @@ async fn web_login(email: &str, password_md5: &str) -> Result<WebLoginResult, St
     .filter(|id| *id > 0)
     .map(|id| id.to_string());
 
-    let (arl, token, uid) = match gw_fetch_arl(
+    let (arl, token, uid, license_token) = match gw_fetch_arl(
         &client,
         email,
         password_md5,
@@ -1380,12 +1459,12 @@ async fn web_login(email: &str, password_md5: &str) -> Result<WebLoginResult, St
     {
         Ok(v) => v,
         Err(_e) => {
-            // ARL не обязателен — OAuth уже даёт доступ к библиотеке
             if let Ok(mobile_arl) = mobile_login(email, password_md5).await {
                 (
                     mobile_arl,
                     String::new(),
                     uid_from_api.clone().unwrap_or_default(),
+                    String::new(),
                 )
             } else {
                 return Ok(WebLoginResult {
@@ -1393,13 +1472,14 @@ async fn web_login(email: &str, password_md5: &str) -> Result<WebLoginResult, St
                     token: String::new(),
                     uid: uid_from_api.unwrap_or_default(),
                     access_token,
+                    license_token: String::new(),
                 });
             }
         }
     };
 
     Ok(WebLoginResult {
-        arl: Some(arl),
+        arl: Some(arl.clone()),
         token,
         uid: if uid.is_empty() {
             uid_from_api.unwrap_or_default()
@@ -1407,6 +1487,7 @@ async fn web_login(email: &str, password_md5: &str) -> Result<WebLoginResult, St
             uid
         },
         access_token,
+        license_token,
     })
 }
 
@@ -1521,7 +1602,6 @@ async fn gw_light_call(
             ])
             .header(ACCEPT, "*/*")
             .header("Cache-Control", "max-age=0")
-            .header("Connection", "keep-alive")
             .header("Origin", "https://www.deezer.com")
             .header("Referer", "https://www.deezer.com/")
             .header("Sec-Fetch-Site", "same-origin")
@@ -1624,7 +1704,6 @@ async fn gw_light_call_custom(
         .query(&qp)
         .header(ACCEPT, "*/*")
         .header("Cache-Control", "max-age=0")
-        .header("Connection", "keep-alive")
         .header("Origin", "https://www.deezer.com")
         .header("Referer", "https://www.deezer.com/")
         .header("Sec-Fetch-Site", "same-origin")
@@ -1667,7 +1746,7 @@ fn jar_has_cookie(jar: &Jar, url: &Url, cookie_prefix: &str) -> bool {
     s.split(';').any(|p| p.trim_start().starts_with(cookie_prefix))
 }
 
-async fn login(Json(req): Json<LoginReq>) -> impl IntoResponse {
+async fn login(State(state): State<AppState>, Json(req): Json<LoginReq>) -> impl IntoResponse {
     let email = req.email.trim().to_string();
     let pass  = req.password_md5.trim().to_string();
 
@@ -1676,12 +1755,18 @@ async fn login(Json(req): Json<LoginReq>) -> impl IntoResponse {
     }
 
     match web_login(&email, &pass).await {
-        Ok(res) => (StatusCode::OK, Json(json!({
-            "arl":          res.arl,
-            "token":        res.token,
-            "uid":          res.uid,
-            "access_token": res.access_token
-        }))).into_response(),
+        Ok(res) => {
+            if let Some(ref arl) = res.arl {
+                store_arl_session(&state, arl, &res.token, &res.license_token).await;
+                state.api_by_arl.write().await.remove(arl);
+            }
+            (StatusCode::OK, Json(json!({
+                "arl":          res.arl,
+                "token":        res.token,
+                "uid":          res.uid,
+                "access_token": res.access_token
+            }))).into_response()
+        }
         Err(e) => json_error(
             StatusCode::UNAUTHORIZED,
             format!("login_failed; {e}"),
@@ -1894,12 +1979,20 @@ async fn pair_oauth(State(state): State<AppState>, Json(req): Json<PairOauthReq>
         Some(user_id.clone())
     };
 
-    let (arl_opt, token_opt) = try_fetch_arl_for_token(
+    let (arl_opt, token_opt, license_opt) = try_fetch_arl_for_token(
         &access_token,
         uid_from_api.as_deref(),
     )
     .await;
 
+    if let (Some(ref arl), Some(ref token), Some(ref lic)) = (&arl_opt, &token_opt, &license_opt) {
+        store_arl_session(&state, arl, token, lic).await;
+        state.api_by_arl.write().await.remove(arl);
+    } else if let (Some(ref arl), Some(ref token)) = (&arl_opt, &token_opt) {
+        store_arl_session(&state, arl, token, "").await;
+        state.api_by_arl.write().await.remove(arl);
+    }
+
     let mut map = state.pair.write().await;
     let Some(sess) = map.get_mut(&code) else {
         return json_error(StatusCode::NOT_FOUND, "no such code");
@@ -2131,6 +2224,10 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
             }
             drop(map);
             pair_store_save(&state).await;
+            if let Some(ref arl) = login.arl {
+                store_arl_session(&state, arl, &login.token, &login.license_token).await;
+                state.api_by_arl.write().await.remove(arl);
+            }
             let msg = if login.arl.is_some() {
                 "<h3>Готово</h3><p>Вернись на ТВ — плагин подключится автоматически.</p>"
             } else {
@@ -2233,7 +2330,7 @@ struct OauthArlReq {
     access_token: String,
 }
 
-async fn oauth_arl(Json(req): Json<OauthArlReq>) -> impl IntoResponse {
+async fn oauth_arl(State(state): State<AppState>, Json(req): Json<OauthArlReq>) -> impl IntoResponse {
     let token = req.access_token.trim().to_string();
     if token.is_empty() {
         return json_error(StatusCode::BAD_REQUEST, "access_token required");
@@ -2272,10 +2369,12 @@ async fn oauth_arl(Json(req): Json<OauthArlReq>) -> impl IntoResponse {
         .map(|id| id.to_string());
 
     match gw_fetch_arl(&client, "", "", uid.as_deref()).await {
-        Ok((arl, _, _)) if arl.len() >= 20 => {
+        Ok((arl, check_form, _, license_token)) if arl.len() >= 20 => {
+            store_arl_session(&state, &arl, &check_form, &license_token).await;
+            state.api_by_arl.write().await.remove(&arl);
             (StatusCode::OK, Json(json!({ "arl": arl }))).into_response()
         }
-        Ok((arl, _, _)) => {
+        Ok((arl, _, _, _)) => {
             json_error(
                 StatusCode::SERVICE_UNAVAILABLE,
                 format!("oauth_arl:arl_too_short:{}", arl.len()),
@@ -2701,6 +2800,34 @@ async fn oauth_history(Json(req): Json<OauthHistoryReq>) -> impl IntoResponse {
     }
 }
 
+#[derive(Debug, Deserialize)]
+struct WarmArlReq {
+    arl: String,
+}
+
+async fn warm_arl(State(state): State<AppState>, Json(req): Json<WarmArlReq>) -> impl IntoResponse {
+    let arl = req.arl.trim().to_string();
+    if arl.len() < 20 {
+        return json_error(StatusCode::BAD_REQUEST, "arl required");
+    }
+
+    state.api_by_arl.write().await.remove(&arl);
+    let client = api_client_for_arl(&state, Some(arl.clone())).await;
+    let session = {
+        let mut c = client.lock().await;
+        if c.license_token.is_empty() {
+            if let Err(e) = c.force_renew().await {
+                return json_error(StatusCode::SERVICE_UNAVAILABLE, format!("warm:renew:{e}"));
+            }
+        }
+        (c.check_form.clone(), c.license_token.clone())
+    };
+
+    store_arl_session(&state, &arl, &session.0, &session.1).await;
+    state.api_by_arl.write().await.remove(&arl);
+    (StatusCode::OK, Json(json!({ "ok": true }))).into_response()
+}
+
 #[tokio::main]
 async fn main() {
     let bind_addr = std::env::var("BIND_ADDR").unwrap_or("[::]".to_string());
@@ -2710,6 +2837,7 @@ async fn main() {
     let state = AppState {
         api: Arc::new(Mutex::new(APIClient::new())),
         api_by_arl: Arc::new(RwLock::new(HashMap::new())),
+        arl_sessions: Arc::new(RwLock::new(HashMap::new())),
         pair: Arc::new(RwLock::new(HashMap::new())),
         pair_store_path: std::env::var("PAIR_STORE_PATH").ok().unwrap_or_else(|| "pair_store.json".to_string()),
     };
@@ -2745,6 +2873,7 @@ async fn main() {
         .route("/oauth/playlists", post(oauth_playlists))
         .route("/oauth/playlist_tracks", post(oauth_playlist_tracks))
         .route("/oauth/arl", post(oauth_arl))
+        .route("/session/warm", post(warm_arl))
         .route("/oauth/flow", post(oauth_flow))
         .route("/oauth/reco_playlists", post(oauth_reco_playlists))
         .route("/oauth/reco_albums", post(oauth_reco_albums))