Upload main.rs

src/main.rs

@@ -961,11 +961,28 @@ async fn oauth_access_token(
 
 async fn gw_light_call(
     client: &reqwest::Client,
+    jar: &Arc<Jar>,
     method: &str,
     api_token: &str,
     params: serde_json::Value,
 ) -> Result<serde_json::Value, String> {
     let url = "https://www.deezer.com/ajax/gw-light.php";
+    let url_deezer = "https://www.deezer.com".parse::<Url>().unwrap();
+
+    fn cookie_value(jar: &Jar, url: &Url, key: &str) -> Option<String> {
+        let Some(hv) = jar.cookies(url) else { return None };
+        let Ok(s) = hv.to_str() else { return None };
+        for part in s.split(';') {
+            let p = part.trim();
+            if let Some(rest) = p.strip_prefix(&format!("{key}=")) {
+                if !rest.is_empty() {
+                    return Some(rest.to_string());
+                }
+            }
+        }
+        None
+    }
+
     fn cid() -> String {
         SystemTime::now()
             .duration_since(UNIX_EPOCH)
@@ -975,22 +992,36 @@ async fn gw_light_call(
 
     async fn do_req(
         client: &reqwest::Client,
+        jar: &Arc<Jar>,
+        url_deezer: &Url,
         url: &str,
         method: &str,
         api_token: &str,
         params: &serde_json::Value,
         use_get: bool,
+        user_id: Option<&str>,
     ) -> Result<serde_json::Value, String> {
         let cid = cid();
-        let req = if use_get {
+        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", "application/json").body(params.to_string())
         };
 
+        let sid = cookie_value(jar, url_deezer, "sid").unwrap_or_default();
+        let arl = cookie_value(jar, url_deezer, "arl").unwrap_or_default();
+        if !sid.is_empty() || !arl.is_empty() {
+            let mut parts: Vec<String> = Vec::new();
+            parts.push(format!("arl={arl}"));
+            if !sid.is_empty() {
+                parts.push(format!("sid={sid}"));
+            }
+            req = req.header("Cookie", parts.join("; "));
+        }
+        if let Some(uid) = user_id.filter(|s| !s.trim().is_empty()) {
+            req = req.header("x-deezer-user", uid);
+        }
+
         let r = req
             .query(&[
                 ("method", method),
@@ -1000,18 +1031,36 @@ async fn gw_light_call(
                 ("cid", cid.as_str()),
             ])
             .header(ACCEPT, "*/*")
+            .header("Cache-Control", "max-age=0")
+            .header("Connection", "keep-alive")
             .header("Origin", "https://www.deezer.com")
             .header("Referer", "https://www.deezer.com/")
             .header("X-Requested-With", "XMLHttpRequest")
             .header("Accept-Language", "en-US,en;q=0.9")
+            .header("Content-Language", "en-US")
+            .header("X-User-IP", "1.1.1.1")
+            .header("x-deezer-client-ip", "1.1.1.1")
             .header(
                 "User-Agent",
-                "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0",
+                "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36",
             )
             .send()
             .await
             .map_err(|_| "network".to_string())?;
 
+        if method == "deezer.getUserData" {
+            for v in r.headers().get_all("set-cookie").iter() {
+                if let Ok(s) = v.to_str() {
+                    if s.starts_with("sid=") {
+                        let cookie = s.split(';').next().unwrap_or("").trim();
+                        if !cookie.is_empty() {
+                            jar.add_cookie_str(&format!("{cookie}; Domain=.deezer.com"), url_deezer);
+                        }
+                    }
+                }
+            }
+        }
+
         let status = r.status();
         let text = r.text().await.map_err(|_| "read".to_string())?;
         let json: GwResp = serde_json::from_str(&text).map_err(|_| {
@@ -1029,22 +1078,12 @@ async fn gw_light_call(
         Ok(json.results)
     }
 
-    if method == "deezer.getUserData" {
-        match do_req(client, url, method, api_token, &params, false).await {
+    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(e1) => match do_req(client, url, method, api_token, &params, true).await {
-                Ok(v) => Ok(v),
-                Err(e2) => Err(format!("getUserData:{e1}; fallback:{e2}")),
-            },
-        }
-    } else {
-        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 {
-                Ok(v) => Ok(v),
-                Err(e2) => Err(format!("{e1}; retry:{e2}")),
-            },
-        }
+            Err(e2) => Err(format!("{e1}; retry:{e2}")),
+        },
     }
 }