Upload 2 files

src/main.rs

@@ -1180,6 +1180,60 @@ async fn gw_fetch_arl(
     Err(format!("getArl:{last_err}"))
 }
 
+async fn try_fetch_arl_for_token(
+    access_token: &str,
+    user_id: Option<&str>,
+) -> (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),
+    };
+    jar.add_cookie_str("comeback=1; Domain=.deezer.com; Path=/", &url_deezer);
+
+    let client = match reqwest::Client::builder()
+        .no_proxy()
+        .cookie_provider(jar.clone())
+        .timeout(std::time::Duration::from_secs(20))
+        .build()
+    {
+        Ok(c) => c,
+        Err(_) => return (None, None),
+    };
+
+    let _ = client
+        .get("https://www.deezer.com/")
+        .header(ACCEPT, "*/*")
+        .header("User-Agent", gw_browser_ua())
+        .send()
+        .await;
+
+    if ensure_anonymous_sid(&client, &jar).await.is_err() {
+        return (None, None);
+    }
+
+    establish_oauth_session(&client, &jar, access_token).await;
+
+    let uid = if let Some(uid) = user_id.filter(|s| !s.trim().is_empty()) {
+        Some(uid.to_string())
+    } else {
+        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())
+    };
+
+    match gw_fetch_arl(&client, "", "", uid.as_deref()).await {
+        Ok((arl, token, _)) if arl.len() >= 20 => {
+            let gw_token = if token.is_empty() { None } else { Some(token) };
+            (Some(arl), gw_token)
+        }
+        _ => (None, None),
+    }
+}
+
 async fn oauth_access_token(
     client: &reqwest::Client,
     email: &str,
@@ -1819,13 +1873,49 @@ async fn pair_oauth(State(state): State<AppState>, Json(req): Json<PairOauthReq>
         return json_error(StatusCode::BAD_REQUEST, "code/access_token required");
     }
 
+    let http = reqwest::Client::builder()
+        .no_proxy()
+        .timeout(std::time::Duration::from_secs(15))
+        .build()
+        .unwrap();
+    let email = api_deezer_get(&http, "/user/me", &access_token, &[])
+        .await
+        .ok()
+        .and_then(|v| v.get("email").and_then(|x| x.as_str()).map(|s| s.to_string()));
+
+    let uid_from_api = if user_id.is_empty() {
+        api_deezer_get(&http, "/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())
+    } else {
+        Some(user_id.clone())
+    };
+
+    let (arl_opt, token_opt) = try_fetch_arl_for_token(
+        &access_token,
+        uid_from_api.as_deref(),
+    )
+    .await;
+
     let mut map = state.pair.write().await;
     let Some(sess) = map.get_mut(&code) else {
         return json_error(StatusCode::NOT_FOUND, "no such code");
     };
     sess.access_token = Some(access_token);
-    if !user_id.is_empty() {
-        sess.user_id = Some(user_id);
+    if let Some(uid) = uid_from_api {
+        sess.user_id = Some(uid);
+    }
+    if let Some(arl) = arl_opt {
+        sess.arl = Some(arl);
+    }
+    if let Some(token) = token_opt {
+        sess.token = Some(token);
+    }
+    if let Some(email) = email {
+        sess.email = Some(email);
     }
     sess.error = None;
     drop(map);
@@ -2008,6 +2098,22 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
             Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(&e))).into_response()
         }
         Ok(login) => {
+            let email_from_api = {
+                let http = reqwest::Client::builder()
+                    .no_proxy()
+                    .timeout(std::time::Duration::from_secs(10))
+                    .build()
+                    .ok();
+                if let Some(http) = http {
+                    api_deezer_get(&http, "/user/me", &login.access_token, &[])
+                        .await
+                        .ok()
+                        .and_then(|v| v.get("email").and_then(|x| x.as_str()).map(|s| s.to_string()))
+                } else {
+                    None
+                }
+            };
+
             let mut map = state.pair.write().await;
             if let Some(s) = map.get_mut(&code) {
                 s.arl = login.arl.clone();
@@ -2020,7 +2126,7 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
                 if !login.uid.is_empty() {
                     s.user_id = Some(login.uid.clone());
                 }
-                s.email = Some(email);
+                s.email = email_from_api.or(Some(email));
                 s.error = None;
             }
             drop(map);
@@ -2169,7 +2275,7 @@ async fn oauth_arl(Json(req): Json<OauthArlReq>) -> impl IntoResponse {
         Ok((arl, _, _)) if arl.len() >= 20 => {
             (StatusCode::OK, Json(json!({ "arl": arl }))).into_response()
         }
-        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, format!("oauth_arl:{e}")),
     }
 }