update

src/client.rs

@@ -3,10 +3,55 @@ use crate::record::{HTTPRecord, InternalRequest, InternalResponse};
 // use crate::redirect::{Action, Attempt, Policy};
 use crate::{ConnectorBuilder, redirect, Result};
 use bytes::Bytes;
-use http::HeaderMap;
+use http::{HeaderMap, HeaderValue};
 use std::io::{BufReader, Write};
 use std::sync::Arc;
 use std::time::Duration;
+use http::header::{ACCEPT, USER_AGENT};
+
+#[derive(Clone)]
+pub struct Client {
+  inner: Arc<ClientRef>,
+}
+
+#[must_use]
+pub struct ClientBuilder {
+  config: Config,
+}
+impl Default for ClientBuilder {
+  fn default() -> Self {
+    Self::new()
+  }
+}
+impl ClientBuilder {
+  pub fn new() -> ClientBuilder {
+    let mut headers: HeaderMap<HeaderValue> = HeaderMap::with_capacity(2);
+    headers.insert(ACCEPT, HeaderValue::from_static("*/*"));
+    ClientBuilder {
+      config: Config {
+        connect_timeout: None,
+        headers,
+        referer: false,
+        max_size: None,
+        proxy: None,
+      },
+    }
+  }
+  pub fn build(self) -> crate::Result<Client> {
+    let config = self.config;
+    let mut connector =ConnectorBuilder::default();
+    Ok(Client {
+      inner: Arc::new(ClientRef {
+        headers: Default::default(),
+        redirect_policy: Default::default(),
+        referer: false,
+        request_timeout: None,
+        read_timeout: None,
+        proxies: Arc::new(vec![]),
+      }),
+    })
+  }
+}
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct Config {
@@ -30,6 +75,7 @@ impl Default for Config {
     }
   }
 }
+
 struct ClientRef {
   // cookie_store: Option<Arc<dyn cookie::CookieStore>>,
   headers: HeaderMap,
@@ -39,10 +85,6 @@ struct ClientRef {
   read_timeout: Option<Duration>,
   proxies: Arc<Vec<Proxy>>,
 }
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct Client {
-  pub config: Config,
-}
 
 // fn same_origin(attempt: Attempt) -> Action {
 //   if let Some(p) = attempt.previous().last() {
@@ -63,18 +105,6 @@ pub struct Client {
 //   }
 // }
 
-impl Client {
-  pub fn new(config: Config) -> Result<Self> {
-    Ok(Self { config })
-  }
-}
-
-impl Client {
-  pub fn request(&self, request: InternalRequest) -> Result<HTTPRecord> {
-    http_request(request)
-  }
-}
-
 pub fn http_request(request: InternalRequest) -> Result<HTTPRecord> {
   let mut record = HTTPRecord::default();
   let mut socket = ConnectorBuilder::default()

src/connector.rs

@@ -16,10 +16,6 @@ pub struct ConnectorBuilder {
   write_timeout: Option<Duration>,
   connect_timeout: Option<Duration>,
   nodelay: bool,
-  addr: Option<SocketAddr>,
-  domain: Option<Domain>,
-  socket_type: Option<Type>,
-  protocol: Option<Protocol>,
   proxy: Option<Proxy>,
 }
 
@@ -49,54 +45,35 @@ impl ConnectorBuilder {
     self.connect_timeout = Some(timeout);
     self
   }
-  pub fn addr(mut self, addr: SocketAddr) -> ConnectorBuilder {
-    self.addr = Some(addr);
-    self
-  }
   pub fn proxy(mut self, addr: Proxy) -> ConnectorBuilder {
     self.proxy = Some(addr);
     self
   }
-  pub fn domain(mut self, addr: Option<Domain>) -> ConnectorBuilder {
-    self.domain = addr;
-    self
-  }
-  pub fn socket_type(mut self, socket_type: Option<Type>) -> ConnectorBuilder {
-    self.socket_type = socket_type;
-    self
-  }
-  pub fn protocol(mut self, protocol: Option<Protocol>) -> ConnectorBuilder {
-    self.protocol = protocol;
-    self
-  }
 }
 
 impl ConnectorBuilder {
-  pub fn connect_with_target(self, target: &http::Uri) -> Result<InternalSocket> {
-    ProxySocket::new(target, &self.proxy).conn_with_connector_builder(self)
-  }
   pub fn build(&self) -> Result<Connector> {
-    let tcp = match self.addr {
-      None => Socket::new(
-        self.domain.unwrap_or(Domain::IPV4),
-        self.socket_type.unwrap_or(Type::STREAM),
-        self.protocol,
-      )?,
-      Some(addr) => Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?,
-    };
+    let (ipv4, ipv6) = (
+      Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP))?,
+      Socket::new(Domain::IPV6, Type::STREAM, Some(Protocol::TCP))?,
+    );
     let tls = TlsConnector::builder()
       .danger_accept_invalid_hostnames(!self.hostname_verification)
       .danger_accept_invalid_certs(!self.certs_verification)
       .build()?;
     if self.nodelay {
-      tcp.set_nodelay(self.nodelay)?;
+      ipv4.set_nodelay(self.nodelay)?;
+      ipv6.set_nodelay(self.nodelay)?;
     }
-    tcp.set_read_timeout(self.read_timeout)?;
-    tcp.set_write_timeout(self.write_timeout)?;
+    ipv4.set_read_timeout(self.read_timeout)?;
+    ipv4.set_write_timeout(self.write_timeout)?;
+    ipv6.set_read_timeout(self.read_timeout)?;
+    ipv6.set_write_timeout(self.write_timeout)?;
     let conn = Connector {
       connect_timeout: self.connect_timeout,
       proxy: self.proxy.clone(),
-      tcp: InternalSocket::TCP(tcp),
+      ipv4: InternalSocket::TCP(ipv4),
+      ipv6: InternalSocket::TCP(ipv6),
       tls,
     };
     Ok(conn)
@@ -107,7 +84,8 @@ impl ConnectorBuilder {
 pub struct Connector {
   connect_timeout: Option<Duration>,
   proxy: Option<Proxy>,
-  tcp: InternalSocket,
+  ipv4: InternalSocket,
+  ipv6: InternalSocket,
   tls: TlsConnector,
 }
 
@@ -119,15 +97,30 @@ impl PartialEq for Connector {
 
 impl Connector {
   pub fn connect_with_addr(&self, addr: SocketAddr) -> Result<InternalSocket> {
-    match self.connect_timeout {
-      None => {
-        self.tcp.connect(&addr.into())?;
+    return match addr {
+      SocketAddr::V4(_) => {
+        match self.connect_timeout {
+          None => {
+            self.ipv4.connect(&addr.into())?;
+          }
+          Some(timeout) => {
+            self.ipv4.connect_timeout(&addr.into(), timeout)?;
+          }
+        }
+        Ok(InternalSocket::TCP(self.ipv4.try_clone().unwrap()))
       }
-      Some(timeout) => {
-        self.tcp.connect_timeout(&addr.into(), timeout)?;
+      SocketAddr::V6(_) => {
+        match self.connect_timeout {
+          None => {
+            self.ipv6.connect(&addr.into())?;
+          }
+          Some(timeout) => {
+            self.ipv6.connect_timeout(&addr.into(), timeout)?;
+          }
+        }
+        Ok(InternalSocket::TCP(self.ipv6.try_clone().unwrap()))
       }
-    }
-    Ok(InternalSocket::TCP(self.tcp.try_clone().unwrap()))
+    };
   }
   pub fn connect_with_uri(&self, target: &http::Uri) -> Result<InternalSocket> {
     ProxySocket::new(target, &self.proxy).conn_with_connector(self)

src/lib.rs

@@ -9,7 +9,7 @@ mod record;
 mod redirect;
 mod socket;
 
-pub use client::{Client, Config};
+pub use client::{Client, Config, http_request};
 pub use connector::{Connector, ConnectorBuilder};
 pub use errors::{EngineError, ReplyError, Result};
 pub use http::{HeaderMap, HeaderName, HeaderValue, Method};

src/proxy.rs

@@ -1,4 +1,4 @@
-use crate::connector::{Connector, ConnectorBuilder};
+use crate::connector::Connector;
 use crate::{EngineError, InternalRequest, InternalResponse, ReplyError, Result};
 use bytes::Bytes;
 use http::HeaderValue;
@@ -247,13 +247,6 @@ impl ProxySocket {
       }
     };
   }
-  pub fn conn_with_connector_builder(
-    self,
-    connector_builder: ConnectorBuilder,
-  ) -> Result<InternalSocket> {
-    let conn = connector_builder.addr(self.get_conn_addr()?).build()?;
-    self.conn_with_connector(&conn)
-  }
 }
 
 fn default_port(uri: &http::Uri) -> Option<u16> {
@@ -582,7 +575,7 @@ impl TargetAddr {
           port,
         ))
       }
-    }
+    };
   }
   pub fn to_be_bytes(&self, cmd: Socks5Command) -> Result<(usize, Vec<u8>)> {
     let mut packet = [0u8; consts::MAX_ADDR_LEN + 3];

tests/tests.rs

@@ -1,7 +1,7 @@
 #[cfg(test)]
 mod tests {
   use http::{HeaderName, HeaderValue};
-  use rawrequest_rs::{Client, Config, InternalRequest};
+  use rawrequest_rs::{Client, Config, http_request, InternalRequest};
   use std::collections::HashMap;
   #[test]
   fn socket() {
@@ -25,8 +25,8 @@ mod tests {
     };
     b = b.uri("https://httpbin.org/ip");
     let r = b.body(None).unwrap();
-    let client = Client::new(Config::default()).unwrap();
-    let recode = client.request(r.into()).expect("err");
+    // let client = Client::new(Config::default()).unwrap();
+    let recode = http_request(r.into()).expect("err");
     println!("{:?}", recode);
   }
 }