Upload main.rs

src/main.rs

@@ -8,7 +8,7 @@
 };
 use tower_http::{cors::{CorsLayer, Any}, compression::CompressionLayer, trace::TraceLayer};
 use serde_json::json;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
 use bytes::Bytes;
@@ -35,6 +35,7 @@ struct AppState {
     api: Arc<Mutex<APIClient>>,
     api_by_arl: Arc<RwLock<HashMap<String, Arc<Mutex<APIClient>>>>>,
     pair: Arc<RwLock<HashMap<String, PairSession>>>,
+    pair_store_path: String,
 }
 
 fn json_error(status: StatusCode, message: impl Into<String>) -> axum::response::Response {
@@ -1019,6 +1020,98 @@ async fn mobile_login(email: &str, password_md5: &str) -> Result<String, String>
     Ok(arl)
 }
 
+async fn web_login(email: &str, password_md5: &str) -> Result<String, String> {
+    let jar = Arc::new(Jar::default());
+    let url_deezer = "https://www.deezer.com".parse::<Url>().map_err(|_| "web:url".to_string())?;
+    jar.add_cookie_str("comeback=1; Domain=.deezer.com; Path=/", &url_deezer);
+
+    let client = reqwest::Client::builder()
+        .no_proxy()
+        .cookie_provider(jar.clone())
+        .timeout(std::time::Duration::from_secs(25))
+        .build()
+        .map_err(|_| "web:client".to_string())?;
+
+    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 ud = gw_light_call_custom(
+        &client,
+        "deezer.getUserData",
+        "null",
+        None,
+        &json!({}),
+        None,
+        false,
+    )
+    .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());
+    }
+
+    let _ = gw_light_call_custom(
+        &client,
+        "user.checkCredentials",
+        &check_form,
+        None,
+        &json!({
+            "login": email,
+            "password": password_md5,
+            "checkFormLogin": check_form
+        }),
+        None,
+        false,
+    )
+    .await
+    .map_err(|e| format!("web:checkCredentials:{e}"))?;
+
+    let ud2 = gw_light_call_custom(
+        &client,
+        "deezer.getUserData",
+        "null",
+        None,
+        &json!({}),
+        None,
+        false,
+    )
+    .await
+    .map_err(|e| format!("web:getUserData2:{e}"))?;
+
+    let check_form2 = ud2.get("checkForm").and_then(|x| x.as_str()).unwrap_or("").trim().to_string();
+    if check_form2.is_empty() {
+        return Err("web:no_checkForm2".to_string());
+    }
+
+    let arl_v = gw_light_call_custom(
+        &client,
+        "user.getArl",
+        &check_form2,
+        None,
+        &json!({}),
+        None,
+        true,
+    )
+    .await
+    .map_err(|e| format!("web:getArl:{e}"))?;
+
+    let arl = arl_v.as_str().unwrap_or("").to_string();
+    if arl.len() < 100 {
+        return Err(format!("web:arl_too_short:{}", arl.len()));
+    }
+    Ok(arl)
+}
+
 
 async fn gw_light_call(
     client: &reqwest::Client,
@@ -1223,21 +1316,26 @@ async fn login(Json(req): Json<LoginReq>) -> impl IntoResponse {
         return json_error(StatusCode::BAD_REQUEST, "Email and password_md5 required");
     }
 
-    // Используем мобильный API — не блокируется Cloudflare в датацентрах
     match mobile_login(&email, &pass).await {
-        Ok(arl) => {
-            (StatusCode::OK, Json(json!({
+        Ok(arl) => (StatusCode::OK, Json(json!({
+            "arl":          arl,
+            "token":        null,
+            "uid":          "",
+            "access_token": null
+        }))).into_response(),
+        Err(e1) => match web_login(&email, &pass).await {
+            Ok(arl) => (StatusCode::OK, Json(json!({
                 "arl":          arl,
                 "token":        null,
                 "uid":          "",
                 "access_token": null
-            }))).into_response()
+            }))).into_response(),
+            Err(e2) => json_error(StatusCode::UNAUTHORIZED, format!("login_failed; mobile:{e1}; web:{e2}")),
         }
-        Err(e) => json_error(StatusCode::UNAUTHORIZED, format!("login_failed; {e}")),
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Serialize, Deserialize)]
 struct PairSession {
     created_ms: u128,
     access_token: Option<String>,
@@ -1248,6 +1346,34 @@ struct PairSession {
     error: Option<String>,
 }
 
+async fn pair_store_load(state: &AppState) {
+    let path = state.pair_store_path.trim();
+    if path.is_empty() {
+        return;
+    }
+    if let Ok(txt) = tokio::fs::read_to_string(path).await {
+        if let Ok(map) = serde_json::from_str::<HashMap<String, PairSession>>(&txt) {
+            *state.pair.write().await = map;
+        }
+    }
+}
+
+async fn pair_store_save(state: &AppState) {
+    let path = state.pair_store_path.trim();
+    if path.is_empty() {
+        return;
+    }
+    let map = state.pair.read().await.clone();
+    let Ok(txt) = serde_json::to_string(&map) else { return };
+    let tmp = format!("{path}.tmp");
+    if tokio::fs::write(&tmp, txt).await.is_ok() {
+        if tokio::fs::rename(&tmp, path).await.is_err() {
+            let _ = tokio::fs::remove_file(path).await;
+            let _ = tokio::fs::rename(&tmp, path).await;
+        }
+    }
+}
+
 fn gen_pair_code() -> String {
     let ms = now_ms();
     let hex = format!("{:x}", md5::compute(format!("pair:{ms}:{SECRET}").as_bytes()));
@@ -1315,6 +1441,7 @@ async fn pair_start(State(state): State<AppState>) -> impl IntoResponse {
             },
         );
     }
+    pair_store_save(&state).await;
     (StatusCode::OK, Json(json!({ "code": code }))).into_response()
 }
 
@@ -1332,6 +1459,8 @@ async fn pair_status(State(state): State<AppState>, Query(q): Query<PairStatusQu
     };
     if now.saturating_sub(sess.created_ms) > ttl_ms {
         map.remove(&code);
+        drop(map);
+        pair_store_save(&state).await;
         return json_error(StatusCode::NOT_FOUND, "code expired");
     }
 
@@ -1399,6 +1528,8 @@ async fn pair_oauth(State(state): State<AppState>, Json(req): Json<PairOauthReq>
         sess.user_id = Some(user_id);
     }
     sess.error = None;
+    drop(map);
+    pair_store_save(&state).await;
     (StatusCode::OK, Json(json!({ "ok": true }))).into_response()
 }
 
@@ -1564,26 +1695,34 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
 
     let pass_md5 = format!("{:x}", md5::compute(password.as_bytes()));
 
-    // Мобильный API — не блокируется Cloudflare
-    match mobile_login(&email, &pass_md5).await {
+    let res = match mobile_login(&email, &pass_md5).await {
+        Ok(arl) => Ok(arl),
+        Err(e1) => match web_login(&email, &pass_md5).await {
+            Ok(arl) => Ok(arl),
+            Err(e2) => Err(format!("mobile:{e1}; web:{e2}")),
+        },
+    };
+
+    match res {
         Err(e) => {
             let mut map = state.pair.write().await;
             if let Some(s) = map.get_mut(&code) {
                 s.error = Some(e.clone());
             }
+            drop(map);
+            pair_store_save(&state).await;
             Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(&e))).into_response()
         }
         Ok(arl) => {
-            {
-                let mut map = state.pair.write().await;
-                if let Some(s) = map.get_mut(&code) {
-                    s.arl   = Some(arl);
-                    s.email = Some(email);
-                    s.error = None;
-                }
+            let mut map = state.pair.write().await;
+            if let Some(s) = map.get_mut(&code) {
+                s.arl = Some(arl);
+                s.email = Some(email);
+                s.error = None;
             }
-            Html("<h3>Готово</h3><p>Вернись на ТВ — плагин подключится автоматически.</p>".to_string())
-                .into_response()
+            drop(map);
+            pair_store_save(&state).await;
+            Html("<h3>Готово</h3><p>Вернись на ТВ — плагин подключится автоматически.</p>".to_string()).into_response()
         }
     }
 }
@@ -1815,6 +1954,7 @@ async fn gw_page(Json(req): Json<GwPageReq>) -> impl IntoResponse {
     jar.add_cookie_str(&format!("arl={arl}; Domain=.deezer.com; Path=/"), &url_deezer);
 
     let client = reqwest::Client::builder()
+        .no_proxy()
         .cookie_provider(jar.clone())
         .timeout(std::time::Duration::from_secs(20))
         .build()
@@ -1944,6 +2084,7 @@ async fn gw_flow(Json(req): Json<GwFlowReq>) -> impl IntoResponse {
     jar.add_cookie_str(&format!("arl={arl}; Domain=.deezer.com; Path=/"), &url_deezer);
 
     let client = reqwest::Client::builder()
+        .no_proxy()
         .cookie_provider(jar.clone())
         .timeout(std::time::Duration::from_secs(20))
         .build()
@@ -2208,7 +2349,9 @@ async fn main() {
         api: Arc::new(Mutex::new(APIClient::new())),
         api_by_arl: 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()),
     };
+    pair_store_load(&state).await;
 
     let cors = CorsLayer::new()
         .allow_origin(Any)