Check authority when parsing the host.

Author: o0Ignition0o

src/parser.rs

@@ -822,11 +822,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);
@@ -912,18 +914,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)?