From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from firstgate.proxmox.com (firstgate.proxmox.com [212.224.123.68]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by lists.proxmox.com (Postfix) with ESMTPS id 450B570AC8 for ; Fri, 14 May 2021 15:45:45 +0200 (CEST) Received: from firstgate.proxmox.com (localhost [127.0.0.1]) by firstgate.proxmox.com (Proxmox) with ESMTP id 37CD117C9A for ; Fri, 14 May 2021 15:45:15 +0200 (CEST) Received: from proxmox-new.maurer-it.com (proxmox-new.maurer-it.com [94.136.29.106]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by firstgate.proxmox.com (Proxmox) with ESMTPS id CE55117B49 for ; Fri, 14 May 2021 15:45:11 +0200 (CEST) Received: from proxmox-new.maurer-it.com (localhost.localdomain [127.0.0.1]) by proxmox-new.maurer-it.com (Proxmox) with ESMTP id A72D046566 for ; Fri, 14 May 2021 15:45:11 +0200 (CEST) From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= To: pbs-devel@lists.proxmox.com Date: Fri, 14 May 2021 15:44:48 +0200 Message-Id: <20210514134457.1447930-13-f.gruenbichler@proxmox.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210514134457.1447930-1-f.gruenbichler@proxmox.com> References: <20210514134457.1447930-1-f.gruenbichler@proxmox.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-SPAM-LEVEL: Spam detection results: 0 AWL -0.038 Adjusted score from AWL reputation of From: address KAM_DMARC_STATUS 0.01 Test Rule for DKIM or SPF Failure with Strict Alignment PROLO_LEO1 0.1 Meta Catches all Leo drug variations so far SPF_HELO_NONE 0.001 SPF: HELO does not publish an SPF Record SPF_PASS -0.001 SPF: sender matches SPF record URIBL_BLOCKED 0.001 ADMINISTRATOR NOTICE: The query to URIBL was blocked. See http://wiki.apache.org/spamassassin/DnsBlocklists#dnsbl-block for more information. [wrapper.rs, simple.rs, helpers.rs, connector.rs] Subject: [pbs-devel] [PATCH proxmox 12/13] http: rustfmt X-BeenThere: pbs-devel@lists.proxmox.com X-Mailman-Version: 2.1.29 Precedence: list List-Id: Proxmox Backup Server development discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 14 May 2021 13:45:45 -0000 Signed-off-by: Fabian Grünbichler --- proxmox-http/src/http/client/connector.rs | 78 ++++++++++++----------- proxmox-http/src/http/client/simple.rs | 45 ++++++------- proxmox-http/src/http/helpers.rs | 11 ++-- proxmox-http/src/http/proxy_config.rs | 8 +-- proxmox-http/src/http/wrapper.rs | 65 +++++-------------- 5 files changed, 89 insertions(+), 118 deletions(-) diff --git a/proxmox-http/src/http/client/connector.rs b/proxmox-http/src/http/client/connector.rs index a302dd1..d69fdf2 100644 --- a/proxmox-http/src/http/client/connector.rs +++ b/proxmox-http/src/http/client/connector.rs @@ -1,4 +1,4 @@ -use anyhow::{Error, format_err, bail}; +use anyhow::{bail, format_err, Error}; use std::os::unix::io::AsRawFd; use std::pin::Pin; use std::sync::Arc; @@ -8,11 +8,7 @@ use futures::*; use http::Uri; use hyper::client::HttpConnector; use openssl::ssl::SslConnector; -use tokio::io::{ - AsyncRead, - AsyncReadExt, - AsyncWriteExt, -}; +use tokio::io::{AsyncRead, AsyncReadExt, AsyncWriteExt}; use tokio::net::TcpStream; use tokio_openssl::SslStream; @@ -29,7 +25,11 @@ pub struct HttpsConnector { } impl HttpsConnector { - pub fn with_connector(mut connector: HttpConnector, ssl_connector: SslConnector, tcp_keepalive: u32) -> Self { + pub fn with_connector( + mut connector: HttpConnector, + ssl_connector: SslConnector, + tcp_keepalive: u32, + ) -> Self { connector.enforce_http(false); Self { connector, @@ -61,21 +61,27 @@ impl HttpsConnector { Ok(()) } - async fn parse_connect_response( - stream: &mut R, - ) -> Result<(), Error> { - + async fn parse_connect_response(stream: &mut R) -> Result<(), Error> { let mut data: Vec = Vec::new(); let mut buffer = [0u8; 256]; const END_MARK: &[u8; 4] = b"\r\n\r\n"; 'outer: loop { let n = stream.read(&mut buffer[..]).await?; - if n == 0 { break; } - let search_start = if data.len() > END_MARK.len() { data.len() - END_MARK.len() + 1 } else { 0 }; + if n == 0 { + break; + } + let search_start = if data.len() > END_MARK.len() { + data.len() - END_MARK.len() + 1 + } else { + 0 + }; data.extend(&buffer[..n]); if data.len() >= END_MARK.len() { - if let Some(pos) = data[search_start..].windows(END_MARK.len()).position(|w| w == END_MARK) { + if let Some(pos) = data[search_start..] + .windows(END_MARK.len()) + .position(|w| w == END_MARK) + { let response = String::from_utf8_lossy(&data); let status_line = match response.split("\r\n").next() { Some(status) => status, @@ -89,7 +95,8 @@ impl HttpsConnector { break 'outer; } } - if data.len() > 1024*32 { // max 32K (random chosen limit) + if data.len() > 1024 * 32 { + // max 32K (random chosen limit) bail!("too many bytes"); } } @@ -101,12 +108,11 @@ impl hyper::service::Service for HttpsConnector { type Response = MaybeTlsStream; type Error = Error; #[allow(clippy::type_complexity)] - type Future = Pin> + Send + 'static>>; + type Future = + Pin> + Send + 'static>>; fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { - self.connector - .poll_ready(ctx) - .map_err(|err| err.into()) + self.connector.poll_ready(ctx).map_err(|err| err.into()) } fn call(&mut self, dst: Uri) -> Self::Future { @@ -123,7 +129,6 @@ impl hyper::service::Service for HttpsConnector { let keepalive = self.tcp_keepalive; if let Some(ref proxy) = self.proxy { - let use_connect = is_https || proxy.force_connect; let proxy_authority = match helpers::build_authority(&proxy.host, proxy.port) { @@ -145,17 +150,16 @@ impl hyper::service::Service for HttpsConnector { if use_connect { async move { - - let mut tcp_stream = connector - .call(proxy_uri) - .await - .map_err(|err| format_err!("error connecting to {} - {}", proxy_authority, err))?; + let mut tcp_stream = connector.call(proxy_uri).await.map_err(|err| { + format_err!("error connecting to {} - {}", proxy_authority, err) + })?; let _ = set_tcp_keepalive(tcp_stream.as_raw_fd(), keepalive); let mut connect_request = format!("CONNECT {0}:{1} HTTP/1.1\r\n", host, port); if let Some(authorization) = authorization { - connect_request.push_str(&format!("Proxy-Authorization: {}\r\n", authorization)); + connect_request + .push_str(&format!("Proxy-Authorization: {}\r\n", authorization)); } connect_request.push_str(&format!("Host: {0}:{1}\r\n\r\n", host, port)); @@ -169,18 +173,19 @@ impl hyper::service::Service for HttpsConnector { } else { Ok(MaybeTlsStream::Normal(tcp_stream)) } - }.boxed() + } + .boxed() } else { - async move { - let tcp_stream = connector - .call(proxy_uri) - .await - .map_err(|err| format_err!("error connecting to {} - {}", proxy_authority, err))?; + async move { + let tcp_stream = connector.call(proxy_uri).await.map_err(|err| { + format_err!("error connecting to {} - {}", proxy_authority, err) + })?; - let _ = set_tcp_keepalive(tcp_stream.as_raw_fd(), keepalive); + let _ = set_tcp_keepalive(tcp_stream.as_raw_fd(), keepalive); - Ok(MaybeTlsStream::Proxied(tcp_stream)) - }.boxed() + Ok(MaybeTlsStream::Proxied(tcp_stream)) + } + .boxed() } } else { async move { @@ -197,7 +202,8 @@ impl hyper::service::Service for HttpsConnector { } else { Ok(MaybeTlsStream::Normal(tcp_stream)) } - }.boxed() + } + .boxed() } } } diff --git a/proxmox-http/src/http/client/simple.rs b/proxmox-http/src/http/client/simple.rs index 6783781..b6e6d5a 100644 --- a/proxmox-http/src/http/client/simple.rs +++ b/proxmox-http/src/http/client/simple.rs @@ -1,16 +1,13 @@ -use anyhow::{Error, format_err, bail}; +use anyhow::{bail, format_err, Error}; use std::collections::HashMap; -use hyper::Body; +use futures::*; +use http::{HeaderValue, Request, Response}; use hyper::client::{Client, HttpConnector}; -use http::{Request, Response, HeaderValue}; +use hyper::Body; use openssl::ssl::{SslConnector, SslMethod}; -use futures::*; -use crate::http::{ - ProxyConfig, - client::HttpsConnector, -}; +use crate::http::{client::HttpsConnector, ProxyConfig}; /// Options for a SimpleHttp client. #[derive(Default)] @@ -27,7 +24,7 @@ impl SimpleHttpOptions { fn get_proxy_authorization(&self) -> Option { if let Some(ref proxy_config) = self.proxy_config { if !proxy_config.force_connect { - return proxy_config.authorization.clone(); + return proxy_config.authorization.clone(); } } @@ -55,7 +52,11 @@ impl SimpleHttp { pub fn with_ssl_connector(ssl_connector: SslConnector, options: SimpleHttpOptions) -> Self { let connector = HttpConnector::new(); - let mut https = HttpsConnector::with_connector(connector, ssl_connector, options.tcp_keepalive.unwrap_or(7200)); + let mut https = HttpsConnector::with_connector( + connector, + ssl_connector, + options.tcp_keepalive.unwrap_or(7200), + ); if let Some(ref proxy_config) = options.proxy_config { https.set_proxy(proxy_config.clone()); } @@ -71,12 +72,10 @@ impl SimpleHttp { fn add_proxy_headers(&self, request: &mut Request) -> Result<(), Error> { if request.uri().scheme() != Some(&http::uri::Scheme::HTTPS) { if let Some(ref authorization) = self.options.get_proxy_authorization() { - request - .headers_mut() - .insert( - http::header::PROXY_AUTHORIZATION, - HeaderValue::from_str(authorization)?, - ); + request.headers_mut().insert( + http::header::PROXY_AUTHORIZATION, + HeaderValue::from_str(authorization)?, + ); } } Ok(()) @@ -89,13 +88,13 @@ impl SimpleHttp { HeaderValue::from_str(Self::DEFAULT_USER_AGENT_STRING)? }; - request.headers_mut().insert(hyper::header::USER_AGENT, user_agent); + request + .headers_mut() + .insert(hyper::header::USER_AGENT, user_agent); self.add_proxy_headers(&mut request)?; - self.client.request(request) - .map_err(Error::from) - .await + self.client.request(request).map_err(Error::from).await } pub async fn post( @@ -104,7 +103,6 @@ impl SimpleHttp { body: Option, content_type: Option<&str>, ) -> Result, Error> { - let body = if let Some(body) = body { Body::from(body) } else { @@ -126,10 +124,7 @@ impl SimpleHttp { uri: &str, extra_headers: Option<&HashMap>, ) -> Result { - - let mut request = Request::builder() - .method("GET") - .uri(uri); + let mut request = Request::builder().method("GET").uri(uri); if let Some(hs) = extra_headers { for (h, v) in hs.iter() { diff --git a/proxmox-http/src/http/helpers.rs b/proxmox-http/src/http/helpers.rs index 3f663d2..ca67161 100644 --- a/proxmox-http/src/http/helpers.rs +++ b/proxmox-http/src/http/helpers.rs @@ -6,10 +6,11 @@ use http::uri::Authority; pub fn build_authority(host: &str, port: u16) -> Result { let bytes = host.as_bytes(); let len = bytes.len(); - let authority = if len > 3 && bytes.contains(&b':') && bytes[0] != b'[' && bytes[len-1] != b']' { - format!("[{}]:{}", host, port).parse()? - } else { - format!("{}:{}", host, port).parse()? - }; + let authority = + if len > 3 && bytes.contains(&b':') && bytes[0] != b'[' && bytes[len - 1] != b']' { + format!("[{}]:{}", host, port).parse()? + } else { + format!("{}:{}", host, port).parse()? + }; Ok(authority) } diff --git a/proxmox-http/src/http/proxy_config.rs b/proxmox-http/src/http/proxy_config.rs index 9eac3bd..3fe7cba 100644 --- a/proxmox-http/src/http/proxy_config.rs +++ b/proxmox-http/src/http/proxy_config.rs @@ -1,4 +1,4 @@ -use anyhow::{Error, format_err, bail}; +use anyhow::{bail, format_err, Error}; use http::Uri; @@ -16,7 +16,6 @@ pub struct ProxyConfig { impl ProxyConfig { /// Parse proxy config from ALL_PROXY environment var pub fn from_proxy_env() -> Result, Error> { - // We only support/use ALL_PROXY environment match std::env::var_os("ALL_PROXY") { @@ -70,7 +69,8 @@ impl ProxyConfig { authorization, force_connect: false, }) - }).map_err(|err| format_err!("parse_proxy_url failed: {}", err)) + }) + .map_err(|err| format_err!("parse_proxy_url failed: {}", err)) } /// Assemble canonical proxy string (including scheme and port) @@ -78,7 +78,7 @@ impl ProxyConfig { let authority = helpers::build_authority(&self.host, self.port)?; Ok(match self.authorization { None => format!("http://{}", authority), - Some(ref authorization) => format!("http://{}@{}", authorization, authority) + Some(ref authorization) => format!("http://{}@{}", authorization, authority), }) } } diff --git a/proxmox-http/src/http/wrapper.rs b/proxmox-http/src/http/wrapper.rs index 3399b28..9ed4221 100644 --- a/proxmox-http/src/http/wrapper.rs +++ b/proxmox-http/src/http/wrapper.rs @@ -2,7 +2,7 @@ use std::io; use std::pin::Pin; use std::task::{Context, Poll}; -use hyper::client::connect::{Connection, Connected}; +use hyper::client::connect::{Connected, Connection}; use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; use tokio_openssl::SslStream; @@ -22,15 +22,9 @@ impl AsyncRead for MaybeTlsStream { buf: &mut ReadBuf, ) -> Poll> { match self.get_mut() { - MaybeTlsStream::Normal(ref mut s) => { - Pin::new(s).poll_read(cx, buf) - } - MaybeTlsStream::Proxied(ref mut s) => { - Pin::new(s).poll_read(cx, buf) - } - MaybeTlsStream::Secured(ref mut s) => { - Pin::new(s).poll_read(cx, buf) - } + MaybeTlsStream::Normal(ref mut s) => Pin::new(s).poll_read(cx, buf), + MaybeTlsStream::Proxied(ref mut s) => Pin::new(s).poll_read(cx, buf), + MaybeTlsStream::Secured(ref mut s) => Pin::new(s).poll_read(cx, buf), } } } @@ -42,15 +36,9 @@ impl AsyncWrite for MaybeTlsStream { buf: &[u8], ) -> Poll> { match self.get_mut() { - MaybeTlsStream::Normal(ref mut s) => { - Pin::new(s).poll_write(cx, buf) - } - MaybeTlsStream::Proxied(ref mut s) => { - Pin::new(s).poll_write(cx, buf) - } - MaybeTlsStream::Secured(ref mut s) => { - Pin::new(s).poll_write(cx, buf) - } + MaybeTlsStream::Normal(ref mut s) => Pin::new(s).poll_write(cx, buf), + MaybeTlsStream::Proxied(ref mut s) => Pin::new(s).poll_write(cx, buf), + MaybeTlsStream::Secured(ref mut s) => Pin::new(s).poll_write(cx, buf), } } @@ -60,15 +48,9 @@ impl AsyncWrite for MaybeTlsStream { bufs: &[io::IoSlice<'_>], ) -> Poll> { match self.get_mut() { - MaybeTlsStream::Normal(ref mut s) => { - Pin::new(s).poll_write_vectored(cx, bufs) - } - MaybeTlsStream::Proxied(ref mut s) => { - Pin::new(s).poll_write_vectored(cx, bufs) - } - MaybeTlsStream::Secured(ref mut s) => { - Pin::new(s).poll_write_vectored(cx, bufs) - } + MaybeTlsStream::Normal(ref mut s) => Pin::new(s).poll_write_vectored(cx, bufs), + MaybeTlsStream::Proxied(ref mut s) => Pin::new(s).poll_write_vectored(cx, bufs), + MaybeTlsStream::Secured(ref mut s) => Pin::new(s).poll_write_vectored(cx, bufs), } } @@ -82,36 +64,23 @@ impl AsyncWrite for MaybeTlsStream { fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll> { match self.get_mut() { - MaybeTlsStream::Normal(ref mut s) => { - Pin::new(s).poll_flush(cx) - } - MaybeTlsStream::Proxied(ref mut s) => { - Pin::new(s).poll_flush(cx) - } - MaybeTlsStream::Secured(ref mut s) => { - Pin::new(s).poll_flush(cx) - } + MaybeTlsStream::Normal(ref mut s) => Pin::new(s).poll_flush(cx), + MaybeTlsStream::Proxied(ref mut s) => Pin::new(s).poll_flush(cx), + MaybeTlsStream::Secured(ref mut s) => Pin::new(s).poll_flush(cx), } } fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll> { match self.get_mut() { - MaybeTlsStream::Normal(ref mut s) => { - Pin::new(s).poll_shutdown(cx) - } - MaybeTlsStream::Proxied(ref mut s) => { - Pin::new(s).poll_shutdown(cx) - } - MaybeTlsStream::Secured(ref mut s) => { - Pin::new(s).poll_shutdown(cx) - } + MaybeTlsStream::Normal(ref mut s) => Pin::new(s).poll_shutdown(cx), + MaybeTlsStream::Proxied(ref mut s) => Pin::new(s).poll_shutdown(cx), + MaybeTlsStream::Secured(ref mut s) => Pin::new(s).poll_shutdown(cx), } } } // we need this for the hyper http client -impl Connection for MaybeTlsStream -{ +impl Connection for MaybeTlsStream { fn connected(&self) -> Connected { match self { MaybeTlsStream::Normal(s) => s.connected(), -- 2.20.1