[feat] proxy disabled with websocket and http feature

[barbyJam]

Describe the problem

Some system env. be set global proxy, so whatever I set fetch(plugin) or websocket (plugin) 's options, the request still using the system proxy.

Describe the solution you'd like

Providing some options for the proxy. You can set those enum,

1. using IE proxy;
2. using global proxy;
3. not using any proxy(ban to use any proxy, rather than current keep default if value is undefined);

Alternatives considered

No response

Additional context

No response

[FabianLars]

Do you have some references of other projects offerings the settings you desire?

[barbyJam]

Nowadays, I could not give you references of projects directly, however, I may provide you some code sample that can assist to you, such as,

Cargo.toml

[dependencies]
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.11", features = ["blocking"] }
tokio-tungstenite = "0.15"
serde = "1.0"
serde_json = "1.0"
winreg = "0.10"  # For read IE proxy config

proxy.rs

use reqwest::{Client, Proxy};
use tokio_tungstenite::{connect_async, tungstenite::protocol::Message};
use std::error::Error;
use winreg::RegKey;
use winreg::enums::*;
use serde::Deserialize;
use std::env;

#[derive(Debug, Clone, Copy)]
pub enum ProxyOption {
    IEDefault,
    SystemGlobal,
    NoProxy,
}

#[derive(Deserialize, Debug)]
struct ProxySettings {
    pub proxy: Option<String>,
    pub http_proxy: Option<String>,
}

impl ProxyOption {
    pub async fn get_http_proxy(self) -> Option<Proxy> {
        match self {
            ProxyOption::IEDefault => {
                if let Some(proxy_url) = get_ie_proxy().await {
                    Some(Proxy::http(proxy_url).unwrap())
                } else {
                    None
                }
            }
            ProxyOption::SystemGlobal => {
                // If system global proxy is enabled, use the proxy environment variable
                if let Ok(proxy) = env::var("http_proxy") {
                    Some(Proxy::http(proxy).unwrap())
                } else {
                    None
                }
            }
            ProxyOption::NoProxy => None,
        }
    }
}

async fn get_ie_proxy() -> Option<String> {
    // Get the proxy settings from the Windows IE registry
    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
    let proxy_key = hkcu.open_subkey(r"Software\Microsoft\Windows\CurrentVersion\Internet Settings").ok()?;

    match proxy_key.get_str("ProxyServer") {
        Ok(proxy_url) => Some(proxy_url.to_string()),
        Err(_) => None,
    }
}

async fn make_http_request(proxy_option: ProxyOption) -> Result<String, Box<dyn Error>> {
    // Create an HTTP client with the selected proxy settings
    let client = Client::builder()
        .proxy(proxy_option.get_http_proxy().await)
        .build()?;

    // Make a request to an HTTP endpoint (httpbin.org in this case)
    let response = client.get("http://httpbin.org/ip")
        .send()
        .await?
        .text()
        .await?;

    Ok(response)
}

async fn make_websocket_request(proxy_option: ProxyOption) -> Result<(), Box<dyn Error>> {
    // Based on the selected proxy option, determine the proxy settings
    let proxy = match proxy_option {
        ProxyOption::IEDefault => get_ie_proxy().await,
        ProxyOption::SystemGlobal => env::var("http_proxy").ok(),
        ProxyOption::NoProxy => None,
    };

    let ws_url = "ws://example.com/socket";
    
    // Connect to the WebSocket, applying the proxy if available
    let (ws_stream, _) = if let Some(proxy_url) = proxy {
        connect_async(format!("ws://{}{}", proxy_url, ws_url)).await?
    } else {
        connect_async(ws_url).await?
    };

    // Send a message over the WebSocket
    ws_stream.send(Message::Text("Hello WebSocket".into())).await?;
    Ok(())
}

#[tokio::main]
async fn main() {
    // Example: Set the proxy to use the IE default proxy settings
    let proxy_option = ProxyOption::IEDefault;

    // HTTP request example
    match make_http_request(proxy_option).await {
        Ok(response) => println!("HTTP Response: {}", response),
        Err(e) => eprintln!("HTTP Request Error: {}", e),
    }

    // WebSocket request example
    if let Err(e) = make_websocket_request(proxy_option).await {
        eprintln!("WebSocket Error: {}", e);
    }
}