Upload main.rs

src/main.rs

@@ -987,7 +987,7 @@ async fn gw_light_call(
         } else {
             client
                 .post(url)
-                .header("Content-Type", "text/plain;charset=UTF-8")
+                .header("Content-Type", "application/json")
                 .body(params.to_string())
         };
 
@@ -1002,9 +1002,6 @@ async fn gw_light_call(
             .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("X-Requested-With", "XMLHttpRequest")
             .header("Accept-Language", "en-US,en;q=0.9")
             .header(
@@ -1033,9 +1030,9 @@ async fn gw_light_call(
     }
 
     if method == "deezer.getUserData" {
-        match do_req(client, url, method, api_token, &params, true).await {
+        match do_req(client, url, method, api_token, &params, false).await {
             Ok(v) => Ok(v),
-            Err(e1) => match do_req(client, url, method, api_token, &params, false).await {
+            Err(e1) => match do_req(client, url, method, api_token, &params, true).await {
                 Ok(v) => Ok(v),
                 Err(e2) => Err(format!("getUserData:{e1}; fallback:{e2}")),
             },
@@ -1066,7 +1063,6 @@ async fn login(Json(req): Json<LoginReq>) -> 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);
     let client = reqwest::Client::builder()
         .cookie_provider(jar.clone())
@@ -1074,36 +1070,6 @@ async fn login(Json(req): Json<LoginReq>) -> impl IntoResponse {
         .build()
         .unwrap();
 
-    let mut access_token_out: Option<String> = None;
-    if let Ok(access_token) = oauth_access_token(&client, &email, &pass).await {
-        access_token_out = Some(access_token.clone());
-        let _ = client
-            .get("https://api.deezer.com/platform/generic/track/80085")
-            .header("Authorization", format!("Bearer {}", access_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;
-
-        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 {}", access_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::BAD_GATEWAY, e),
@@ -1119,33 +1085,29 @@ async fn login(Json(req): Json<LoginReq>) -> impl IntoResponse {
         .map(|n| n.to_string())
         .unwrap_or_default();
 
-    let arl_v = match gw_light_call(&client, "user.getArl", &token, json!({})).await {
-        Ok(v) => v,
-        Err(e1) => {
-            let cred = gw_light_call(
-                &client,
-                "user.checkCredentials",
-                &token,
-                json!({
-                    "login": email,
-                    "password": pass,
-                    "checkFormLogin": token
-                }),
-            )
-            .await;
-            if let Err(e) = cred {
-                return json_error(StatusCode::UNAUTHORIZED, e);
-            }
-            match gw_light_call(&client, "user.getArl", &token, json!({})).await {
-                Ok(v) => v,
-                Err(e2) => return json_error(StatusCode::BAD_GATEWAY, format!("getArl:{e1}; retry:{e2}")),
-            }
-        }
-    };
+    if let Err(e) = gw_light_call(
+        &client,
+        "user.checkCredentials",
+        &token,
+        json!({
+            "login": email,
+            "password": pass,
+            "checkFormLogin": token
+        }),
+    )
+    .await
+    {
+        return json_error(StatusCode::UNAUTHORIZED, e);
+    }
 
-    let arl = arl_v.as_str().unwrap_or("").to_string();
-    if arl.len() < 20 {
-        return json_error(StatusCode::BAD_GATEWAY, "no arl");
+    let mut arl: String = String::new();
+    if let Ok(v) = gw_light_call(&client, "user.getArl", &token, json!({})).await {
+        arl = v.as_str().unwrap_or("").to_string();
+    }
+
+    let mut access_token_out: Option<String> = None;
+    if let Ok(access_token) = oauth_access_token(&client, &email, &pass).await {
+        access_token_out = Some(access_token);
     }
 
     (StatusCode::OK, Json(json!({ "arl": arl, "token": token, "uid": uid, "access_token": access_token_out }))).into_response()
@@ -1234,6 +1196,13 @@ async fn pair_status(State(state): State<AppState>, Query(q): Query<PairStatusQu
         )
             .into_response();
     }
+    if sess.token.as_deref().unwrap_or("").trim().len() > 0 {
+        return (
+            StatusCode::OK,
+            Json(json!({ "status": "ok", "access_token": null, "token": sess.token, "user_id": sess.user_id, "email": sess.email, "arl": sess.arl })),
+        )
+            .into_response();
+    }
 
     (StatusCode::OK, Json(json!({ "status": "pending" }))).into_response()
 }
@@ -1358,42 +1327,6 @@ async fn api_deezer_get(
     Ok(v)
 }
 
-async fn upstream_login(email: &str, password_md5: &str) -> Result<serde_json::Value, String> {
-    let Some(base) = upstream_dzmedia_base() else {
-        return Err("upstream:disabled".to_string());
-    };
-    let url = format!("{base}/login");
-    let client = reqwest::Client::builder()
-        .timeout(std::time::Duration::from_secs(20))
-        .build()
-        .map_err(|_| "upstream:client".to_string())?;
-    let r = client
-        .post(url)
-        .json(&json!({ "email": email, "password_md5": password_md5 }))
-        .send()
-        .await
-        .map_err(|_| "upstream:network".to_string())?;
-
-    let status = r.status();
-    let text = r.text().await.map_err(|_| "upstream:read".to_string())?;
-    let v: serde_json::Value = serde_json::from_str(&text).map_err(|_| {
-        let snip: String = text.chars().take(200).collect();
-        format!("upstream:parse:{}:{}", status.as_u16(), snip)
-    })?;
-    if !status.is_success() {
-        let msg = v
-            .get("error")
-            .and_then(|x| x.as_str())
-            .map(|s| s.to_string())
-            .unwrap_or_else(|| {
-                let snip: String = text.chars().take(200).collect();
-                format!("upstream:{}:{}", status.as_u16(), snip)
-            });
-        return Err(msg);
-    }
-    Ok(v)
-}
-
 async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairCompleteForm>) -> impl IntoResponse {
     let code = f.code.trim().to_string();
     let email = f.email.trim().to_string();
@@ -1422,138 +1355,72 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
     let mut access_token: Option<String> = None;
     let mut uid: Option<String> = None;
     let mut arl_out: Option<String> = None;
-    let mut login_err: Option<String> = None;
     let mut gw_token: Option<String> = None;
-    let mut gw_err: Option<String> = None;
 
-    match oauth_access_token(&client, &email, &pass_md5).await {
-        Ok(t) => access_token = Some(t),
+    let ud = match gw_light_call(&client, "deezer.getUserData", "null", json!({})).await {
+        Ok(v) => v,
         Err(e) => {
-            login_err = Some(e.clone());
-            match upstream_login(&email, &pass_md5).await {
-                Ok(v) => {
-                    if let Some(t) = v.get("access_token").and_then(|x| x.as_str()) {
-                        if !t.trim().is_empty() {
-                            access_token = Some(t.trim().to_string());
-                        }
-                    }
-                    if let Some(u) = v.get("uid").and_then(|x| x.as_str()) {
-                        if !u.trim().is_empty() {
-                            uid = Some(u.trim().to_string());
-                        }
-                    } else if let Some(u) = v.get("uid").and_then(|x| x.as_i64()) {
-                        uid = Some(u.to_string());
-                    }
-                    if let Some(a) = v.get("arl").and_then(|x| x.as_str()) {
-                        if a.trim().len() > 20 {
-                            arl_out = Some(a.trim().to_string());
-                        }
-                    }
-                }
-                Err(e2) => {
-                    login_err = Some(format!("{e}; upstream:{e2}"));
-                }
+            let mut map = state.pair.write().await;
+            if let Some(s) = map.get_mut(&code) {
+                s.error = Some(format!("gw:getUserData:{e}"));
             }
+            return Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(&format!("gw:getUserData:{e}"))))
+                .into_response();
         }
-    }
-
-    if let Some(tok) = access_token.as_ref() {
-        let _ = client
-            .get("https://api.deezer.com/platform/generic/track/80085")
-            .header("Authorization", format!("Bearer {}", tok))
-            .send()
-            .await;
+    };
 
-        if uid.is_none() {
-            match api_deezer_get(&client, "/user/me", tok, &[]).await {
-                Ok(me) => uid = me.get("id").and_then(|x| x.as_i64()).map(|n| n.to_string()),
-                Err(e) => {
-                    let mut map = state.pair.write().await;
-                    if let Some(s) = map.get_mut(&code) {
-                        s.error = Some(e.clone());
-                    }
-                    return Html(format!("<h3>Ошибка Deezer API</h3><pre>{}</pre>", htmlesc(&e))).into_response();
-                }
-            }
+    let token = ud["checkForm"].as_str().unwrap_or("").to_string();
+    if token.is_empty() {
+        let msg = "gw:no_checkForm";
+        let mut map = state.pair.write().await;
+        if let Some(s) = map.get_mut(&code) {
+            s.error = Some(msg.to_string());
+        }
+        return Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(msg))).into_response();
+    }
+    gw_token = Some(token.clone());
+    uid = ud["USER"]["USER_ID"]
+        .as_i64()
+        .map(|n| n.to_string())
+        .filter(|s| !s.trim().is_empty());
+
+    if let Err(e) = gw_light_call(
+        &client,
+        "user.checkCredentials",
+        &token,
+        json!({
+            "login": email,
+            "password": pass_md5,
+            "checkFormLogin": token
+        }),
+    )
+    .await
+    {
+        let mut map = state.pair.write().await;
+        if let Some(s) = map.get_mut(&code) {
+            s.error = Some(format!("gw:checkCredentials:{e}"));
         }
+        return Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(&format!("gw:checkCredentials:{e}"))))
+            .into_response();
     }
 
-    if arl_out.is_none() {
-        match gw_light_call(&client, "deezer.getUserData", "null", json!({})).await {
-            Ok(ud) => {
-                let token = ud["checkForm"].as_str().unwrap_or("").to_string();
-                let gw_uid = ud["USER"]["USER_ID"]
-                    .as_i64()
-                    .map(|n| n.to_string())
-                    .unwrap_or_default();
-                if !gw_uid.is_empty() && uid.is_none() {
-                    uid = Some(gw_uid);
-                }
-                if !token.is_empty() {
-                    gw_token = Some(token.clone());
-                    match gw_light_call(
-                        &client,
-                        "user.checkCredentials",
-                        &token,
-                        json!({
-                            "login": email,
-                            "password": pass_md5,
-                            "checkFormLogin": token
-                        }),
-                    )
-                    .await
-                    {
-                        Ok(_) => match gw_light_call(&client, "user.getArl", &token, json!({})).await {
-                            Ok(v) => {
-                                if let Some(s) = v.as_str() {
-                                    if s.len() > 20 {
-                                        arl_out = Some(s.to_string());
-                                    } else {
-                                        gw_err = Some("gw:no_arl".to_string());
-                                    }
-                                } else {
-                                    gw_err = Some("gw:no_arl".to_string());
-                                }
-                            }
-                            Err(e) => {
-                                gw_err = Some(format!("gw:getArl:{e}"));
-                            }
-                        },
-                        Err(e) => {
-                            gw_err = Some(format!("gw:checkCredentials:{e}"));
-                        }
-                    }
-                } else {
-                    gw_err = Some("gw:no_checkForm".to_string());
-                }
-            }
-            Err(e) => {
-                gw_err = Some(format!("gw:getUserData:{e}"));
+    if let Ok(v) = gw_light_call(&client, "user.getArl", &token, json!({})).await {
+        if let Some(s) = v.as_str() {
+            if s.len() > 20 {
+                arl_out = Some(s.to_string());
             }
         }
     }
 
-    if access_token.is_none() && arl_out.as_deref().unwrap_or("").len() < 20 {
-        let msg = match (login_err, gw_err) {
-            (Some(a), Some(b)) => format!("{a}; {b}"),
-            (Some(a), None) => a,
-            (None, Some(b)) => b,
-            (None, None) => "login_failed".to_string(),
-        };
-        let mut map = state.pair.write().await;
-        if let Some(s) = map.get_mut(&code) {
-            s.error = Some(msg.clone());
-        }
-        return Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(&msg))).into_response();
+    if let Ok(t) = oauth_access_token(&client, &email, &pass_md5).await {
+        access_token = Some(t);
     }
 
     {
         let mut map = state.pair.write().await;
         if let Some(s) = map.get_mut(&code) {
             s.access_token = access_token;
-            if gw_token.is_some() {
-                s.token = gw_token;
-            }
+            s.token = gw_token;
             s.user_id = uid;
             s.email = Some(email);
             s.arl = arl_out;