禁用本地网络代理

Author: chen-zeong

src-tauri/src/platforms/common/http_client.rs

@@ -6,12 +6,13 @@ use std::time::Duration;
 pub const DEFAULT_USER_AGENT: &str = "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";
 const DEFAULT_TIMEOUT_SECONDS: u64 = 20;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct HttpClient {
     pub inner: Client,
     headers: ReqwestHeaderMap,
 }
 
+#[allow(dead_code)]
 impl HttpClient {
     pub fn new() -> Result<Self, String> {
         let mut default_headers = ReqwestHeaderMap::new();
@@ -37,6 +38,33 @@ impl HttpClient {
         })
     }
 
+    /// 创建一个绕过所有代理的直连HTTP客户端
+    /// 这个客户端将忽略系统代理设置，直接连接到目标服务器
+    pub fn new_direct_connection() -> Result<Self, String> {
+        let mut default_headers = ReqwestHeaderMap::new();
+        default_headers.insert(
+            USER_AGENT,
+            HeaderValue::from_str(DEFAULT_USER_AGENT)
+                .map_err(|e| format!("Invalid default user agent: {}", e))?,
+        );
+
+        let cookie_jar = Arc::new(Jar::default());
+
+        let client_builder = Client::builder()
+            .timeout(Duration::from_secs(DEFAULT_TIMEOUT_SECONDS))
+            .cookie_provider(cookie_jar)
+            .no_proxy(); // 关键：禁用所有代理设置
+
+        let inner_client = client_builder
+            .build()
+            .map_err(|e| format!("Failed to build direct connection reqwest client: {}", e))?;
+
+        Ok(HttpClient {
+            inner: inner_client,
+            headers: default_headers,
+        })
+    }
+
     // Method to add or update a header for subsequent requests made with this client instance
     pub fn insert_header(&mut self, name: HeaderName, value: &str) -> Result<(), String> {
         let header_value = HeaderValue::from_str(value)
@@ -97,5 +125,90 @@ impl HttpClient {
         Ok(json_response)
     }
 
-    // Add post, post_json etc. from the demo if needed in the future
+    pub async fn post_form(&self, url: &str, form_data: &str) -> Result<Response, String> {
+        let response = self.send_request(
+            self.inner
+                .post(url)
+                .header("Content-Type", "application/x-www-form-urlencoded")
+                .body(form_data.to_string())
+        ).await?;
+        Ok(response)
+    }
+
+    pub async fn post_form_json<T: serde::de::DeserializeOwned>(&self, url: &str, form_data: &str) -> Result<T, String> {
+        let response = self.post_form(url, form_data).await?;
+        let status = response.status();
+        if !status.is_success() {
+            let err_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Failed to read error body".to_string());
+            return Err(format!(
+                "POST FORM {} failed with status {}: {}",
+                url, status, err_text
+            ));
+        }
+        let json_response = response
+            .json::<T>()
+            .await
+            .map_err(|e| format!("Failed to parse JSON response from {}: {}", url, e))?;
+        Ok(json_response)
+    }
+
+    pub async fn get_json_with_headers<T: serde::de::DeserializeOwned>(&self, url: &str, headers: Option<ReqwestHeaderMap>) -> Result<T, String> {
+        let mut request_builder = self.inner.get(url);
+        
+        if let Some(additional_headers) = headers {
+            request_builder = request_builder.headers(additional_headers);
+        }
+        
+        let response = self.send_request(request_builder).await?;
+        let status = response.status();
+        if !status.is_success() {
+            let err_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Failed to read error body".to_string());
+            return Err(format!(
+                "GET JSON {} failed with status {}: {}",
+                url, status, err_text
+            ));
+        }
+        let json_response = response
+            .json::<T>()
+            .await
+            .map_err(|e| format!("Failed to parse JSON response from {}: {}", url, e))?;
+        Ok(json_response)
+    }
+
+    pub async fn get_with_cookies(&self, url: &str) -> Result<Response, String> {
+        let request_builder = self.inner.get(url).headers(self.headers.clone());
+        self.send_request(request_builder).await
+    }
+
+    pub async fn get_text_with_headers(&self, url: &str, headers: Option<ReqwestHeaderMap>) -> Result<String, String> {
+        let mut request_builder = self.inner.get(url).headers(self.headers.clone());
+        
+        if let Some(additional_headers) = headers {
+            request_builder = request_builder.headers(additional_headers);
+        }
+        
+        let response = self.send_request(request_builder).await?;
+        let status = response.status();
+        if !status.is_success() {
+            let err_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Failed to read error body".to_string());
+            return Err(format!(
+                "GET {} failed with status {}: {}",
+                url, status, err_text
+            ));
+        }
+        let text_response = response
+            .text()
+            .await
+            .map_err(|e| format!("Failed to read text response from {}: {}", url, e))?;
+        Ok(text_response)
+    }
 }

src-tauri/src/platforms/douyin/danmu/web_fetcher.rs

@@ -1,6 +1,5 @@
+use crate::platforms::common::http_client::HttpClient;
 use regex::Regex;
-use reqwest::cookie::Jar;
-use reqwest::Client;
 use serde::{Deserialize, Serialize};
 use serde_json;
 use std::sync::Arc;
@@ -25,17 +24,15 @@ pub struct DouyinLiveWebFetcher {
     pub ttwid: Option<String>,
     pub room_id: Option<String>,
     pub user_agent: String,
-    pub http_client: Client,
+    pub http_client: HttpClient,
     pub(crate) _ws_stream: Option<Arc<Mutex<WebSocketStream<MaybeTlsStream<TcpStream>>>>>,
 }
 
 impl DouyinLiveWebFetcher {
     pub fn new(live_id: &str) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
-        let cookie_jar = Arc::new(Jar::default());
-        let http_client = Client::builder()
-            .cookie_provider(cookie_jar)
-            .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
-            .build()?;
+        // 使用直连HTTP客户端，绕过所有代理设置
+        let http_client = HttpClient::new_direct_connection()
+            .map_err(|e| format!("Failed to create direct connection HttpClient: {}", e))?;
 
         Ok(DouyinLiveWebFetcher {
             live_id: live_id.to_string(),
@@ -53,7 +50,8 @@ impl DouyinLiveWebFetcher {
         }
 
         let live_url = "https://live.douyin.com/";
-        let response = self.http_client.get(live_url).send().await?;
+        let response = self.http_client.get_with_cookies(live_url).await
+            .map_err(|e| format!("Failed to get response from {}: {}", live_url, e))?;
 
         let ttwid_val = response
             .cookies()
@@ -85,14 +83,16 @@ impl DouyinLiveWebFetcher {
         );
 
         let url = format!("https://live.douyin.com/{}", self.live_id);
-        let response = self
-            .http_client
-            .get(&url)
-            .header("Cookie", cookie_header)
-            .send()
-            .await?;
-
-        let text = response.text().await?;
+        
+        let mut headers = reqwest::header::HeaderMap::new();
+        headers.insert(
+            reqwest::header::COOKIE,
+            reqwest::header::HeaderValue::from_str(&cookie_header)
+                .map_err(|e| format!("Failed to create cookie header: {}", e))?
+        );
+        
+        let text = self.http_client.get_text_with_headers(&url, Some(headers)).await
+            .map_err(|e| format!("Failed to get room page: {}", e))?;
         println!(
             "HTML Response (first 500 chars): {}",
             &text[..std::cmp::min(500, text.len())]
@@ -123,15 +123,20 @@ impl DouyinLiveWebFetcher {
             room_id_val // room_id_str is the actual numerical room ID
         );
 
-        let response = self
-            .http_client
-            .get(&url)
-            .header("User-Agent", &self.user_agent)
-            .header("Cookie", format!("ttwid={};", ttwid_val))
-            .send()
-            .await?;
-
-        let data: serde_json::Value = response.json().await?;
+        let mut headers = reqwest::header::HeaderMap::new();
+        headers.insert(
+            reqwest::header::USER_AGENT,
+            reqwest::header::HeaderValue::from_str(&self.user_agent)
+                .map_err(|e| format!("Failed to create user-agent header: {}", e))?
+        );
+        headers.insert(
+            reqwest::header::COOKIE,
+            reqwest::header::HeaderValue::from_str(&format!("ttwid={};", ttwid_val))
+                .map_err(|e| format!("Failed to create cookie header: {}", e))?
+        );
+        
+        let data: serde_json::Value = self.http_client.get_json_with_headers(&url, Some(headers)).await
+            .map_err(|e| format!("Failed to get room status: {}", e))?;
 
         // This part is mostly for printing/debugging in the original code
         if let Some(room_data_top) = data.get("data") {
@@ -209,26 +214,20 @@ pub async fn fetch_douyin_room_info(live_id: String) -> Result<DouyinFollowListR
         room_id_str // room_id_str (the numerical one we fetched)
     );
 
-    let response = fetcher
-        .http_client
-        .get(&url)
-        .header("User-Agent", &fetcher.user_agent)
-        .header("Cookie", format!("ttwid={};", ttwid))
-        .send()
-        .await
-        .map_err(|e| format!("Failed to send request to web/enter: {}", e))?;
-
-    let response_text = response
-        .text()
-        .await
-        .map_err(|e| format!("Failed to get response text: {}", e))?;
-    // println!("[fetch_douyin_room_info] Response text: {}", response_text);
-    let data: serde_json::Value = serde_json::from_str(&response_text).map_err(|e| {
-        format!(
-            "Failed to parse JSON from web/enter: {}. Response text: {}",
-            e, response_text
-        )
-    })?;
+    let mut headers = reqwest::header::HeaderMap::new();
+    headers.insert(
+        reqwest::header::USER_AGENT,
+        reqwest::header::HeaderValue::from_str(&fetcher.user_agent)
+            .map_err(|e| format!("Failed to create user-agent header: {}", e))?
+    );
+    headers.insert(
+        reqwest::header::COOKIE,
+        reqwest::header::HeaderValue::from_str(&format!("ttwid={};", ttwid))
+            .map_err(|e| format!("Failed to create cookie header: {}", e))?
+    );
+    
+    let data: serde_json::Value = fetcher.http_client.get_json_with_headers(&url, Some(headers)).await
+        .map_err(|e| format!("Failed to get room info from web/enter: {}", e))?;
 
     // Parse data based on typical Douyin API structure
     let room_data_top = data

src-tauri/src/platforms/douyin/douyin_streamer_detail.rs

@@ -45,8 +45,9 @@ pub async fn get_douyin_live_stream_url_with_quality(
         });
     }
 
+    // 使用直连HTTP客户端，绕过所有代理设置
     let mut http_client =
-        HttpClient::new().map_err(|e| format!("Failed to create HttpClient: {}", e))?;
+        HttpClient::new_direct_connection().map_err(|e| format!("Failed to create direct connection HttpClient: {}", e))?;
 
     if let Err(e) = setup_douyin_cookies(&mut http_client, &room_id_str).await {
         return Ok(crate::platforms::common::LiveStreamInfo {

src-tauri/src/platforms/douyin/douyin_streamer_info.rs

@@ -24,8 +24,9 @@ pub async fn fetch_douyin_streamer_info(
         });
     }
 
+    // 使用直连HTTP客户端，绕过所有代理设置
     let mut http_client =
-        HttpClient::new().map_err(|e| format!("Failed to create HttpClient: {}", e))?;
+        HttpClient::new_direct_connection().map_err(|e| format!("Failed to create direct connection HttpClient: {}", e))?;
 
     if let Err(e) = setup_douyin_cookies(&mut http_client, &room_id_str).await {
         return Ok(crate::platforms::common::LiveStreamInfo {

src-tauri/src/platforms/douyin/douyin_streamer_list.rs

@@ -1,3 +1,4 @@
+use crate::platforms::common::http_client::HttpClient;
 use reqwest::header::{HeaderMap, HeaderValue, COOKIE};
 use serde::{Deserialize, Serialize};
 use tauri::State; // Removed SET_COOKIE
@@ -83,10 +84,9 @@ pub async fn fetch_douyin_partition_rooms(
 ) -> Result<DouyinLiveListResponse, String> {
     let count: i32 = 15; // Number of items requested per page, explicitly typed as i32
 
-    // For this test, create a new client, similar to the user's test snippet
-    let local_client = reqwest::Client::builder()
-        .build()
-        .map_err(|e| format!("Failed to build local reqwest client: {}", e))?;
+    // 使用直连HTTP客户端，绕过所有代理设置
+    let local_client = HttpClient::new_direct_connection()
+        .map_err(|e| format!("Failed to create direct connection HttpClient: {}", e))?;
 
     // Use hardcoded ttwid and odin_tt from the user's working test for now
     let hardcoded_odin_tt = "54c68ba8fa8ce792ad017c55272d171c283baedc87b2f6282ca8706df295cbd89c5d55449b587b7ebe0a2e352e394a86975955c9ed7f98f209996bdca2749479619aceecc7b75c2374e146b5a722b2e1";
@@ -106,21 +106,9 @@ pub async fn fetch_douyin_partition_rooms(
         count, offset, partition, partition_type, ms_token
     );
 
-    let request_builder = local_client
-        .request(reqwest::Method::GET, &url)
-        .headers(headers);
-
-    match request_builder.send().await {
-        Ok(response) => {
-            let initial_status = response.status();
-            if initial_status.is_success() {
-                let response_text = response
-                    .text()
-                    .await
-                    .map_err(|e| format!("Failed to read response text: {}", e))?;
-                return match serde_json::from_str::<DouyinPartitionApiResponse>(&response_text) {
-                    Ok(api_response) => {
-                        if api_response.status_code == 0 {
+    match local_client.get_json_with_headers::<DouyinPartitionApiResponse>(&url, Some(headers)).await {
+        Ok(api_response) => {
+            if api_response.status_code == 0 {
                             let mut frontend_rooms = Vec::new();
                             let received_rooms_count = api_response.data.data.len(); // Number of rooms actually received from this API call
 
@@ -168,26 +156,10 @@ pub async fn fetch_douyin_partition_rooms(
                             })
                         } else {
                             Err(format!(
-                                "Douyin API returned non-zero status code: {}. Response: {}",
-                                api_response.status_code, response_text
+                                "Douyin API returned non-zero status code: {}",
+                                api_response.status_code
                             ))
                         }
-                    }
-                    Err(e) => Err(format!(
-                        "Failed to parse Douyin room list JSON: {}. Response: {}",
-                        e, response_text
-                    )),
-                };
-            } else {
-                let error_body = response
-                    .text()
-                    .await
-                    .unwrap_or_else(|_| "Failed to read error body".to_string());
-                Err(format!(
-                    "Failed to fetch Douyin room list: HTTP Status {}. Body: {}",
-                    initial_status, error_body
-                ))
-            }
         }
         Err(e) => Err(format!("Network error fetching Douyin room list: {}", e)),
     }