Merge pull request #283 from alley-rs/dev

Author: github-actions[bot]

src-tauri/src/error.rs

@@ -2,9 +2,8 @@ use std::fmt;
 
 use serde::{Serialize, Serializer};
 
-use crate::eval::EvalError;
-
-pub(super) type LsarResult<T> = std::result::Result<T, LsarError>;
+pub(super) type Result<T> = std::result::Result<T, LsarError>;
+pub(super) type LsarResult<T> = Result<T>;
 
 #[derive(Debug, thiserror::Error)]
 pub(super) enum LsarError {
@@ -40,8 +39,6 @@ pub(super) enum LsarError {
     #[error(transparent)]
     UrlParse(#[from] url::ParseError),
     #[error(transparent)]
-    Eval(#[from] EvalError),
-    #[error(transparent)]
     SerdeJSON(#[from] serde_json::Error),
     #[error(transparent)]
     VarError(#[from] std::env::VarError),
@@ -138,10 +135,6 @@ pub(super) enum MissKeyFieldError {
     /// 不是所有平台都支持分类，此成员仅用于部分平台
     #[error("解析分类失败")]
     Category,
-    #[error("解析签名函数失败")]
-    SignatureFunction,
-    #[error("解析随机数失败")]
-    RandomNumber,
     #[error("解析房间号失败，请检查房间号是否正确")]
     RoomId,
 }

src-tauri/src/eval.rs

@@ -4,7 +4,6 @@
 mod config;
 mod data;
 mod error;
-mod eval;
 mod global;
 mod http;
 mod log;
@@ -30,7 +29,6 @@ use tauri::{AppHandle, Manager};
 use crate::config::{read_config_file, write_config_file};
 use crate::data::db::{delete_a_history_by_id, get_all_history, insert_a_history};
 use crate::error::LsarResult;
-use crate::eval::eval_result;
 use crate::http::{get, post};
 use crate::log::{debug, error, info, trace, warn};
 use crate::parsers::{parse_bigo, parse_bilibili, parse_douyin, parse_douyu, parse_huya, parse_yy};
@@ -113,7 +111,6 @@ fn main() {
             open,
             read_config_file,
             write_config_file,
-            eval_result,
             parse_bigo,
             parse_douyu,
             parse_huya,

src-tauri/src/main.rs

@@ -1,30 +1,29 @@
 use std::error::Error;
 
 use bytes::Bytes;
-use reqwest::{header::CONTENT_TYPE, Body, Client as InnerClient, Response};
+use reqwest::{
+    header::{HeaderMap, CONTENT_TYPE},
+    Client as InnerClient, Response,
+};
 use serde::{de::DeserializeOwned, Serialize};
-use tauri::http::HeaderMap;
 
 use crate::error::{LsarError, LsarResult};
 
 #[derive(Clone)]
 pub struct Client {
     pub inner: InnerClient,
-    headers: HeaderMap,
 }
 
 impl Client {
     pub fn new() -> Self {
         trace!("Creating new HttpClient instance");
 
-        let headers = HeaderMap::default();
-
         let inner = InnerClient::builder()
             .user_agent("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36")
             .build()
             .unwrap();
 
-        let client = Client { inner, headers };
+        let client = Client { inner };
         debug!("HttpClient instance created with default headers");
         client
     }
@@ -43,9 +42,10 @@ impl Client {
     pub async fn send_request(
         &self,
         request: reqwest::RequestBuilder,
+        headers: Option<HeaderMap>,
     ) -> LsarResult<reqwest::Response> {
         request
-            .headers(self.headers.clone())
+            .headers(headers.unwrap_or_default())
             .send()
             .await
             .map_err(|e| {
@@ -56,7 +56,7 @@ impl Client {
 
     pub async fn get(&self, url: &str) -> LsarResult<Response> {
         info!("Sending GET request to: {}", url);
-        let response = self.send_request(self.inner.get(url)).await?;
+        let response = self.send_request(self.inner.get(url), None).await?;
 
         debug!("GET request successful, status: {}", response.status());
 
@@ -91,9 +91,15 @@ impl Client {
         Ok(bytes)
     }
 
-    pub async fn get_json<T: DeserializeOwned>(&self, url: &str) -> LsarResult<T> {
+    pub async fn get_json<T: DeserializeOwned, H: Into<Option<HeaderMap>>>(
+        &self,
+        url: &str,
+        headers: H,
+    ) -> LsarResult<T> {
         info!("Sending GET request for JSON to: {}", url);
-        let response = self.send_request(self.inner.get(url)).await?;
+        let response = self
+            .send_request(self.inner.get(url), headers.into())
+            .await?;
 
         debug!("GET request successful, headers: {:?}", response.headers());
 
@@ -120,41 +126,21 @@ impl Client {
         Ok(json)
     }
 
-    pub async fn post<D: DeserializeOwned, T: Into<Body>>(
-        &self,
-        url: &str,
-        body: T,
-    ) -> LsarResult<D> {
-        info!("Sending POST request with body to: {}", url);
-
-        let request = self
-            .inner
-            .post(url)
-            .body(body)
-            .header(CONTENT_TYPE, "application/x-www-form-urlencoded");
-
-        let response = self.send_request(request).await?;
-
-        debug!("POST request successful, status: {}", response.status());
-        let json = response.json().await.map_err(|e| {
-            error!("Failed to parse JSON response from POST request: {}", e);
-            LsarError::Http(e.into())
-        })?;
-
-        trace!("JSON response from POST request parsed successfully");
-        Ok(json)
-    }
-
-    pub async fn post_form<D: DeserializeOwned, T: Serialize + ?Sized>(
+    pub async fn post_form<
+        D: DeserializeOwned,
+        T: Serialize + ?Sized,
+        H: Into<Option<HeaderMap>>,
+    >(
         &self,
         url: &str,
         form: &T,
+        headers: H,
     ) -> LsarResult<D> {
         info!("Sending POST request with body to: {}", url);
 
         let request = self.inner.post(url).form(form);
 
-        let response = self.send_request(request).await?;
+        let response = self.send_request(request, headers.into()).await?;
 
         debug!("POST request successful, status: {}", response.status());
         let json = response.json().await.map_err(|e| {
@@ -175,7 +161,7 @@ impl Client {
             .body(body.to_owned())
             .header(CONTENT_TYPE, "text/plain;charset=UTF-8");
 
-        let response = self.send_request(request).await?;
+        let response = self.send_request(request, None).await?;
 
         debug!("POST request successful, status: {}", response.status());
         let json = response.json().await.map_err(|e| {
@@ -193,7 +179,9 @@ impl Client {
         body: &S,
     ) -> LsarResult<T> {
         info!("Sending POST request with JSON body to: {}", url);
-        let response = self.send_request(self.inner.post(url).json(body)).await?;
+        let response = self
+            .send_request(self.inner.post(url).json(body), None)
+            .await?;
 
         debug!("POST request successful, status: {}", response.status());
         let json = response.json().await.map_err(|e| {

src-tauri/src/network/http.rs

@@ -41,7 +41,7 @@ impl BigoParser {
     async fn get_real_url(&self) -> LsarResult<RoomInfo> {
         const URL: &str = "https://ta.bigo.tv/official_website/studio/getInternalStudioInfo";
         let body = [("siteId", self.room_id)];
-        let resp: Response = self.http_client.post_form(URL, &body).await?;
+        let resp: Response = self.http_client.post_form(URL, &body, None).await?;
 
         Ok(resp.data)
     }

src-tauri/src/parsers/bigo/mod.rs

@@ -1,3 +1,3 @@
-pub const DEVICE_ID: &str = "10000000000000000000000000001501";
+pub const DEVICE_ID: &str = "10000000000000000000000000003306";
 pub const ROOM_OFFLINE_STATE: &str = "房间未开播";
 pub const INVALID_REQUEST: &str = "非法请求";

src-tauri/src/parsers/douyu/constants.rs

@@ -0,0 +1,77 @@
+use reqwest::header::{HeaderMap, HeaderValue, REFERER};
+use serde::Deserialize;
+
+use crate::error::{LsarError, Result};
+use crate::network::http::Client;
+use crate::parsers::douyu::constants::DEVICE_ID;
+use crate::utils::{md5, now};
+
+#[derive(Debug, Deserialize)]
+struct EncryptionData {
+    rand_str: String,
+    key: String,
+    enc_time: u8,
+    is_special: u8,
+    enc_data: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct EncryptionResponse {
+    error: i8,
+    msg: String,
+    data: EncryptionData,
+}
+
+#[derive(Debug)]
+pub struct Encryption {
+    pub enc_data: String,
+    pub ts: u64,
+    pub auth: String,
+}
+
+pub struct EncryptionFetcher {
+    client: Client,
+}
+
+impl EncryptionFetcher {
+    pub fn new(client: Client) -> Self {
+        Self { client }
+    }
+
+    pub async fn fetch_encryption(&self, room_id: u64) -> Result<Encryption> {
+        let url = format!(
+            "https://www.douyu.com/wgapi/livenc/liveweb/websec/getEncryption?did={}",
+            DEVICE_ID
+        );
+        let headers = HeaderMap::from_iter([(
+            REFERER,
+            HeaderValue::from_str(&format!("https://www.douyu.com/{}", room_id)).unwrap(),
+        )]);
+        let data: EncryptionResponse = self.client.get_json(&url, headers).await?;
+        if data.error != 0 {
+            return Err(LsarError::Other(format!(
+                "Douyu encryption fetch failed: {}",
+                data.msg
+            )));
+        }
+
+        let ts = now()?.as_secs();
+        let sign_str = if data.data.is_special == 1 {
+            "".to_string()
+        } else {
+            format!("{}{}", room_id, ts)
+        };
+
+        let mut auth = data.data.rand_str;
+        for _ in 0..data.data.enc_time {
+            auth = md5(format!("{}{}", auth, data.data.key));
+        }
+        auth = md5(format!("{}{}{}", auth, data.data.key, sign_str));
+
+        Ok(Encryption {
+            enc_data: data.data.enc_data,
+            ts,
+            auth,
+        })
+    }
+}