Upload main.rs

src/main.rs

@@ -1064,6 +1064,87 @@ async fn gw_light_call(
     }
 }
 
+async fn gw_light_call_custom(
+    client: &reqwest::Client,
+    method: &str,
+    api_token: &str,
+    gateway_input: Option<&str>,
+    params: &serde_json::Value,
+    user_id: Option<&str>,
+    use_get: bool,
+) -> Result<serde_json::Value, String> {
+    fn cid() -> String {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|d| d.as_millis().to_string())
+            .unwrap_or_else(|_| "0".to_string())
+    }
+
+    let cid = cid();
+    let mut req = if use_get || method == "user.getArl" {
+        client.get("https://www.deezer.com/ajax/gw-light.php")
+    } else {
+        client
+            .post("https://www.deezer.com/ajax/gw-light.php")
+            .header("Content-Type", "text/plain;charset=UTF-8")
+            .body(params.to_string())
+    };
+
+    if let Some(uid) = user_id.filter(|s| !s.trim().is_empty()) {
+        req = req.header("x-deezer-user", uid);
+    }
+
+    let mut qp: Vec<(&str, &str)> = vec![
+        ("method", method),
+        ("input", "3"),
+        ("api_version", "1.0"),
+        ("api_token", api_token),
+        ("cid", cid.as_str()),
+    ];
+    if let Some(gi) = gateway_input.filter(|s| !s.trim().is_empty()) {
+        qp.push(("gateway_input", gi));
+    }
+
+    let r = req
+        .query(&qp)
+        .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("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")
+        .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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36",
+        )
+        .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)
+}
+
 fn jar_has_cookie(jar: &Jar, url: &Url, cookie_prefix: &str) -> bool {
     let Some(hv) = jar.cookies(url) else { return false };
     let Ok(s) = hv.to_str() else { return false };
@@ -1799,6 +1880,226 @@ async fn oauth_arl(Json(req): Json<OauthArlReq>) -> impl IntoResponse {
     (StatusCode::OK, Json(json!({ "arl": arl }))).into_response()
 }
 
+#[derive(Debug, Deserialize)]
+struct GwPageReq {
+    arl: String,
+    token: Option<String>,
+    user_id: Option<String>,
+    page: Option<String>,
+    lang: Option<String>,
+}
+
+async fn gw_page(Json(req): Json<GwPageReq>) -> impl IntoResponse {
+    let arl = req.arl.trim().to_string();
+    if arl.len() < 20 {
+        return json_error(StatusCode::BAD_REQUEST, "arl required");
+    }
+    let page = req.page.unwrap_or_else(|| "home".to_string()).trim().to_string();
+    if page.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "page required");
+    }
+    let lang = req
+        .lang
+        .unwrap_or_else(|| "en".to_string())
+        .trim()
+        .to_string();
+    let lang = if lang.is_empty() { "en".to_string() } else { lang };
+
+    let jar = Arc::new(Jar::default());
+    let url_deezer = "https://www.deezer.com".parse::<Url>().unwrap();
+    jar.add_cookie_str("comeback=1; Domain=.deezer.com", &url_deezer);
+    jar.add_cookie_str(&format!("arl={arl}; Domain=.deezer.com; Path=/"), &url_deezer);
+
+    let client = reqwest::Client::builder()
+        .cookie_provider(jar.clone())
+        .timeout(std::time::Duration::from_secs(20))
+        .build()
+        .unwrap();
+
+    let ud = match gw_light_call_custom(
+        &client,
+        "deezer.getUserData",
+        "null",
+        None,
+        &json!({}),
+        None,
+        true,
+    )
+    .await
+    {
+        Ok(v) => v,
+        Err(e) => return json_error(StatusCode::UNAUTHORIZED, format!("gw:getUserData:{e}")),
+    };
+
+    let token = req
+        .token
+        .unwrap_or_default()
+        .trim()
+        .to_string()
+        .chars()
+        .filter(|c| !c.is_control())
+        .collect::<String>();
+    let api_token = if !token.is_empty() {
+        token
+    } else {
+        ud.get("checkForm")
+            .and_then(|x| x.as_str())
+            .unwrap_or("")
+            .trim()
+            .to_string()
+    };
+    if api_token.is_empty() {
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, "gw:no_checkForm");
+    }
+
+    let user_id = req
+        .user_id
+        .unwrap_or_default()
+        .trim()
+        .to_string()
+        .chars()
+        .filter(|c| c.is_ascii_digit())
+        .collect::<String>();
+    let user_id = if !user_id.is_empty() {
+        Some(user_id)
+    } else {
+        ud.get("USER")
+            .and_then(|u| u.get("USER_ID"))
+            .and_then(|x| x.as_i64())
+            .filter(|n| *n > 0)
+            .map(|n| n.to_string())
+    };
+
+    let support = json!({
+        "ads": [],
+        "deeplink-list": ["deeplink"],
+        "event-card": ["live-event"],
+        "grid-preview-one": ["album","artist","artistLineUp","channel","livestream","flow","playlist","radio","show","smarttracklist","track","user","video-link","external-link"],
+        "grid-preview-two": ["album","artist","artistLineUp","channel","livestream","flow","playlist","radio","show","smarttracklist","track","user","video-link","external-link"],
+        "grid": ["album","artist","artistLineUp","channel","livestream","flow","playlist","radio","show","smarttracklist","track","user","video-link","external-link"],
+        "horizontal-grid": ["album","artist","artistLineUp","channel","livestream","flow","playlist","radio","show","smarttracklist","track","user","video-link","external-link"],
+        "horizontal-list": ["track","song"],
+        "item-highlight": ["radio"],
+        "large-card": ["album","external-link","playlist","show","video-link"],
+        "list": ["episode"],
+        "mini-banner": ["external-link"],
+        "slideshow": ["album","artist","channel","external-link","flow","livestream","playlist","show","smarttracklist","user","video-link"],
+        "small-horizontal-grid": ["flow"],
+        "long-card-horizontal-grid": ["album","artist","artistLineUp","channel","livestream","flow","playlist","radio","show","smarttracklist","track","user","video-link","external-link"],
+        "filterable-grid": ["flow"]
+    });
+
+    let gateway_input = json!({
+        "PAGE": page,
+        "VERSION": "2.5",
+        "SUPPORT": support,
+        "LANG": lang,
+        "OPTIONS": ["deeplink_newsandentertainment", "deeplink_subscribeoffer"]
+    })
+    .to_string();
+
+    let results = match gw_light_call_custom(
+        &client,
+        "page.get",
+        &api_token,
+        Some(&gateway_input),
+        &json!({}),
+        user_id.as_deref(),
+        false,
+    )
+    .await
+    {
+        Ok(v) => v,
+        Err(e) => return json_error(StatusCode::SERVICE_UNAVAILABLE, format!("gw:page.get:{e}")),
+    };
+
+    (StatusCode::OK, Json(json!({ "results": results }))).into_response()
+}
+
+#[derive(Debug, Deserialize)]
+struct GwFlowReq {
+    arl: String,
+    token: Option<String>,
+    user_id: String,
+    config_id: Option<String>,
+}
+
+async fn gw_flow(Json(req): Json<GwFlowReq>) -> impl IntoResponse {
+    let arl = req.arl.trim().to_string();
+    if arl.len() < 20 {
+        return json_error(StatusCode::BAD_REQUEST, "arl required");
+    }
+    let user_id = req.user_id.trim().to_string();
+    if user_id.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "user_id required");
+    }
+
+    let jar = Arc::new(Jar::default());
+    let url_deezer = "https://www.deezer.com".parse::<Url>().unwrap();
+    jar.add_cookie_str("comeback=1; Domain=.deezer.com", &url_deezer);
+    jar.add_cookie_str(&format!("arl={arl}; Domain=.deezer.com; Path=/"), &url_deezer);
+
+    let client = reqwest::Client::builder()
+        .cookie_provider(jar.clone())
+        .timeout(std::time::Duration::from_secs(20))
+        .build()
+        .unwrap();
+
+    let ud = match gw_light_call_custom(
+        &client,
+        "deezer.getUserData",
+        "null",
+        None,
+        &json!({}),
+        None,
+        true,
+    )
+    .await
+    {
+        Ok(v) => v,
+        Err(e) => return json_error(StatusCode::UNAUTHORIZED, format!("gw:getUserData:{e}")),
+    };
+
+    let token = req.token.unwrap_or_default().trim().to_string();
+    let api_token = if !token.is_empty() {
+        token
+    } else {
+        ud.get("checkForm")
+            .and_then(|x| x.as_str())
+            .unwrap_or("")
+            .trim()
+            .to_string()
+    };
+    if api_token.is_empty() {
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, "gw:no_checkForm");
+    }
+
+    let mut params = json!({ "user_id": user_id });
+    let config_id = req.config_id.unwrap_or_default().trim().to_string();
+    if !config_id.is_empty() && config_id != "default" {
+        if let Some(obj) = params.as_object_mut() {
+            obj.insert("config_id".to_string(), serde_json::Value::String(config_id));
+        }
+    }
+
+    let results = match gw_light_call_custom(
+        &client,
+        "radio.getUserRadio",
+        &api_token,
+        None,
+        &params,
+        Some(req.user_id.as_str()),
+        false,
+    )
+    .await
+    {
+        Ok(v) => v,
+        Err(e) => return json_error(StatusCode::SERVICE_UNAVAILABLE, format!("gw:radio.getUserRadio:{e}")),
+    };
+
+    (StatusCode::OK, Json(json!({ "results": results }))).into_response()
+}
+
 #[derive(Debug, Deserialize)]
 struct OauthFlowReq {
     access_token: String,
@@ -2023,6 +2324,8 @@ async fn main() {
         .route("/pair/oauth", post(pair_oauth))
         .route("/pair/oauth_cb", get(pair_oauth_cb))
         .route("/pair/complete", post(pair_complete))
+        .route("/gw/page", post(gw_page))
+        .route("/gw/flow", post(gw_flow))
         .route("/oauth/me", post(oauth_me))
         .route("/oauth/playlists", post(oauth_playlists))
         .route("/oauth/playlist_tracks", post(oauth_playlist_tracks))