use std::{borrow::Cow, fmt, net::Ipv4Addr, net::Ipv6Addr};
use crate::chars::{self, NONE, REG_NAME, char_at, lowercase};
use crate::error::{ErrorKind, InvalidUrl};
use crate::{idna, quoting::unquote_with};
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum Host<'a> {
Domain(&'a str),
Ipv4(Ipv4Addr),
Ipv6(Ipv6Addr),
}
impl<'a> Host<'a> {
pub fn parse(src: &'a str) -> Result<Host<'a>, InvalidUrl> {
validate_host(src)?;
Ok(Host::classify(src))
}
pub(crate) fn classify(src: &'a str) -> Host<'a> {
if let Some(inner) = src.strip_prefix('[')
&& let Ok(addr) = ipv6(inner)
{
Host::Ipv6(addr)
} else if looks_like_ipv4(src)
&& let Ok(addr) = src.parse()
{
Host::Ipv4(addr)
} else {
Host::Domain(src)
}
}
pub fn to_unicode(&self) -> Cow<'a, str> {
match self {
Host::Domain(s) => idna::domain_to_unicode(s),
host => Cow::Owned(host.to_string()),
}
}
}
impl fmt::Display for Host<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Host::Domain(s) => f.write_str(s),
Host::Ipv4(addr) => fmt::Display::fmt(addr, f),
Host::Ipv6(addr) => write!(f, "[{addr}]"),
}
}
}
fn looks_like_ipv4(s: &str) -> bool {
!s.is_empty()
&& s.bytes().all(|b| b.is_ascii_digit() || b == b'.')
&& s.bytes().filter(|b| *b == b'.').count() == 3
}
fn ipv6(inner: &str) -> Result<Ipv6Addr, InvalidUrl> {
inner
.strip_suffix(']')
.and_then(|inner| inner.parse().ok())
.ok_or(InvalidUrl::at(ErrorKind::InvalidIpv6, 0))
}
fn check_ipv4(s: &str) -> Result<(), InvalidUrl> {
if looks_like_ipv4(s) && s.parse::<Ipv4Addr>().is_err() {
Err(InvalidUrl::at(ErrorKind::InvalidIpv4, 0))
} else {
Ok(())
}
}
pub(crate) fn validate_host(s: &str) -> Result<(), InvalidUrl> {
if let Some(inner) = s.strip_prefix('[') {
return ipv6(inner).map(|_| ());
}
chars::check(s, ®_NAME)?;
check_ipv4(s)
}
pub(crate) fn normalize_host(s: &str) -> Result<Cow<'_, str>, InvalidUrl> {
if let Some(inner) = s.strip_prefix('[') {
let canonical = format!("[{}]", ipv6(inner)?);
return Ok(if canonical == s {
Cow::Borrowed(s)
} else {
Cow::Owned(canonical)
});
}
let decoded = unquote_with::<false>(s, &NONE);
let host = if !decoded.is_ascii() {
Cow::Owned(
idna::domain_to_ascii(&decoded).ok_or(InvalidUrl::at(ErrorKind::InvalidHost, 0))?,
)
} else {
lowercase(decoded)
};
if let Some(i) = host.bytes().position(|b| !REG_NAME.contains(b)) {
return Err(if s.len() == host.len() && s.is_ascii() {
InvalidUrl::at(ErrorKind::InvalidChar(char_at(&host, i)), i)
} else {
InvalidUrl::at(ErrorKind::InvalidHost, 0)
});
}
check_ipv4(&host)?;
Ok(host)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn normalize() {
assert!(matches!(
normalize_host("a.com"),
Ok(Cow::Borrowed("a.com"))
));
assert_eq!(normalize_host("A.Com").unwrap(), "a.com");
assert_eq!(normalize_host("%41.com").unwrap(), "a.com");
assert_eq!(normalize_host("[0:0::1]").unwrap(), "[::1]");
assert_eq!(
normalize_host("a b").unwrap_err().kind(),
ErrorKind::InvalidChar(' ')
);
assert_eq!(
normalize_host("a%20b").unwrap_err().kind(),
ErrorKind::InvalidHost
);
assert_eq!(normalize_host("München.de").unwrap(), "xn--mnchen-3ya.de");
assert_eq!(
normalize_host("m%C3%BCnchen.de").unwrap(),
"xn--mnchen-3ya.de"
);
assert_eq!(
normalize_host("mü nchen.de").unwrap_err().kind(),
ErrorKind::InvalidHost
);
assert_eq!(
normalize_host("1.2.3.999").unwrap_err().kind(),
ErrorKind::InvalidIpv4
);
assert_eq!(
normalize_host("[::g]").unwrap_err().kind(),
ErrorKind::InvalidIpv6
);
}
#[test]
fn classify() {
assert_eq!(Host::classify("127.0.0.1"), Host::Ipv4(Ipv4Addr::LOCALHOST));
assert_eq!(Host::classify("1.2.3"), Host::Domain("1.2.3"));
assert_eq!(Host::Ipv6(Ipv6Addr::LOCALHOST).to_string(), "[::1]");
}
}