Client: Add https support

Author: saulvaldelvira

crates/client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "httpcli"
-version = "0.5.0"
+version = "0.6.0"
 edition = "2024"
 description = "Http client"
 authors = ["Saúl Valdelvira <saul@saulv.es>"]
@@ -13,3 +13,14 @@ path = "src/main.rs"
 
 [dependencies]
 http.workspace = true
+webpki-roots = { version = "1.0.1", optional = true }
+
+[dependencies.rustls]
+version = ">=0.23.28"
+optional = true
+default-features = false
+features = ["std", "aws_lc_rs"]
+
+[features]
+default = ["tls"]
+tls = ["dep:rustls", "dep:webpki-roots", "http/tls"]

crates/client/src/config.rs

@@ -9,6 +9,12 @@ pub enum OutFile {
     GetFromUrl,
 }
 
+#[derive(Clone, Debug)]
+pub enum HttpType {
+    Http,
+    Https,
+}
+
 #[derive(Clone, Debug)]
 pub struct ClientConfig {
     pub url: String,
@@ -17,6 +23,7 @@ pub struct ClientConfig {
     pub port: u16,
     pub user_agent: String,
     pub out_file: OutFile,
+    pub http_type: HttpType,
 }
 
 impl ClientConfig {
@@ -54,7 +61,13 @@ impl ClientConfig {
         }
 
         let mut host = conf.url.as_str();
-        host = conf.url.strip_prefix("http://").unwrap_or(host);
+        if let Some(url) = conf.url.strip_prefix("http://") {
+            host = url;
+        }
+        if let Some(url) = conf.url.strip_prefix("https://") {
+            host = url;
+            conf.http_type = HttpType::Https;
+        }
 
         let mut url = "/";
 
@@ -66,6 +79,11 @@ impl ClientConfig {
         if let Some(i) = host.find(':') {
             conf.port = host[i + 1..].parse()?;
             host = &host[..i];
+        } else {
+            conf.port = match conf.http_type {
+                HttpType::Http => 80,
+                HttpType::Https => 443,
+            }
         }
 
         conf.host = host.to_string();
@@ -82,13 +100,6 @@ impl ClientConfig {
 fn help() -> ! {
     println!(
         "\
-http-client: Copyright (C) 2025 Saúl Valdelvira
-
-This program is free software: you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation, version 3.
-Use http-client --license to read a copy of the GPL v3
-
 USAGE: http-client [--method <HTTP Method>] [--host <hostname>]
                    [--user-agent <User Agent>] [-O] [-o <output-file>]
 PARAMETERS:
@@ -137,6 +148,7 @@ impl Default for ClientConfig {
             host: String::new(),
             user_agent: "http-client".to_string(),
             out_file: OutFile::Stdout,
+            http_type: HttpType::Http,
         }
     }
 }

crates/client/src/main.rs

@@ -1,22 +1,64 @@
 use std::{
     env,
     fs::File,
+    io,
     io::{Write, stdout},
     net::{TcpStream, ToSocketAddrs},
     process,
 };
 
-use http::{HttpMethod, HttpRequest};
+use http::{HttpMethod, HttpRequest, HttpResponse};
 mod config;
 use config::ClientConfig;
 
+use crate::config::HttpType;
+
 fn open_file(fname: &str) -> Box<dyn Write> {
     Box::new(File::create(fname).unwrap_or_else(|_| {
         eprintln!("Couldn't create file: {fname}");
         process::exit(1);
     }))
 }
 
+#[cfg(not(feature = "tls"))]
+#[inline]
+fn send_request(
+    tcp: TcpStream,
+    _http_type: HttpType,
+    _host: String,
+    req: HttpRequest,
+) -> http::Result<HttpResponse> {
+    req.send_to(tcp)
+}
+
+#[cfg(feature = "tls")]
+fn send_request(
+    tcp: TcpStream,
+    http_type: HttpType,
+    host: String,
+    req: HttpRequest,
+) -> http::Result<HttpResponse> {
+    use std::sync::Arc;
+
+    if matches!(http_type, HttpType::Https) {
+        let root_store = rustls::RootCertStore {
+            roots: webpki_roots::TLS_SERVER_ROOTS.into(),
+        };
+        let mut config = rustls::ClientConfig::builder()
+            .with_root_certificates(root_store)
+            .with_no_client_auth();
+
+        config.key_log = Arc::new(rustls::KeyLogFile::new());
+
+        let conn =
+            rustls::ClientConnection::new(Arc::new(config), host.try_into().unwrap()).unwrap();
+        let tls = rustls::StreamOwned::new(conn, tcp);
+        req.send_to(tls)
+    } else {
+        req.send_to(tcp)
+    }
+}
+
 pub fn main() -> http::Result<()> {
     let conf = ClientConfig::parse(env::args().skip(1)).unwrap_or_else(|err| {
         eprintln!("ERROR: {err}");
@@ -34,19 +76,21 @@ pub fn main() -> http::Result<()> {
                 .url
                 .split('/')
                 .filter(|s| !s.is_empty())
-                .last()
+                .next_back()
                 .unwrap_or(&conf.host);
             open_file(fname)
         }
     };
 
     let req = HttpRequest::builder()
-        .method(HttpMethod::GET)
-        .url(conf.url)
+        .method(conf.method)
+        .url(conf.url.clone().into_boxed_str())
         .version(1.1)
-        .header("Host", conf.host)
+        .header("Host", conf.host.clone().into_boxed_str())
         .header("Accept", "*/*")
         .header("User-Agent", "http-client")
+        .header("Connection", "close")
+        .header("Accept-Encoding", "identity")
         .build()
         .unwrap();
 
@@ -57,14 +101,32 @@ pub fn main() -> http::Result<()> {
             process::exit(1);
         }
     };
-    let mut result = req.send_to(tcp).unwrap_or_else(|err| {
-        eprint!("ERROR: {err}");
-        process::exit(1);
-    });
+
+    let mut result =
+        send_request(tcp, conf.http_type, conf.host.clone(), req).unwrap_or_else(|err| {
+            eprint!("ERROR: {err}");
+            process::exit(1);
+        });
+
+    if matches!(conf.method, HttpMethod::HEAD) {
+        println!("Headers");
+        for (k, v) in result.headers() {
+            println!("{k}: {v}");
+        }
+        return Ok(());
+    }
 
     match result.write_to(&mut out) {
         Ok(_) => { /* eprintln!("\n\n{n} bytes transfered") */ }
-        Err(err) => eprintln!("\n\nERROR: {err}"),
+        Err(err) => {
+            match err.kind() {
+                /* Ignore this error kind
+                 * https://docs.rs/rustls/latest/rustls/manual/_03_howto/index.html#unexpected-eof
+                 * */
+                io::ErrorKind::UnexpectedEof => {}
+                _ => eprintln!("\n\nERROR: {err}"),
+            }
+        }
     }
 
     Ok(())

crates/http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "http-utils"
-version = "0.5.0"
+version = "0.6.0"
 edition = "2024"
 description = "Http utils"
 authors = ["Saúl Valdelvira <saul@saulv.es>"]

crates/http/src/request/mod.rs

@@ -265,24 +265,21 @@ impl HttpRequest {
     ///
     /// # Errors
     /// If, while reading or writing, some io Error is found
-    pub fn read_body(&mut self, writer: &mut dyn Write) -> Result<()> {
-        const CHUNK_SIZE: usize = 1024;
-        let mut buf: [u8; CHUNK_SIZE] = [0; CHUNK_SIZE];
-        let len = self.content_length();
-        let n = len / CHUNK_SIZE;
-        let remainder = len % CHUNK_SIZE;
-
-        for _ in 0..n {
-            self.stream.read_exact(&mut buf)?;
-            writer.write_all(&buf)?;
-        }
+    pub fn read_body(&mut self, out: &mut dyn Write) -> Result<usize> {
+        let mut total = 0;
+        loop {
+            let slice = self.stream.fill_buf()?;
+            if slice.is_empty() {
+                break;
+            }
+            out.write_all(slice)?;
 
-        if remainder > 0 {
-            self.stream.read_exact(&mut buf[0..remainder])?;
-            writer.write_all(&buf[0..remainder])?;
+            let len = slice.len();
+            self.stream.consume(len);
+            total += len;
         }
-
-        Ok(())
+        out.flush()?;
+        Ok(total)
     }
     /// Respond to the request without a body
     ///

crates/http/src/response/mod.rs

@@ -159,14 +159,17 @@ impl HttpResponse {
     }
 
     pub fn write_to(&mut self, out: &mut dyn io::Write) -> io::Result<usize> {
-        let mut buf = [0_u8; 1024];
         let mut total = 0;
-        while let Ok(n) = self.stream.read(&mut buf) {
-            out.write_all(&buf[0..n])?;
-            total += n;
-            if n == 0 {
+        loop {
+            let slice = self.stream.fill_buf()?;
+            if slice.is_empty() {
                 break;
             }
+            out.write_all(slice)?;
+
+            let len = slice.len();
+            self.stream.consume(len);
+            total += len;
         }
         out.flush()?;
         Ok(total)

crates/server/Cargo.toml

@@ -17,8 +17,6 @@ jsonrs = { package = "jsonrs", version = ">=0.1.4", git = "https://github.com/sa
 delay_init = { package = "delay_init" , version = ">=0.2.0", git = "https://github.com/saulvaldelvira/delay-init" }
 base64 = { package = "rb64", version = ">=0.1.0", git = "https://github.com/saulvaldelvira/rb64" }
 url = { package = "url-utils", version = ">=0.1.0", path = "../url" }
-rustls = "0.23.28"
-webpki-roots = "1.0.1"
 
 [features]
 default = ["full"]

crates/server/src/lib.rs

@@ -57,6 +57,7 @@ use std::{
     io::{self, BufRead, BufReader},
     net::{TcpListener, TcpStream},
     sync::Arc,
+    thread,
     time::{Duration, Instant},
 };
 
@@ -117,6 +118,7 @@ fn handle_connection(
     if connection.is_some_and(|conn| conn == "keep-alive") && keep_alive {
         let start = Instant::now();
         let mut n = 1;
+        log_info!("[{:?}] Start keep alive", thread::current().id());
         while start.elapsed() < keep_alive_timeout && n < keep_alive_requests {
             let offset = keep_alive_timeout - start.elapsed();
 
@@ -134,6 +136,7 @@ fn handle_connection(
                 break;
             }
         }
+        log_info!("[{:?}] End keep alive", thread::current().id());
     }
     Ok(())
 }