Host checks.

Author: o0Ignition0o

src/parser.rs

@@ -79,6 +79,7 @@ macro_rules! simple_enum_error {
 
 simple_enum_error! {
     EmptyHost => "empty host",
+    InvalidAuthority => "invalid authority",
     IdnaError => "invalid international domain name",
     InvalidPort => "invalid port number",
     InvalidIpv4Address => "invalid IPv4 address",
@@ -840,11 +841,13 @@ impl<'a> Parser<'a> {
         self.serialization.push('/');
         self.serialization.push('/');
         // authority state
+        let before_authority = self.serialization.len();
         let (username_end, remaining) = self.parse_userinfo(input, scheme_type)?;
+        let has_authority = before_authority != self.serialization.len();
         // host state
         let host_start = to_u32(self.serialization.len())?;
         let (host_end, host, port, remaining) =
-            self.parse_host_and_port(remaining, scheme_end, scheme_type)?;
+            self.parse_host_and_port(remaining, scheme_end, scheme_type, has_authority)?;
         // path state
         let path_start = to_u32(self.serialization.len())?;
         let remaining = self.parse_path_start(scheme_type, &mut true, remaining);
@@ -888,7 +891,18 @@ impl<'a> Parser<'a> {
         }
         let (mut userinfo_char_count, remaining) = match last_at {
             None => return Ok((to_u32(self.serialization.len())?, input)),
-            Some((0, remaining)) => return Ok((to_u32(self.serialization.len())?, remaining)),
+            Some((0, remaining)) => {
+                // Otherwise, if one of the following is true
+                // c is the EOF code point, U+002F (/), U+003F (?), or U+0023 (#)
+                // url is special and c is U+005C (\)
+                // If @ flag is set and buffer is the empty string, validation error, return failure.
+                if let (Some(c), _) = remaining.split_first() {
+                    if c == '/' || c == '?' || c == '#' || scheme_type.is_special() && c == '\\' {
+                        return Err(ParseError::InvalidAuthority);
+                    }
+                }
+                return Ok((to_u32(self.serialization.len())?, remaining));
+            }
             Some(x) => x,
         };
 
@@ -930,18 +944,26 @@ impl<'a> Parser<'a> {
         input: Input<'i>,
         scheme_end: u32,
         scheme_type: SchemeType,
+        has_authority: bool,
     ) -> ParseResult<(u32, HostInternal, Option<u16>, Input<'i>)> {
         let (host, remaining) = Parser::parse_host(input, scheme_type)?;
         write!(&mut self.serialization, "{}", host).unwrap();
         let host_end = to_u32(self.serialization.len())?;
-        if remaining.starts_with(":") {
-            // Port with an empty host
-            if let Host::Domain(h) = &host {
-                if h.is_empty() {
+        if let Host::Domain(h) = &host {
+            if h.is_empty() {
+                // Port with an empty host
+                if remaining.starts_with(":") {
+                    return Err(ParseError::EmptyHost);
+                }
+                if scheme_type.is_special() {
+                    return Err(ParseError::EmptyHost);
+                }
+                if !scheme_type.is_special() && has_authority {
                     return Err(ParseError::EmptyHost);
                 }
             }
-        }
+        };
+
         let (port, remaining) = if let Some(remaining) = remaining.split_prefix(':') {
             let scheme = || default_port(&self.serialization[..scheme_end as usize]);
             Parser::parse_port(remaining, scheme, self.context)?
@@ -1010,7 +1032,10 @@ impl<'a> Parser<'a> {
 
     pub fn get_file_host<'i>(input: Input<'i>) -> ParseResult<(Host<String>, Input)> {
         let (_, host_str, remaining) = Parser::file_host(input)?;
-        let host = Host::parse(&host_str)?;
+        let host = match Host::parse(&host_str)? {
+            Host::Domain(ref d) if d == "localhost" => Host::Domain("".to_string()),
+            host => host,
+        };
         Ok((host, remaining))
     }
 

src/quirks.rs

@@ -177,8 +177,8 @@ pub fn set_hostname(url: &mut Url, new_hostname: &str) -> Result<(), ()> {
     if let Ok((host, _remaining)) = result {
         if let Host::Domain(h) = &host {
             if h.is_empty() {
-                // Empty host on special url
-                if SchemeType::from(url.scheme()).is_special()
+                // Empty host on special not file url
+                if SchemeType::from(url.scheme()) == SchemeType::SpecialNotFile
                     // Port with an empty host
                     ||!port(&url).is_empty()
                     // Empty host with includes credentials