Handle file scheme type when setting host and hostname.

Author: o0Ignition0o

src/parser.rs

@@ -968,10 +968,32 @@ impl<'a> Parser<'a> {
         Ok((host, input))
     }
 
-    pub fn parse_file_host<'i>(
+    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)?;
+        Ok((host, remaining))
+    }
+
+    fn parse_file_host<'i>(
         &mut self,
         input: Input<'i>,
     ) -> ParseResult<(bool, HostInternal, Input<'i>)> {
+        let (has_host, host_str, remaining) = Parser::file_host(input)?;
+        let host = if host_str.is_empty() {
+            HostInternal::None
+        } else {
+            match Host::parse(&host_str)? {
+                Host::Domain(ref d) if d == "localhost" => HostInternal::None,
+                host => {
+                    write!(&mut self.serialization, "{}", host).unwrap();
+                    host.into()
+                }
+            }
+        };
+        Ok((has_host, host, remaining))
+    }
+
+    pub fn file_host<'i>(input: Input<'i>) -> ParseResult<(bool, String, Input<'i>)> {
         // Undo the Input abstraction here to avoid allocating in the common case
         // where the host part of the input does not contain any tab or newline
         let input_str = input.chars.as_str();
@@ -1000,20 +1022,9 @@ impl<'a> Parser<'a> {
             }
         }
         if is_windows_drive_letter(host_str) {
-            return Ok((false, HostInternal::None, input));
+            return Ok((false, "".to_string(), input));
         }
-        let host = if host_str.is_empty() {
-            HostInternal::None
-        } else {
-            match Host::parse(host_str)? {
-                Host::Domain(ref d) if d == "localhost" => HostInternal::None,
-                host => {
-                    write!(&mut self.serialization, "{}", host).unwrap();
-                    host.into()
-                }
-            }
-        };
-        Ok((true, host, remaining))
+        Ok((true, host_str.to_string(), remaining))
     }
 
     pub fn parse_port<P>(

src/quirks.rs

@@ -107,7 +107,12 @@ pub fn set_host(url: &mut Url, new_host: &str) -> Result<(), ()> {
     let opt_port;
     {
         let scheme = url.scheme();
-        let result = Parser::parse_host(Input::new(new_host), SchemeType::from(scheme));
+        let scheme_type = SchemeType::from(scheme);
+        let result = if scheme_type == SchemeType::File {
+            Parser::get_file_host(Input::new(new_host))
+        } else {
+            Parser::parse_host(Input::new(new_host), scheme_type)
+        };
         match result {
             Ok((h, remaining)) => {
                 host = h;
@@ -155,7 +160,12 @@ pub fn set_hostname(url: &mut Url, new_hostname: &str) -> Result<(), ()> {
     if url.cannot_be_a_base() {
         return Err(());
     }
-    let result = Parser::parse_host(Input::new(new_hostname), SchemeType::from(url.scheme()));
+    let scheme_type = SchemeType::from(url.scheme());
+    let result = if scheme_type == SchemeType::File {
+        Parser::get_file_host(Input::new(new_hostname))
+    } else {
+        Parser::parse_host(Input::new(new_hostname), scheme_type)
+    };
     if let Ok((host, _remaining)) = result {
         if let Host::Domain(h) = &host {
             if h.is_empty() {