From c580239c33ddca9237fb89fe35793a7d4011b0d7 Mon Sep 17 00:00:00 2001 From: Antun Krasic Date: Thu, 11 Apr 2024 14:21:04 +0100 Subject: [PATCH] Use the proper exector --- src/main.rs | 74 +++++++++++++++++++++++++++++++---------------------- 1 file changed, 43 insertions(+), 31 deletions(-) diff --git a/src/main.rs b/src/main.rs index 7e9464d..58d4abb 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,11 +1,14 @@ -use hyper::body::Bytes; +use core::panic; use http_body_util::{combinators::BoxBody, BodyExt, Empty}; +use hyper::body::Bytes; use hyper::Request; use hyper_util::rt::TokioIo; -use tokio::net::TcpStream; use log::debug; +use std::{net::ToSocketAddrs, sync::Arc}; +use tokio::net::TcpStream; use tokio_rustls::{rustls, TlsConnector}; -use std::sync::Arc; + +// empty pub fn empty_body() -> BoxBody { Empty::::new() @@ -14,14 +17,14 @@ pub fn empty_body() -> BoxBody { } // -// With using the HTTP2 we need to take the executre +// With using the HTTP2 we need to take the executre // https://docs.rs/hyper/latest/hyper/rt/trait.Executor.html #[derive(Clone, Debug)] struct MyExecutor; impl hyper::rt::Executor for MyExecutor - where -F: std::future::Future + Send + 'static, +where + F: std::future::Future + Send + 'static, F::Output: Send + 'static, { fn execute(&self, future: F) { @@ -31,50 +34,59 @@ F: std::future::Future + Send + 'static, #[tokio::main] async fn main() -> Result<(), Box> { + // Set log level to TRACE to see detailed information tracing_subscriber::fmt() - .with_max_level(tracing::Level::TRACE) + .with_max_level(tracing::Level::INFO) .init(); - let target_host = "167.235.156.145:443"; - let domain = "g.s0c.in"; + let domain = "www.google.com"; + let uri = format!("https://{}/", domain); + let target_host = match format!("{}:443", domain).to_socket_addrs() { + Ok(socket_ip) => socket_ip.into_iter().next().unwrap(), + Err(e) => { + panic!("DNS resolution error: {}", e); + } + }; let mut root_cert_store = rustls::RootCertStore::empty(); root_cert_store.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned()); - let mut config = rustls::ClientConfig::builder().with_root_certificates(root_cert_store).with_no_client_auth(); + let mut config = rustls::ClientConfig::builder() + .with_root_certificates(root_cert_store) + .with_no_client_auth(); // Available protocols: http/1.0, http/1.1, h2 config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec(), b"http/1.0".to_vec()]; - let connector = TlsConnector::from(Arc::new(config)); - - // Look into adding tokiotls there working with setting up a client TLS connection + // Look into adding tokiotls there working with setting up a client TLS connection // - // Connection established with the remote host - // Establish valid Client TLS negotiation process - // Craft the request - HTTP/1.1 or HTTP/2 needs to be looked at - // Send the request. + // Connection established with the remote host + // Establish valid Client TLS negotiation process + // Craft the request - HTTP/1.1 or HTTP/2 needs to be looked at + // Send the request. // - // From the intiial look, it might seem that the needed action here is to do the - // actual TLS negtiation based on the `TcpStream` that was opened. - // Established a valid TLS connection. + // From the intiial look, it might seem that the needed action here is to do the + // actual TLS negtiation based on the `TcpStream` that was opened. + // Established a valid TLS connection. // - // Once a TLS connection is estasblished either a HTTP/1.1 request should be sent - // over the line. - // Or establish a HTTP/2 type connection to stream over the TLS connection. + // Once a TLS connection is estasblished either a HTTP/1.1 request should be sent + // over the line. + // Or establish a HTTP/2 type connection to stream over the TLS connection. // let tcp_stream = TcpStream::connect(target_host).await?; - let tls_domain = rustls_pki_types::ServerName::try_from(domain).map_err(|_| std::io::Error::new(std::io::ErrorKind::InvalidInput, "invalid dnsname"))?.to_owned(); + let tls_domain = rustls_pki_types::ServerName::try_from(domain) + .map_err(|_| std::io::Error::new(std::io::ErrorKind::InvalidInput, "invalid dnsname"))? + .to_owned(); // let io = IOTypeNotSend::new(hyper_util::rt::TokioIo::new(tcp_stream)); let stream = connector.connect(tls_domain, tcp_stream).await?; let io = TokioIo::new(stream); - - // let (mut sender, conn) = hyper::client::conn::http1::handshake(io).await.unwrap(); - let (mut sender, conn) = hyper::client::conn::http2::handshake(MyExecutor, io).await?; + let executor = hyper_util::rt::tokio::TokioExecutor::new(); + // let (mut sender, conn) = hyper::client::conn::http1::handshake(io).await.unwrap(); + let (mut sender, conn) = hyper::client::conn::http2::handshake(executor, io).await?; tokio::task::spawn(async move { if let Err(e) = conn.await { @@ -83,18 +95,18 @@ async fn main() -> Result<(), Box> { }); let upstream_request = Request::builder() - .uri("https://g.s0c.in/") - // .header("host", domain) + .uri(uri) .header("user-agent", "lolza-0.2") .version(hyper::Version::HTTP_2) - .body(empty_body())?; - + .body(Empty::::new())?; debug!("Request: {:#?}", upstream_request); let res = sender.send_request(upstream_request).await?; debug!("Response: {:#?}", res); + let body = res.collect().await?.to_bytes(); + println!("{}", String::from_utf8_lossy(&body)); Ok(()) }