Upload 2 files

src/main.rs

@@ -1023,12 +1023,163 @@ async fn mobile_login(email: &str, password_md5: &str) -> Result<String, String>
 const DEEZER_APP_SECRET: &str = "a83bf7f38ad2f137e444727cfc3775cf";
 
 struct WebLoginResult {
-    arl: String,
+    arl: Option<String>,
     token: String,
     uid: String,
     access_token: String,
 }
 
+fn gw_browser_ua() -> &'static str {
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
+}
+
+fn gw_cid() -> String {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis().to_string())
+        .unwrap_or_else(|_| "0".to_string())
+}
+
+fn capture_sid_from_response(jar: &Jar, url: &Url, headers: &reqwest::header::HeaderMap) {
+    for cookie_hdr in headers.get_all(reqwest::header::SET_COOKIE) {
+        if let Ok(s) = cookie_hdr.to_str() {
+            for part in s.split(',') {
+                let part = part.trim();
+                let name_val = part.split(';').next().unwrap_or("").trim();
+                if name_val.starts_with("sid=") {
+                    jar.add_cookie_str(
+                        &format!("{name_val}; Domain=.deezer.com; Path=/"),
+                        url,
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// Deezer выдаёт анонимный sid в Set-Cookie ответа на GET user.getArl — нужен до OAuth.
+async fn ensure_anonymous_sid(client: &reqwest::Client, jar: &Jar) -> Result<(), String> {
+    let url_deezer = "https://www.deezer.com".parse::<Url>().map_err(|_| "sid:url".to_string())?;
+    if jar_has_cookie(jar, &url_deezer, "sid=") {
+        return Ok(());
+    }
+
+    let cid = gw_cid();
+    let r = client
+        .get("https://www.deezer.com/ajax/gw-light.php")
+        .query(&[
+            ("method", "user.getArl"),
+            ("input", "3"),
+            ("output", "3"),
+            ("api_version", "1.0"),
+            ("api_token", "null"),
+            ("cid", cid.as_str()),
+        ])
+        .header(ACCEPT, "*/*")
+        .header("Origin", "https://www.deezer.com")
+        .header("Referer", "https://www.deezer.com/")
+        .header("Sec-Fetch-Site", "same-origin")
+        .header("Sec-Fetch-Mode", "cors")
+        .header("Sec-Fetch-Dest", "empty")
+        .header("User-Agent", gw_browser_ua())
+        .send()
+        .await
+        .map_err(|e| format!("sid:network:{e}"))?;
+
+    capture_sid_from_response(jar, &url_deezer, r.headers());
+
+    if !jar_has_cookie(jar, &url_deezer, "sid=") {
+        return Err("sid:not_set".to_string());
+    }
+    Ok(())
+}
+
+async fn gw_fetch_arl(
+    client: &reqwest::Client,
+    email: &str,
+    password_md5: &str,
+    user_id: Option<&str>,
+) -> Result<(String, String, String), String> {
+    let mut last_err = String::from("getArl:none");
+
+    for attempt in 0..3u8 {
+        let ud = gw_light_call_custom(
+            client,
+            "deezer.getUserData",
+            "null",
+            None,
+            &json!({}),
+            None,
+            attempt > 0,
+        )
+        .await
+        .map_err(|e| format!("getUserData:{e}"))?;
+
+        let check_form = ud
+            .get("checkForm")
+            .and_then(|x| x.as_str())
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        if check_form.is_empty() {
+            last_err = "no_checkForm".to_string();
+            continue;
+        }
+
+        let uid = ud
+            .get("USER")
+            .and_then(|u| u.get("USER_ID"))
+            .and_then(|x| x.as_i64())
+            .map(|n| n.to_string())
+            .unwrap_or_default();
+
+        let uid_for_hdr = user_id
+            .filter(|s| !s.trim().is_empty())
+            .or_else(|| if uid.is_empty() { None } else { Some(uid.as_str()) });
+
+        match gw_light_call_custom(
+            client,
+            "user.getArl",
+            &check_form,
+            None,
+            &json!({}),
+            uid_for_hdr,
+            true,
+        )
+        .await
+        {
+            Ok(v) => {
+                let arl = v.as_str().unwrap_or("").to_string();
+                if arl.len() >= 100 {
+                    return Ok((arl, check_form, uid));
+                }
+                last_err = format!("arl_too_short:{}", arl.len());
+            }
+            Err(e) => {
+                last_err = e.clone();
+                if e.contains("NEED_USER_AUTH") && attempt == 0 {
+                    let _ = gw_light_call_custom(
+                        client,
+                        "user.checkCredentials",
+                        &check_form,
+                        None,
+                        &json!({
+                            "login": email,
+                            "password": password_md5,
+                            "checkFormLogin": check_form
+                        }),
+                        uid_for_hdr,
+                        false,
+                    )
+                    .await;
+                }
+            }
+        }
+    }
+
+    Err(format!("getArl:{last_err}"))
+}
+
 async fn oauth_access_token(
     client: &reqwest::Client,
     email: &str,
@@ -1081,7 +1232,17 @@ async fn oauth_access_token(
 async fn establish_oauth_session(client: &reqwest::Client, jar: &Jar, access_token: &str) {
     let url_deezer = "https://www.deezer.com".parse::<Url>().unwrap();
     let url_api = "https://api.deezer.com".parse::<Url>().unwrap();
-    let ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+    let ua = gw_browser_ua();
+
+    let _ = client
+        .get("https://api.deezer.com/user/me")
+        .query(&[("access_token", access_token)])
+        .header("Authorization", format!("Bearer {access_token}"))
+        .header(ACCEPT, "*/*")
+        .header("Accept-Language", "en-US,en;q=0.9")
+        .header("User-Agent", ua)
+        .send()
+        .await;
 
     let _ = client
         .get("https://api.deezer.com/platform/generic/track/80085")
@@ -1116,7 +1277,19 @@ async fn web_login(email: &str, password_md5: &str) -> Result<WebLoginResult, St
         .build()
         .map_err(|_| "web:client".to_string())?;
 
-    // OAuth через connect.deezer.com — не блокируется так же, как gw-light checkCredentials
+    let _ = client
+        .get("https://www.deezer.com/")
+        .header(ACCEPT, "*/*")
+        .header("Accept-Language", "en-US,en;q=0.9")
+        .header("User-Agent", gw_browser_ua())
+        .send()
+        .await;
+
+    // sid нужен ДО OAuth (как в официальном клиенте Deezer)
+    ensure_anonymous_sid(&client, &jar)
+        .await
+        .map_err(|e| format!("web:{e}"))?;
+
     let access_token = oauth_access_token(&client, email, password_md5)
         .await
         .map_err(|e| format!("oauth:{e}"))?;
@@ -1127,89 +1300,58 @@ async fn web_login(email: &str, password_md5: &str) -> Result<WebLoginResult, St
         .get("https://www.deezer.com/")
         .header(ACCEPT, "*/*")
         .header("Accept-Language", "en-US,en;q=0.9")
-        .header(
-            "User-Agent",
-            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-        )
+        .header("User-Agent", gw_browser_ua())
         .send()
         .await;
 
-    let ud = gw_light_call_custom(
+    let uid_from_api = api_deezer_get(
         &client,
-        "deezer.getUserData",
-        "null",
-        None,
-        &json!({}),
-        None,
-        false,
+        "/user/me",
+        &access_token,
+        &[],
     )
     .await
-    .map_err(|e| format!("web:getUserData:{e}"))?;
-
-    let check_form = ud.get("checkForm").and_then(|x| x.as_str()).unwrap_or("").trim().to_string();
-    if check_form.is_empty() {
-        return Err("web:no_checkForm".to_string());
-    }
+    .ok()
+    .and_then(|v| v.get("id").and_then(|x| x.as_i64()))
+    .filter(|id| *id > 0)
+    .map(|id| id.to_string());
 
-    let uid = ud
-        .get("USER")
-        .and_then(|u| u.get("USER_ID"))
-        .and_then(|x| x.as_i64())
-        .map(|n| n.to_string())
-        .unwrap_or_default();
-
-    let arl_v = match gw_light_call_custom(
+    let (arl, token, uid) = match gw_fetch_arl(
         &client,
-        "user.getArl",
-        &check_form,
-        None,
-        &json!({}),
-        None,
-        true,
+        email,
+        password_md5,
+        uid_from_api.as_deref(),
     )
     .await
     {
         Ok(v) => v,
-        Err(e1) => {
-            // Последний fallback — checkCredentials (часто режется на HF/VPS)
-            let _ = gw_light_call_custom(
-                &client,
-                "user.checkCredentials",
-                &check_form,
-                None,
-                &json!({
-                    "login": email,
-                    "password": password_md5,
-                    "checkFormLogin": check_form
-                }),
-                None,
-                false,
-            )
-            .await;
-
-            gw_light_call_custom(
-                &client,
-                "user.getArl",
-                &check_form,
-                None,
-                &json!({}),
-                None,
-                true,
-            )
-            .await
-            .map_err(|e2| format!("web:getArl:{e1}; retry:{e2}"))?
+        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(),
+                )
+            } else {
+                return Ok(WebLoginResult {
+                    arl: None,
+                    token: String::new(),
+                    uid: uid_from_api.unwrap_or_default(),
+                    access_token,
+                });
+            }
         }
     };
 
-    let arl = arl_v.as_str().unwrap_or("").to_string();
-    if arl.len() < 100 {
-        return Err(format!("web:arl_too_short:{}", arl.len()));
-    }
-
     Ok(WebLoginResult {
-        arl,
-        token: check_form,
-        uid,
+        arl: Some(arl),
+        token,
+        uid: if uid.is_empty() {
+            uid_from_api.unwrap_or_default()
+        } else {
+            uid
+        },
         access_token,
     })
 }
@@ -1868,18 +2010,27 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
         Ok(login) => {
             let mut map = state.pair.write().await;
             if let Some(s) = map.get_mut(&code) {
-                s.arl = Some(login.arl);
-                s.token = Some(login.token);
-                s.access_token = Some(login.access_token);
+                s.arl = login.arl.clone();
+                s.token = if login.token.is_empty() {
+                    None
+                } else {
+                    Some(login.token.clone())
+                };
+                s.access_token = Some(login.access_token.clone());
                 if !login.uid.is_empty() {
-                    s.user_id = Some(login.uid);
+                    s.user_id = Some(login.uid.clone());
                 }
                 s.email = Some(email);
                 s.error = None;
             }
             drop(map);
             pair_store_save(&state).await;
-            Html("<h3>Готово</h3><p>Вернись на ТВ — плагин подключится автоматически.</p>".to_string()).into_response()
+            let msg = if login.arl.is_some() {
+                "<h3>Готово</h3><p>Вернись на ТВ — плагин подключится автоматически.</p>"
+            } else {
+                "<h3>Вход выполнен</h3><p>Библиотека доступна. ARL не получен — полные треки могут не работать, попробуй кнопку «Войти через Deezer».</p>"
+            };
+            Html(msg.to_string()).into_response()
         }
     }
 }
@@ -1984,7 +2135,6 @@ 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()
@@ -1998,86 +2148,29 @@ async fn oauth_arl(Json(req): Json<OauthArlReq>) -> impl IntoResponse {
         .get("https://www.deezer.com/")
         .header(ACCEPT, "*/*")
         .header("Accept-Language", "en-US,en;q=0.9")
-        .header(
-            "User-Agent",
-            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-        )
+        .header("User-Agent", gw_browser_ua())
         .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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-        )
-        .send()
-        .await;
-
-    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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-            )
-            .send()
-            .await;
+    if let Err(e) = ensure_anonymous_sid(&client, &jar).await {
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, format!("oauth_arl:{e}"));
     }
 
-    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, &jar, "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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
-                        )
-                        .send()
-                        .await;
-                }
-            }
-        }
-    }
-    let Some(ud) = ud else {
-        return json_error(
-            StatusCode::SERVICE_UNAVAILABLE,
-            ud_err.unwrap_or_else(|| "gw:getUserData".to_string()),
-        );
-    };
+    establish_oauth_session(&client, &jar, &token).await;
 
-    let check_form = ud["checkForm"].as_str().unwrap_or("").to_string();
-    if check_form.is_empty() {
-        return json_error(StatusCode::SERVICE_UNAVAILABLE, "no checkForm");
-    }
+    let uid = api_deezer_get(&client, "/user/me", &token, &[])
+        .await
+        .ok()
+        .and_then(|v| v.get("id").and_then(|x| x.as_i64()))
+        .filter(|id| *id > 0)
+        .map(|id| id.to_string());
 
-    let arl_v = match gw_light_call(&client, &jar, "user.getArl", &check_form, json!({})).await {
-        Ok(v) => v,
-        Err(e) => return json_error(StatusCode::SERVICE_UNAVAILABLE, e),
-    };
-    let arl = arl_v.as_str().unwrap_or("").to_string();
-    if arl.len() < 20 {
-        return json_error(StatusCode::SERVICE_UNAVAILABLE, "no arl");
+    match gw_fetch_arl(&client, "", "", uid.as_deref()).await {
+        Ok((arl, _, _)) if arl.len() >= 20 => {
+            (StatusCode::OK, Json(json!({ "arl": arl }))).into_response()
+        }
+        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
     }
-
-    (StatusCode::OK, Json(json!({ "arl": arl }))).into_response()
 }
 
 #[derive(Debug, Deserialize)]