Upload main.rs

src/main.rs

@@ -1005,7 +1005,10 @@ async fn gw_light_call(
         let mut req = if use_get || method == "user.getArl" {
             client.get(url)
         } else {
-            client.post(url).header("Content-Type", "application/json").body(params.to_string())
+            client
+                .post(url)
+                .header("Content-Type", "text/plain;charset=UTF-8")
+                .body(params.to_string())
         };
 
         let sid = cookie_value(jar, url_deezer, "sid").unwrap_or_default();
@@ -1035,6 +1038,9 @@ async fn gw_light_call(
             .header("Connection", "keep-alive")
             .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("Content-Language", "en-US")
@@ -1078,12 +1084,22 @@ async fn gw_light_call(
         Ok(json.results)
     }
 
-    match do_req(client, jar, &url_deezer, url, method, api_token, &params, false, None).await {
-        Ok(v) => Ok(v),
-        Err(e1) => match do_req(client, jar, &url_deezer, url, method, api_token, &params, false, None).await {
+    if method == "deezer.getUserData" {
+        match do_req(client, jar, &url_deezer, url, method, api_token, &params, true, None).await {
             Ok(v) => Ok(v),
-            Err(e2) => Err(format!("{e1}; retry:{e2}")),
-        },
+            Err(e1) => match do_req(client, jar, &url_deezer, url, method, api_token, &params, false, None).await {
+                Ok(v) => Ok(v),
+                Err(e2) => Err(format!("getUserData:{e1}; fallback:{e2}")),
+            },
+        }
+    } else {
+        match do_req(client, jar, &url_deezer, url, method, api_token, &params, false, None).await {
+            Ok(v) => Ok(v),
+            Err(e1) => match do_req(client, jar, &url_deezer, url, method, api_token, &params, false, None).await {
+                Ok(v) => Ok(v),
+                Err(e2) => Err(format!("{e1}; retry:{e2}")),
+            },
+        }
     }
 }
 
@@ -1109,34 +1125,82 @@ async fn login(Json(req): Json<LoginReq>) -> impl IntoResponse {
         .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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36",
-        )
-        .send()
-        .await;
+    let mut gw_token: Option<String> = None;
+    let mut gw_uid: Option<String> = None;
+    let mut arl_out: Option<String> = None;
+    let mut gw_err: Option<String> = None;
 
-    let access_token = match oauth_access_token(&client, &email, &pass).await {
-        Ok(t) => t,
-        Err(e) => return json_error(StatusCode::UNAUTHORIZED, e),
-    };
+    match gw_light_call(&client, &jar, "deezer.getUserData", "null", json!({})).await {
+        Ok(ud) => {
+            let token = ud["checkForm"].as_str().unwrap_or("").to_string();
+            if token.is_empty() {
+                gw_err = Some("gw:no_checkForm".to_string());
+            } else {
+                gw_token = Some(token.clone());
+                gw_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,
+                    &jar,
+                    "user.checkCredentials",
+                    &token,
+                    json!({
+                        "login": email,
+                        "password": pass,
+                        "checkFormLogin": token
+                    }),
+                )
+                .await
+                {
+                    return json_error(StatusCode::UNAUTHORIZED, e);
+                }
 
-    let me = match api_deezer_get(&client, "/user/me", &access_token, &[]).await {
-        Ok(v) => v,
-        Err(e) => return json_error(StatusCode::SERVICE_UNAVAILABLE, e),
-    };
-    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
-    if uid <= 0 {
-        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
+                if let Ok(v) = gw_light_call(&client, &jar, "user.getArl", &token, json!({})).await {
+                    if let Some(s) = v.as_str() {
+                        if s.len() > 20 {
+                            arl_out = Some(s.to_string());
+                        }
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            gw_err = Some(format!("gw:getUserData:{e}"));
+        }
+    }
+
+    let mut access_token_out: Option<String> = None;
+    let mut oauth_uid: Option<String> = None;
+    if let Ok(access_token) = oauth_access_token(&client, &email, &pass).await {
+        oauth_uid = api_deezer_get(&client, "/user/me", &access_token, &[])
+            .await
+            .ok()
+            .and_then(|v| v.get("id").and_then(|x| x.as_i64()))
+            .filter(|id| *id > 0)
+            .map(|id| id.to_string());
+        access_token_out = Some(access_token);
+    }
+
+    let uid_out = gw_uid.or(oauth_uid).unwrap_or_default();
+
+    if gw_token.is_none() && access_token_out.is_none() {
+        return json_error(
+            StatusCode::UNAUTHORIZED,
+            gw_err.unwrap_or_else(|| "login_failed".to_string()),
+        );
     }
 
     (
         StatusCode::OK,
-        Json(json!({ "arl": "", "token": null, "uid": uid.to_string(), "access_token": access_token })),
+        Json(json!({
+            "arl": arl_out.unwrap_or_default(),
+            "token": gw_token,
+            "uid": uid_out,
+            "access_token": access_token_out
+        })),
     )
         .into_response()
 }
@@ -1344,57 +1408,83 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
         .unwrap();
 
     let pass_md5 = format!("{:x}", md5::compute(password.as_bytes()));
-    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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36",
-        )
-        .send()
-        .await;
-
-    let access_token = match oauth_access_token(&client, &email, &pass_md5).await {
-        Ok(t) => t,
-        Err(e) => {
-            let mut map = state.pair.write().await;
-            if let Some(s) = map.get_mut(&code) {
-                s.error = Some(e.clone());
+    let mut gw_token: Option<String> = None;
+    let mut gw_uid: Option<String> = None;
+    let mut arl_out: Option<String> = None;
+    let mut access_token_out: Option<String> = None;
+
+    if let Ok(ud) = gw_light_call(&client, &jar, "deezer.getUserData", "null", json!({})).await {
+        let token = ud["checkForm"].as_str().unwrap_or("").to_string();
+        if !token.is_empty() {
+            if let Err(e) = gw_light_call(
+                &client,
+                &jar,
+                "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();
             }
-            return Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(&e))).into_response();
-        }
-    };
 
-    let me = match api_deezer_get(&client, "/user/me", &access_token, &[]).await {
-        Ok(v) => v,
-        Err(e) => {
-            let mut map = state.pair.write().await;
-            if let Some(s) = map.get_mut(&code) {
-                s.error = Some(e.clone());
+            gw_token = Some(token.clone());
+            gw_uid = ud["USER"]["USER_ID"]
+                .as_i64()
+                .map(|n| n.to_string())
+                .filter(|s| !s.trim().is_empty());
+
+            if let Ok(v) = gw_light_call(&client, &jar, "user.getArl", &token, json!({})).await {
+                if let Some(s) = v.as_str() {
+                    if s.len() > 20 {
+                        arl_out = Some(s.to_string());
+                    }
+                }
             }
-            return Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(&e))).into_response();
         }
-    };
-    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
-    if uid <= 0 {
-        let msg = "api:no_user_id".to_string();
+    }
+
+    if let Ok(t) = oauth_access_token(&client, &email, &pass_md5).await {
+        access_token_out = Some(t);
+    }
+
+    if gw_token.is_none() && access_token_out.is_none() {
+        let msg = "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();
     }
-    let uid = uid.to_string();
+
+    if gw_uid.is_none() {
+        if let Some(token) = access_token_out.as_deref() {
+            gw_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 mut map = state.pair.write().await;
         if let Some(s) = map.get_mut(&code) {
-            s.access_token = Some(access_token);
-            s.token = None;
-            s.user_id = Some(uid);
+            s.access_token = access_token_out;
+            s.token = gw_token;
+            s.user_id = gw_uid;
             s.email = Some(email);
-            s.arl = None;
+            s.arl = arl_out;
             s.error = None;
         }
     }