update repo to fit the current status of rust development (#11)

* update repo to fit the current status of rust development

1, use url crate as a replacement of former one
2, upgrade version of rustls_pemfile to make test run
3, upgrade version of webpki-roots to make test run
4, add no_std build test of no_std target in prepush script

* PR fix:

1) add HttpUrl struct to avoid using unwrap and to make things simpler
2) in the examples, use old url with url.set_path instead of use format
   macro
3) remove extra lines and add comment for the #[allow(dead_code)]

* PR fix:
1) use != instead of ne
2) use certain result of host and port as we know the scheme must be http or https
3) add some tests

* add ci file

* PR fix: fix comments

Author: ivila

.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI
+
+on: [push, pull_request]
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  prepush:
+    runs-on: ubuntu-latest
+    container: rust:latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+      - name: Install target
+        run: rustup target add thumbv7m-none-eabi
+      - name: Run
+        run: ./prepush

Cargo.toml

@@ -26,9 +26,10 @@ ssl = []
 hashbrown = "*"
 openssl = { version = "*", optional = true }
 rustls = { version = "^0.20.8", optional = true }
-webpki-roots = { version = "*", optional = true }
-rustls-pemfile = { version = "*", optional = true }
+webpki-roots = { version = "^0.26.0", optional = true }
+rustls-pemfile = { version = "^2.0.0", optional = true }
 native-tls = { version = "*", optional = true }
+url = { version = "2.5.3", default-features = false }
 
 [dev-dependencies]
 clap = { version = "*", features = ["derive"] }

examples/advance_client.rs

@@ -3,17 +3,17 @@ use std::net;
 
 use http_io::client::HttpRequestBuilder;
 use http_io::error::Result;
-use http_io::url::Url;
+use http_io::url::HttpUrl;
 
 fn main() -> Result<()> {
     let args = std::env::args();
-    let url: Url = args
+    let url: HttpUrl = args
         .skip(1)
         .next()
         .unwrap_or("http://www.google.com".into())
         .parse()?;
 
-    let s = net::TcpStream::connect((url.authority.as_ref(), url.port()?))?;
+    let s = net::TcpStream::connect((url.host(), url.port()))?;
     let mut response = HttpRequestBuilder::get(url)?.send(s)?.finish()?;
 
     println!("{:#?}", response.headers);

examples/connection_reuse.rs

@@ -5,16 +5,16 @@ use std::io;
 
 fn main() -> Result<()> {
     let args = std::env::args();
-    let url: Url = args
+    let host = args
         .skip(1)
         .next()
-        .unwrap_or("http://www.google.com".into())
-        .parse()?;
+        .unwrap_or("http://www.google.com".into());
+    let url = Url::parse(&host)?;
 
     let mut client = HttpClient::<std::net::TcpStream>::new();
     for path in &["/", "/favicon.ico", "/robots.txt"] {
         let mut url = url.clone();
-        url.path = path.parse()?;
+        url.set_path(&path);
         io::copy(&mut client.get(url)?.finish()?.body, &mut io::stdout())?;
     }
 

examples/no_std.rs

@@ -23,7 +23,7 @@ mod no_std {
     use http_io::error::{Error, Result};
     use http_io::io;
     use http_io::protocol::HttpMethod;
-    use http_io::url::Url;
+    use http_io::url::HttpUrl;
 
     #[derive(Parser)]
     struct Options {
@@ -106,9 +106,9 @@ mod no_std {
 
         // The clap parsing stuff relies on std::error::Error
         let method: HttpMethod = opts.method.parse()?;
-        let url: Url = opts.url.parse()?;
+        let url: HttpUrl = opts.url.parse()?;
 
-        let s = MyFakeTcpStream::connect(url.authority.as_ref(), url.port()?)?;
+        let s = MyFakeTcpStream::connect(url.host(), url.port())?;
 
         let mut body = match method {
             HttpMethod::Get => HttpRequestBuilder::get(url)?.send(s)?.finish()?.body,

prepush

@@ -15,5 +15,6 @@ cargo test --no-default-features --features std,ssl-rustls
 cargo run --example readme
 cargo run --example connection_reuse
 cargo run --example no_std --no-default-features -- http://fake.com
+cargo build --target thumbv7m-none-eabi --no-default-features
 
 echo "All tests passed"

src/client.rs

@@ -20,14 +20,14 @@
 //! ```rust
 //! use http_io::client::HttpRequestBuilder;
 //! use http_io::error::Result;
-//! use http_io::url::Url;
+//! use http_io::url::HttpUrl;
 //! use std::io;
 //! use std::net::TcpStream;
 //!
 //! fn main() -> Result<()> {
-//!     let url: Url = "http://www.google.com".parse()?;
-//!     let s = TcpStream::connect((url.authority.as_ref(), url.port()?))?;
-//!     let mut response = HttpRequestBuilder::get(url)?.send(s)?.finish()?;
+//!     let http_url: HttpUrl = "http://www.google.com".parse()?;
+//!     let s = TcpStream::connect((http_url.host(), http_url.port()))?;
+//!     let mut response = HttpRequestBuilder::get(http_url)?.send(s)?.finish()?;
 //!     println!("{:#?}", response.headers);
 //!     io::copy(&mut response.body, &mut io::stdout())?;
 //!     Ok(())
@@ -41,11 +41,11 @@
 //! use std::io;
 //!
 //! fn main() -> Result<()> {
-//!     let url: Url = "http://www.google.com".parse()?;
+//!     let url = Url::parse("http://www.google.com")?;
 //!     let mut client = HttpClient::<std::net::TcpStream>::new();
 //!     for path in &["/", "/favicon.ico", "/robots.txt"] {
 //!         let mut url = url.clone();
-//!         url.path = path.parse()?;
+//!         url.set_path(&path);
 //!         io::copy(&mut client.get(url)?.finish()?.body, &mut io::stdout())?;
 //!     }
 //!     Ok(())
@@ -59,7 +59,7 @@ use crate::protocol::{HttpBody, HttpStatus};
 use crate::protocol::{HttpMethod, HttpRequest, OutgoingRequest};
 #[cfg(feature = "std")]
 use crate::url::Scheme;
-use crate::url::Url;
+use crate::url::{HttpUrl, Url};
 #[cfg(not(feature = "std"))]
 use alloc::string::{String, ToString as _};
 use core::convert::TryInto;
@@ -74,63 +74,63 @@ pub struct HttpRequestBuilder {
 
 impl HttpRequestBuilder {
     /// Create a `HttpRequestBuilder` to build a DELETE request
-    pub fn delete<U: TryInto<Url>>(url: U) -> Result<Self>
+    pub fn delete<U: TryInto<HttpUrl>>(url: U) -> Result<Self>
     where
-        <U as TryInto<Url>>::Error: Display,
+        <U as TryInto<HttpUrl>>::Error: Display,
     {
         HttpRequestBuilder::new(url, HttpMethod::Delete)
     }
 
     /// Create a `HttpRequestBuilder` to build a GET request
-    pub fn get<U: TryInto<Url>>(url: U) -> Result<Self>
+    pub fn get<U: TryInto<HttpUrl>>(url: U) -> Result<Self>
     where
-        <U as TryInto<Url>>::Error: Display,
+        <U as TryInto<HttpUrl>>::Error: Display,
     {
         HttpRequestBuilder::new(url, HttpMethod::Get)
     }
 
     /// Create a `HttpRequestBuilder` to build a HEAD request
-    pub fn head<U: TryInto<Url>>(url: U) -> Result<Self>
+    pub fn head<U: TryInto<HttpUrl>>(url: U) -> Result<Self>
     where
-        <U as TryInto<Url>>::Error: Display,
+        <U as TryInto<HttpUrl>>::Error: Display,
     {
         HttpRequestBuilder::new(url, HttpMethod::Head)
     }
 
     /// Create a `HttpRequestBuilder` to build an OPTIONS request
-    pub fn options<U: TryInto<Url>>(url: U) -> Result<Self>
+    pub fn options<U: TryInto<HttpUrl>>(url: U) -> Result<Self>
     where
-        <U as TryInto<Url>>::Error: Display,
+        <U as TryInto<HttpUrl>>::Error: Display,
     {
         HttpRequestBuilder::new(url, HttpMethod::Options)
     }
 
     /// Create a `HttpRequestBuilder` to build a POST request
-    pub fn post<U: TryInto<Url>>(url: U) -> Result<Self>
+    pub fn post<U: TryInto<HttpUrl>>(url: U) -> Result<Self>
     where
-        <U as TryInto<Url>>::Error: Display,
+        <U as TryInto<HttpUrl>>::Error: Display,
     {
         HttpRequestBuilder::new(url, HttpMethod::Post)
     }
 
     /// Create a `HttpRequestBuilder` to build a PUT request
-    pub fn put<U: TryInto<Url>>(url: U) -> Result<Self>
+    pub fn put<U: TryInto<HttpUrl>>(url: U) -> Result<Self>
     where
-        <U as TryInto<Url>>::Error: Display,
+        <U as TryInto<HttpUrl>>::Error: Display,
     {
         HttpRequestBuilder::new(url, HttpMethod::Put)
     }
 
     /// Create a `HttpRequestBuilder`. May fail if the given url does not parse.
-    pub fn new<U: TryInto<Url>>(url: U, method: HttpMethod) -> Result<Self>
+    pub fn new<U: TryInto<HttpUrl>>(url: U, method: HttpMethod) -> Result<Self>
     where
-        <U as TryInto<Url>>::Error: Display,
+        <U as TryInto<HttpUrl>>::Error: Display,
     {
-        let url = url
+        let url: HttpUrl = url
             .try_into()
             .map_err(|e| Error::ParseError(e.to_string()))?;
-        let mut request = HttpRequest::new(method, url.path());
-        request.add_header("Host", url.authority.clone());
+        let mut request = HttpRequest::new(method, url.url().path());
+        request.add_header("Host", url.host().to_string());
         request.add_header("User-Agent", "http_io");
         request.add_header("Accept", "*/*");
         if method.has_body() {
@@ -226,19 +226,23 @@ impl StreamConnector for std::net::TcpStream {
     }
 
     fn to_stream_addr(url: Url) -> Result<Self::StreamAddr> {
+        use core::convert::TryFrom;
+
+        let http_url = HttpUrl::try_from(url)?;
         let err = || {
             std::io::Error::new(
                 std::io::ErrorKind::AddrNotAvailable,
-                format!("Failed to lookup {}", &url.authority),
+                format!("Failed to lookup {}", http_url.host()),
             )
         };
+
         Ok(StreamId {
-            addr: std::net::ToSocketAddrs::to_socket_addrs(&(url.authority.as_ref(), url.port()?))
+            addr: std::net::ToSocketAddrs::to_socket_addrs(&(http_url.host(), http_url.port()))
                 .map_err(|_| err())?
                 .next()
                 .ok_or_else(err)?,
-            host: url.authority,
-            secure: url.scheme == Scheme::Https,
+            host: String::from(http_url.host()),
+            secure: Scheme::Https.eq(&http_url.scheme()),
         })
     }
 }

src/error.rs

@@ -1,6 +1,6 @@
 use crate::protocol::{HttpMethod, HttpStatus};
 #[cfg(not(feature = "std"))]
-use alloc::string::String;
+use alloc::string::{String, ToString};
 use core::fmt;
 use core::num;
 use core::str;
@@ -80,3 +80,9 @@ impl From<crate::ssl::Error> for Error {
         Self::SslError(e)
     }
 }
+
+impl From<url::ParseError> for Error {
+    fn from(e: url::ParseError) -> Self {
+        Self::ParseError(e.to_string())
+    }
+}

src/server.rs

@@ -59,7 +59,7 @@
 //!         Ok(())
 //!     });
 //!
-//!     let url = format!("http://localhost:{}/src/server.rs", port);
+//!     let url = format!("http://127.0.0.1:{}/src/server.rs", port);
 //!     let mut body = http_io::client::get(url.as_ref())?;
 //!     io::copy(&mut body, &mut std::io::stdout())?;
 //!     handle.join().unwrap()?;

src/ssl/mod.rs

@@ -1,3 +1,6 @@
+// disable false positive of not using the String, the dead code analysis
+// intentionally ignore we derive the Debug trait
+#[allow(dead_code)]
 #[derive(Debug)]
 pub struct Error(String);
 

src/ssl/rustls.rs

@@ -2,13 +2,8 @@ use super::{Error, Result};
 use crate::io;
 use crate::server::Listen;
 use std::convert::TryInto as _;
-
-#[cfg(feature = "std")]
 use std::sync::Arc;
 
-#[cfg(not(feature = "std"))]
-use alloc::sync::Arc;
-
 #[cfg(test)]
 fn read_test_cert(name: &str) -> Result<Vec<u8>> {
     use io::Read as _;
@@ -23,20 +18,19 @@ fn read_test_cert(name: &str) -> Result<Vec<u8>> {
 
 fn root_store() -> Result<rustls::RootCertStore> {
     let mut root_store = rustls::RootCertStore::empty();
-    root_store.add_server_trust_anchors(webpki_roots::TLS_SERVER_ROOTS.0.iter().map(|ta| {
+    root_store.add_server_trust_anchors(webpki_roots::TLS_SERVER_ROOTS.iter().map(|ta| {
         rustls::OwnedTrustAnchor::from_subject_spki_name_constraints(
-            ta.subject,
-            ta.spki,
-            ta.name_constraints,
+            ta.subject.to_vec(),
+            ta.subject_public_key_info.to_vec(),
+            ta.name_constraints.as_ref().map(|c| c.to_vec()),
         )
     }));
 
     #[cfg(test)]
-    for c in rustls_pemfile::certs(&mut io::BufReader::new(&read_test_cert("test_ca.pem")?[..]))?
-        .iter()
-        .map(|v| rustls::Certificate(v.clone()))
-    {
-        root_store.add(&c).map_err(|e| Error(e.to_string()))?;
+    for c in rustls_pemfile::certs(&mut io::BufReader::new(&read_test_cert("test_ca.pem")?[..])) {
+        root_store
+            .add(&rustls::Certificate(c?.to_vec()))
+            .map_err(|e| Error(e.to_string()))?;
     }
 
     Ok(root_store)
@@ -138,13 +132,15 @@ pub struct SslListener<L> {
 impl<L: Listen> SslListener<L> {
     pub fn new(private_key_pem: &[u8], cert_pem: &[u8], listener: L) -> Result<Self> {
         let private_key = rustls::PrivateKey(
-            rustls_pemfile::pkcs8_private_keys(&mut io::BufReader::new(private_key_pem))?[0]
-                .clone(),
+            rustls_pemfile::private_key(&mut io::BufReader::new(private_key_pem))?
+                .unwrap()
+                .secret_der()
+                .to_vec(),
         );
-        let certs = rustls_pemfile::certs(&mut io::BufReader::new(cert_pem))?
-            .iter()
-            .map(|v| rustls::Certificate(v.clone()))
-            .collect();
+        let mut certs = Vec::new();
+        for cert in rustls_pemfile::certs(&mut io::BufReader::new(cert_pem)) {
+            certs.push(rustls::Certificate(cert?.to_vec()));
+        }
 
         let config = rustls::ServerConfig::builder()
             .with_safe_defaults()