tuxmain/rust-rpxy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix redirection

Browse source
This commit is contained in:
Jun Kurihara 2022-06-23 23:10:19 -04:00
commit c47efbfc93
No known key found for this signature in database
GPG key ID: 48ADFD173ED22B03
6 changed files with 72 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

107
src/proxy/proxy_handler.rs
View file

@ -27,12 +27,13 @@ pub async fn handle_request(
globals: Arc<Globals>,
backends: Arc<HashMap<String, Backend>>,
) -> Result<Response<Body>> {
let headers = req.headers();
debug!("req: {:?}", req);
// Here we start to handle with hostname
// Find backend application for given hostname
let (hostname, port) = parse_hostname_port(headers, tls_enabled)?;
let (hostname, _port) = parse_hostname_port(&req, tls_enabled)?;
let path = req.uri().path();
let path_and_query = req.uri().path_and_query().unwrap().as_str();
println!("{:?}", path_and_query);
let backend = if let Some(be) = backends.get(hostname.as_str()) {
be
} else {
@ -41,31 +42,18 @@ pub async fn handle_request(
// Redirect to https if tls_enabled is false and redirect_to_https is true
if !tls_enabled && backend.redirect_to_https.unwrap_or(false) {
if let Some(https_port) = globals.https_port {
let dest = if https_port == 443 {
format!("https://{}{}", hostname, path)
} else {
format!(
"https://{}:{}{}",
hostname,
globals.https_port.unwrap(),
path
)
};
return https_redirection(dest);
} else {
return http_error(StatusCode::SERVICE_UNAVAILABLE);
}
debug!("Redirect to https: {}", hostname);
return https_redirection(hostname, globals.https_port, path_and_query);
}
// Find reverse proxy for given path
// let destination_uri = if backend.reverse_proxy.destination_uris.is_some() {
// if let (b) = backend.re
// } else {
// backend.reverse_proxy.default_destination_uri.clone();
// };
let destination_uri = if let Some(uri) = backend.reverse_proxy.destination_uris.get(path) {
uri.to_owned()
} else {
backend.reverse_proxy.default_destination_uri.clone()
};
debug!("path: {}", req.uri().path());
debug!("destination_uri: {}", destination_uri);
// if req.version() == hyper::Version::HTTP_11 {
// Ok(Response::new(Body::from("Hello World")))
// } else {
@ -73,7 +61,7 @@ pub async fn handle_request(
// with an appropriate StatusCode instead of an Err.
// Err("not HTTP/1.1, abort connection")
// http_error(StatusCode::NOT_FOUND)
https_redirection("https://www.google.com/".to_string())
https_redirection("www.google.com".to_string(), Some(443_u16), "/")
// }
// });
}
@ -86,32 +74,67 @@ fn http_error(status_code: StatusCode) -> Result<Response<Body>> {
Ok(response)
}
fn https_redirection(redirect_to: String) -> Result<Response<Body>> {
fn https_redirection(
hostname: String,
https_port: Option<u16>,
path_and_query: &str,
) -> Result<Response<Body>> {
let dest_uri: String = if let Some(https_port) = https_port {
if https_port == 443 {
format!("https://{}{}", hostname, path_and_query)
} else {
format!("https://{}:{}{}", hostname, https_port, path_and_query)
}
} else {
return http_error(StatusCode::SERVICE_UNAVAILABLE);
};
let response = Response::builder()
.status(StatusCode::MOVED_PERMANENTLY)
.header("Location", redirect_to)
.header("Location", dest_uri)
.body(Body::empty())
.unwrap();
Ok(response)
}
fn parse_hostname_port(headers: &HeaderMap, tls_enabled: bool) -> Result<(String, u16)> {
let hostname_port = headers
.get("host")
.ok_or_else(|| anyhow!("No host in request header"))?;
let hp_as_uri = hostname_port.to_str().unwrap().parse::<Uri>().unwrap();
fn parse_hostname_port(req: &Request<Body>, tls_enabled: bool) -> Result<(String, u16)> {
let hostname_port_headers = req.headers().get("host");
let hostname_uri = req.uri().host();
let port_uri = req.uri().port_u16();
let hostname = hp_as_uri
.host()
.ok_or_else(|| anyhow!("Failed to parse hostname"))?;
if hostname_port_headers.is_none() && hostname_uri.is_none() {
bail!("No host in request header");
}
let port = if let Some(p) = hp_as_uri.port() {
p.as_u16()
} else if tls_enabled {
443
} else {
80
let (hostname, port) = match (hostname_uri, hostname_port_headers) {
(Some(x), _) => {
let hostname = hostname_uri.unwrap();
let port = if let Some(p) = port_uri {
p
} else if tls_enabled {
443
} else {
80
};
(hostname.to_string(), port)
}
(None, Some(x)) => {
let hp_as_uri = x.to_str().unwrap().parse::<Uri>().unwrap();
let hostname = hp_as_uri
.host()
.ok_or_else(|| anyhow!("Failed to parse hostname"))?;
let port = if let Some(p) = hp_as_uri.port() {
p.as_u16()
} else if tls_enabled {
443
} else {
80
};
(hostname.to_string(), port)
}
(None, None) => {
bail!("Host unspecified in request")
}
};
Ok((hostname.to_string(), port))
Ok((hostname, port))
}