split proxy into stream handler and http message handler

src/proxy/utils_headers.rs

@@ -1,156 +0,0 @@
-use super::{Upstream, UpstreamOption};
-use crate::{error::*, globals::Globals, log::*, utils::*};
-use bytes::BufMut;
-use hyper::{
-  header::{self, HeaderMap, HeaderName, HeaderValue},
-  Uri,
-};
-use std::{net::SocketAddr, sync::Arc};
-
-////////////////////////////////////////////////////
-// Functions to manipulate headers
-
-pub(super) fn apply_upstream_options_to_header(
-  headers: &mut HeaderMap,
-  _client_addr: &SocketAddr,
-  upstream_scheme_host: &Uri,
-  upstream: &Upstream,
-) -> Result<()> {
-  for opt in upstream.opts.iter() {
-    match opt {
-      UpstreamOption::OverrideHost => {
-        let upstream_host = upstream_scheme_host.host().ok_or_else(|| anyhow!("none"))?;
-        headers
-          .insert(header::HOST, HeaderValue::from_str(upstream_host)?)
-          .ok_or_else(|| anyhow!("none"))?;
-      }
-    }
-  }
-
-  Ok(())
-}
-
-// https://datatracker.ietf.org/doc/html/rfc9110
-pub(super) fn append_header_entry_with_comma(
-  headers: &mut HeaderMap,
-  key: &str,
-  value: &str,
-) -> Result<()> {
-  match headers.entry(HeaderName::from_bytes(key.as_bytes())?) {
-    header::Entry::Vacant(entry) => {
-      entry.insert(value.parse::<HeaderValue>()?);
-    }
-    header::Entry::Occupied(mut entry) => {
-      // entry.append(value.parse::<HeaderValue>()?);
-      let mut new_value = Vec::<u8>::with_capacity(entry.get().as_bytes().len() + 2 + value.len());
-      new_value.put_slice(entry.get().as_bytes());
-      new_value.put_slice(&[b',', b' ']);
-      new_value.put_slice(value.as_bytes());
-      entry.insert(HeaderValue::from_bytes(&new_value)?);
-    }
-  }
-
-  Ok(())
-}
-
-pub(super) fn add_header_entry_if_not_exist(
-  headers: &mut HeaderMap,
-  key: impl Into<std::borrow::Cow<'static, str>>,
-  value: impl Into<std::borrow::Cow<'static, str>>,
-) -> Result<()> {
-  match headers.entry(HeaderName::from_bytes(key.into().as_bytes())?) {
-    header::Entry::Vacant(entry) => {
-      entry.insert(value.into().parse::<HeaderValue>()?);
-    }
-    header::Entry::Occupied(_) => (),
-  };
-
-  Ok(())
-}
-
-pub(super) fn add_forwarding_header(
-  headers: &mut HeaderMap,
-  client_addr: &SocketAddr,
-  tls: bool,
-  globals: &Arc<Globals>, // TODO: Fix
-) -> Result<()> {
-  // default process
-  // optional process defined by upstream_option is applied in fn apply_upstream_options
-  append_header_entry_with_comma(
-    headers,
-    "x-forwarded-for",
-    &client_addr.to_canonical().ip().to_string(),
-  )?;
-
-  /////////// As Nginx
-  // If we receive X-Forwarded-Proto, pass it through; otherwise, pass along the
-  // scheme used to connect to this server
-  add_header_entry_if_not_exist(
-    headers,
-    "x-forwarded-proto",
-    if tls { "https" } else { "http" },
-  )?;
-  // If we receive X-Forwarded-Port, pass it through; otherwise, pass along the
-  // server port the client connected to
-  add_header_entry_if_not_exist(
-    headers,
-    "x-forwarded-port",
-    if tls {
-      globals.https_port.unwrap().to_string()
-    } else {
-      globals.http_port.unwrap().to_string()
-    },
-  )?;
-
-  Ok(())
-}
-
-pub(super) fn remove_connection_header(headers: &mut HeaderMap) {
-  if let Some(values) = headers.get(header::CONNECTION) {
-    if let Ok(v) = values.clone().to_str() {
-      for m in v.split(',') {
-        if !m.is_empty() {
-          headers.remove(m.trim());
-        }
-      }
-    }
-  }
-}
-
-const HOP_HEADERS: &[&str] = &[
-  "connection",
-  "te",
-  "trailer",
-  "keep-alive",
-  "proxy-connection",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "transfer-encoding",
-  "upgrade",
-];
-
-pub(super) fn remove_hop_header(headers: &mut HeaderMap) {
-  HOP_HEADERS.iter().for_each(|key| {
-    headers.remove(*key);
-  });
-}
-
-pub(super) fn extract_upgrade(headers: &HeaderMap) -> Option<String> {
-  if let Some(c) = headers.get(header::CONNECTION) {
-    if c
-      .to_str()
-      .unwrap_or("")
-      .split(',')
-      .into_iter()
-      .any(|w| w.trim().to_ascii_lowercase() == header::UPGRADE.as_str().to_ascii_lowercase())
-    {
-      if let Some(u) = headers.get(header::UPGRADE) {
-        if let Ok(m) = u.to_str() {
-          debug!("Upgrade in request header: {}", m);
-          return Some(m.to_owned());
-        }
-      }
-    }
-  }
-  None
-}