Upload 2 files

src/api.rs

@@ -1,5 +1,6 @@
 use serde::{Serialize, Deserialize, de::DeserializeOwned};
 use std::{env, marker::Sized, time::Instant, sync::Arc};
+use std::time::{SystemTime, UNIX_EPOCH};
 use thiserror::Error;
 use serde_json::{json, value::from_value};
 use reqwest::{Client, Response, cookie::Jar, Url, header::ACCEPT};
@@ -107,21 +108,31 @@ impl APIClient {
         }
 
         let url = "https://www.deezer.com/ajax/gw-light.php";
-        let req = if method == "deezer.getUserData" {
-            self.client.get(url)
-        } else {
-            self.client.post(url).json(params)
-        };
-        let json: DeezerResponse = req
+        let cid = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|d| d.as_millis().to_string())
+            .unwrap_or_else(|_| "0".to_string());
+
+        let body = serde_json::to_string(params)?;
+
+        let json: DeezerResponse = self
+            .client
+            .post(url)
+            .header("Content-Type", "text/plain;charset=UTF-8")
+            .body(body)
             .query(&[
                 ("method", method),
                 ("input", "3"),
                 ("api_version", "1.0"),
                 ("api_token", check_form),
+                ("cid", cid.as_str()),
             ])
             .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(

src/main.rs

@@ -20,6 +20,7 @@ use cbc::Decryptor;
 use reqwest::{cookie::Jar, Url};
 use reqwest::cookie::CookieStore;
 use reqwest::header::ACCEPT;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 type BoxErr = Box<dyn std::error::Error + Send + Sync + 'static>;
 
@@ -436,46 +437,89 @@ async fn gw_light_call(
     params: serde_json::Value,
 ) -> Result<serde_json::Value, String> {
     let url = "https://www.deezer.com/ajax/gw-light.php";
-    let req = if method == "deezer.getUserData" {
-        client.get(url)
-    } else {
-        client.post(url).json(&params)
-    };
-    let r = req
-        .query(&[
-            ("method", method),
-            ("input", "3"),
-            ("api_version", "1.0"),
-            ("api_token", api_token),
-        ])
-        .header(ACCEPT, "*/*")
-        .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(
-            "User-Agent",
-            "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0",
-        )
-        .send()
-        .await
-        .map_err(|_| "network".to_string())?;
-
-    let status = r.status();
-    let text = r.text().await.map_err(|_| "read".to_string())?;
-    let json: GwResp = serde_json::from_str(&text).map_err(|_| {
-        let snip: String = text.chars().take(200).collect();
-        format!("parse:{}:{}", status.as_u16(), snip)
-    })?;
+    fn cid() -> String {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|d| d.as_millis().to_string())
+            .unwrap_or_else(|_| "0".to_string())
+    }
 
-    if let Some(error) = json.error.as_object() {
-        for (code, message) in error {
-            let msg = message.as_str().unwrap_or("");
-            return Err(format!("{}:{}", code, msg));
+    async fn do_req(
+        client: &reqwest::Client,
+        url: &str,
+        method: &str,
+        api_token: &str,
+        params: &serde_json::Value,
+        use_get: bool,
+    ) -> Result<serde_json::Value, String> {
+        let cid = cid();
+        let req = if use_get {
+            client.get(url)
+        } else {
+            client
+                .post(url)
+                .header("Content-Type", "text/plain;charset=UTF-8")
+                .body(params.to_string())
+        };
+
+        let r = req
+            .query(&[
+                ("method", method),
+                ("input", "3"),
+                ("api_version", "1.0"),
+                ("api_token", api_token),
+                ("cid", cid.as_str()),
+            ])
+            .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(
+                "User-Agent",
+                "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0",
+            )
+            .send()
+            .await
+            .map_err(|_| "network".to_string())?;
+
+        let status = r.status();
+        let text = r.text().await.map_err(|_| "read".to_string())?;
+        let json: GwResp = serde_json::from_str(&text).map_err(|_| {
+            let snip: String = text.chars().take(200).collect();
+            format!("parse:{}:{}", status.as_u16(), snip)
+        })?;
+
+        if let Some(error) = json.error.as_object() {
+            for (code, message) in error {
+                let msg = message.as_str().unwrap_or("");
+                return Err(format!("{}:{}", code, msg));
+            }
         }
+
+        Ok(json.results)
     }
 
-    Ok(json.results)
+    if method == "deezer.getUserData" {
+        match do_req(client, url, method, api_token, &params, true).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!("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}")),
+            },
+        }
+    }
 }
 
 fn jar_has_cookie(jar: &Jar, url: &Url, cookie_prefix: &str) -> bool {