Source code
Revision control
Copy as Markdown
Other Tools
// Copyright 2013-2016 The rust-url developers.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::error::Error;
use std::fmt::{self, Formatter, Write};
use std::str;
use crate::host::{Host, HostInternal};
use crate::Url;
use form_urlencoded::EncodingOverride;
use percent_encoding::{percent_encode, utf8_percent_encode, AsciiSet, CONTROLS};
const FRAGMENT: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');
const PATH: &AsciiSet = &FRAGMENT.add(b'#').add(b'?').add(b'{').add(b'}');
pub(crate) const USERINFO: &AsciiSet = &PATH
.add(b'/')
.add(b':')
.add(b';')
.add(b'=')
.add(b'@')
.add(b'[')
.add(b'\\')
.add(b']')
.add(b'^')
.add(b'|');
pub(crate) const PATH_SEGMENT: &AsciiSet = &PATH.add(b'/').add(b'%');
// The backslash (\) character is treated as a path separator in special URLs
// so it needs to be additionally escaped in that case.
pub(crate) const SPECIAL_PATH_SEGMENT: &AsciiSet = &PATH_SEGMENT.add(b'\\');
const QUERY: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'#').add(b'<').add(b'>');
const SPECIAL_QUERY: &AsciiSet = &QUERY.add(b'\'');
pub type ParseResult<T> = Result<T, ParseError>;
macro_rules! simple_enum_error {
($($name: ident => $description: expr,)+) => {
/// Errors that can occur during parsing.
///
/// This may be extended in the future so exhaustive matching is
/// discouraged with an unused variant.
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
#[non_exhaustive]
pub enum ParseError {
$(
$name,
)+
}
impl fmt::Display for ParseError {
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
match *self {
$(
ParseError::$name => fmt.write_str($description),
)+
}
}
}
}
}
impl Error for ParseError {}
simple_enum_error! {
EmptyHost => "empty host",
IdnaError => "invalid international domain name",
InvalidPort => "invalid port number",
InvalidIpv4Address => "invalid IPv4 address",
InvalidIpv6Address => "invalid IPv6 address",
InvalidDomainCharacter => "invalid domain character",
RelativeUrlWithoutBase => "relative URL without a base",
RelativeUrlWithCannotBeABaseBase => "relative URL with a cannot-be-a-base base",
SetHostOnCannotBeABaseUrl => "a cannot-be-a-base URL doesn’t have a host to set",
Overflow => "URLs more than 4 GB are not supported",
}
impl From<::idna::Errors> for ParseError {
fn from(_: ::idna::Errors) -> ParseError {
ParseError::IdnaError
}
}
macro_rules! syntax_violation_enum {
($($name: ident => $description: expr,)+) => {
/// Non-fatal syntax violations that can occur during parsing.
///
/// This may be extended in the future so exhaustive matching is
/// discouraged with an unused variant.
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
#[non_exhaustive]
pub enum SyntaxViolation {
$(
$name,
)+
}
impl SyntaxViolation {
pub fn description(&self) -> &'static str {
match *self {
$(
SyntaxViolation::$name => $description,
)+
}
}
}
}
}
syntax_violation_enum! {
Backslash => "backslash",
C0SpaceIgnored =>
"leading or trailing control or space character are ignored in URLs",
EmbeddedCredentials =>
"embedding authentication information (username or password) \
in an URL is not recommended",
ExpectedDoubleSlash => "expected //",
ExpectedFileDoubleSlash => "expected // after file:",
FileWithHostAndWindowsDrive => "file: with host and Windows drive letter",
NonUrlCodePoint => "non-URL code point",
NullInFragment => "NULL characters are ignored in URL fragment identifiers",
PercentDecode => "expected 2 hex digits after %",
TabOrNewlineIgnored => "tabs or newlines are ignored in URLs",
UnencodedAtSign => "unencoded @ sign in username or password",
}
impl fmt::Display for SyntaxViolation {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(self.description(), f)
}
}
#[derive(Copy, Clone, PartialEq, Eq)]
pub enum SchemeType {
File,
SpecialNotFile,
NotSpecial,
}
impl SchemeType {
pub fn is_special(&self) -> bool {
!matches!(*self, SchemeType::NotSpecial)
}
pub fn is_file(&self) -> bool {
matches!(*self, SchemeType::File)
}
}
impl<T: AsRef<str>> From<T> for SchemeType {
fn from(s: T) -> Self {
match s.as_ref() {
"http" | "https" | "ws" | "wss" | "ftp" => SchemeType::SpecialNotFile,
"file" => SchemeType::File,
_ => SchemeType::NotSpecial,
}
}
}
pub fn default_port(scheme: &str) -> Option<u16> {
match scheme {
"http" | "ws" => Some(80),
"https" | "wss" => Some(443),
"ftp" => Some(21),
_ => None,
}
}
#[derive(Clone, Debug)]
pub struct Input<'i> {
chars: str::Chars<'i>,
}
impl<'i> Input<'i> {
pub fn new_no_trim(input: &'i str) -> Self {
Input {
chars: input.chars(),
}
}
pub fn new_trim_tab_and_newlines(
original_input: &'i str,
vfn: Option<&dyn Fn(SyntaxViolation)>,
) -> Self {
let input = original_input.trim_matches(ascii_tab_or_new_line);
if let Some(vfn) = vfn {
if input.len() < original_input.len() {
vfn(SyntaxViolation::C0SpaceIgnored)
}
if input.chars().any(|c| matches!(c, '\t' | '\n' | '\r')) {
vfn(SyntaxViolation::TabOrNewlineIgnored)
}
}
Input {
chars: input.chars(),
}
}
pub fn new_trim_c0_control_and_space(
original_input: &'i str,
vfn: Option<&dyn Fn(SyntaxViolation)>,
) -> Self {
let input = original_input.trim_matches(c0_control_or_space);
if let Some(vfn) = vfn {
if input.len() < original_input.len() {
vfn(SyntaxViolation::C0SpaceIgnored)
}
if input.chars().any(|c| matches!(c, '\t' | '\n' | '\r')) {
vfn(SyntaxViolation::TabOrNewlineIgnored)
}
}
Input {
chars: input.chars(),
}
}
#[inline]
pub fn is_empty(&self) -> bool {
self.clone().next().is_none()
}
#[inline]
fn starts_with<P: Pattern>(&self, p: P) -> bool {
p.split_prefix(&mut self.clone())
}
#[inline]
pub fn split_prefix<P: Pattern>(&self, p: P) -> Option<Self> {
let mut remaining = self.clone();
if p.split_prefix(&mut remaining) {
Some(remaining)
} else {
None
}
}
#[inline]
fn split_first(&self) -> (Option<char>, Self) {
let mut remaining = self.clone();
(remaining.next(), remaining)
}
#[inline]
fn count_matching<F: Fn(char) -> bool>(&self, f: F) -> (u32, Self) {
let mut count = 0;
let mut remaining = self.clone();
loop {
let mut input = remaining.clone();
if matches!(input.next(), Some(c) if f(c)) {
remaining = input;
count += 1;
} else {
return (count, remaining);
}
}
}
#[inline]
fn next_utf8(&mut self) -> Option<(char, &'i str)> {
loop {
let utf8 = self.chars.as_str();
match self.chars.next() {
Some(c) => {
if !matches!(c, '\t' | '\n' | '\r') {
return Some((c, &utf8[..c.len_utf8()]));
}
}
None => return None,
}
}
}
}
pub trait Pattern {
fn split_prefix(self, input: &mut Input) -> bool;
}
impl Pattern for char {
fn split_prefix(self, input: &mut Input) -> bool {
input.next() == Some(self)
}
}
impl<'a> Pattern for &'a str {
fn split_prefix(self, input: &mut Input) -> bool {
for c in self.chars() {
if input.next() != Some(c) {
return false;
}
}
true
}
}
impl<F: FnMut(char) -> bool> Pattern for F {
fn split_prefix(self, input: &mut Input) -> bool {
input.next().map_or(false, self)
}
}
impl<'i> Iterator for Input<'i> {
type Item = char;
fn next(&mut self) -> Option<char> {
self.chars
.by_ref()
.find(|&c| !matches!(c, '\t' | '\n' | '\r'))
}
}
pub struct Parser<'a> {
pub serialization: String,
pub base_url: Option<&'a Url>,
pub query_encoding_override: EncodingOverride<'a>,
pub violation_fn: Option<&'a dyn Fn(SyntaxViolation)>,
pub context: Context,
}
#[derive(PartialEq, Eq, Copy, Clone)]
pub enum Context {
UrlParser,
Setter,
PathSegmentSetter,
}
impl<'a> Parser<'a> {
fn log_violation(&self, v: SyntaxViolation) {
if let Some(f) = self.violation_fn {
f(v)
}
}
fn log_violation_if(&self, v: SyntaxViolation, test: impl FnOnce() -> bool) {
if let Some(f) = self.violation_fn {
if test() {
f(v)
}
}
}
pub fn for_setter(serialization: String) -> Parser<'a> {
Parser {
serialization,
base_url: None,
query_encoding_override: None,
violation_fn: None,
context: Context::Setter,
}
}
pub fn parse_url(mut self, input: &str) -> ParseResult<Url> {
let input = Input::new_trim_c0_control_and_space(input, self.violation_fn);
if let Ok(remaining) = self.parse_scheme(input.clone()) {
return self.parse_with_scheme(remaining);
}
// No-scheme state
if let Some(base_url) = self.base_url {
if input.starts_with('#') {
self.fragment_only(base_url, input)
} else if base_url.cannot_be_a_base() {
Err(ParseError::RelativeUrlWithCannotBeABaseBase)
} else {
let scheme_type = SchemeType::from(base_url.scheme());
if scheme_type.is_file() {
self.parse_file(input, scheme_type, Some(base_url))
} else {
self.parse_relative(input, scheme_type, base_url)
}
}
} else {
Err(ParseError::RelativeUrlWithoutBase)
}
}
pub fn parse_scheme<'i>(&mut self, mut input: Input<'i>) -> Result<Input<'i>, ()> {
if input.is_empty() || !input.starts_with(ascii_alpha) {
return Err(());
}
debug_assert!(self.serialization.is_empty());
while let Some(c) = input.next() {
match c {
'a'..='z' | 'A'..='Z' | '0'..='9' | '+' | '-' | '.' => {
self.serialization.push(c.to_ascii_lowercase())
}
':' => return Ok(input),
_ => {
self.serialization.clear();
return Err(());
}
}
}
// EOF before ':'
if self.context == Context::Setter {
Ok(input)
} else {
self.serialization.clear();
Err(())
}
}
fn parse_with_scheme(mut self, input: Input<'_>) -> ParseResult<Url> {
use crate::SyntaxViolation::{ExpectedDoubleSlash, ExpectedFileDoubleSlash};
let scheme_end = to_u32(self.serialization.len())?;
let scheme_type = SchemeType::from(&self.serialization);
self.serialization.push(':');
match scheme_type {
SchemeType::File => {
self.log_violation_if(ExpectedFileDoubleSlash, || !input.starts_with("//"));
let base_file_url = self.base_url.and_then(|base| {
if base.scheme() == "file" {
Some(base)
} else {
None
}
});
self.serialization.clear();
self.parse_file(input, scheme_type, base_file_url)
}
SchemeType::SpecialNotFile => {
// special relative or authority state
let (slashes_count, remaining) = input.count_matching(|c| matches!(c, '/' | '\\'));
if let Some(base_url) = self.base_url {
if slashes_count < 2
&& base_url.scheme() == &self.serialization[..scheme_end as usize]
{
// "Cannot-be-a-base" URLs only happen with "not special" schemes.
debug_assert!(!base_url.cannot_be_a_base());
self.serialization.clear();
return self.parse_relative(input, scheme_type, base_url);
}
}
// special authority slashes state
self.log_violation_if(ExpectedDoubleSlash, || {
input
.clone()
.take_while(|&c| matches!(c, '/' | '\\'))
.collect::<String>()
!= "//"
});
self.after_double_slash(remaining, scheme_type, scheme_end)
}
SchemeType::NotSpecial => self.parse_non_special(input, scheme_type, scheme_end),
}
}
/// Scheme other than file, http, https, ws, ws, ftp.
fn parse_non_special(
mut self,
input: Input<'_>,
scheme_type: SchemeType,
scheme_end: u32,
) -> ParseResult<Url> {
// path or authority state (
if let Some(input) = input.split_prefix("//") {
return self.after_double_slash(input, scheme_type, scheme_end);
}
// Anarchist URL (no authority)
let path_start = to_u32(self.serialization.len())?;
let username_end = path_start;
let host_start = path_start;
let host_end = path_start;
let host = HostInternal::None;
let port = None;
let remaining = if let Some(input) = input.split_prefix('/') {
self.serialization.push('/');
self.parse_path(scheme_type, &mut false, path_start as usize, input)
} else {
self.parse_cannot_be_a_base_path(input)
};
self.with_query_and_fragment(
scheme_type,
scheme_end,
username_end,
host_start,
host_end,
host,
port,
path_start,
remaining,
)
}
fn parse_file(
mut self,
input: Input<'_>,
scheme_type: SchemeType,
base_file_url: Option<&Url>,
) -> ParseResult<Url> {
use crate::SyntaxViolation::Backslash;
// file state
debug_assert!(self.serialization.is_empty());
let (first_char, input_after_first_char) = input.split_first();
if matches!(first_char, Some('/') | Some('\\')) {
self.log_violation_if(SyntaxViolation::Backslash, || first_char == Some('\\'));
// file slash state
let (next_char, input_after_next_char) = input_after_first_char.split_first();
if matches!(next_char, Some('/') | Some('\\')) {
self.log_violation_if(Backslash, || next_char == Some('\\'));
// file host state
self.serialization.push_str("file://");
let scheme_end = "file".len() as u32;
let host_start = "file://".len() as u32;
let (path_start, mut host, remaining) =
self.parse_file_host(input_after_next_char)?;
let mut host_end = to_u32(self.serialization.len())?;
let mut has_host = !matches!(host, HostInternal::None);
let remaining = if path_start {
self.parse_path_start(SchemeType::File, &mut has_host, remaining)
} else {
let path_start = self.serialization.len();
self.serialization.push('/');
self.parse_path(SchemeType::File, &mut has_host, path_start, remaining)
};
// For file URLs that have a host and whose path starts
// with the windows drive letter we just remove the host.
if !has_host {
self.serialization
.drain(host_start as usize..host_end as usize);
host_end = host_start;
host = HostInternal::None;
}
let (query_start, fragment_start) =
self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;
return Ok(Url {
serialization: self.serialization,
scheme_end,
username_end: host_start,
host_start,
host_end,
host,
port: None,
path_start: host_end,
query_start,
fragment_start,
});
} else {
self.serialization.push_str("file://");
let scheme_end = "file".len() as u32;
let host_start = "file://".len();
let mut host_end = host_start;
let mut host = HostInternal::None;
if !starts_with_windows_drive_letter_segment(&input_after_first_char) {
if let Some(base_url) = base_file_url {
let first_segment = base_url.path_segments().unwrap().next().unwrap();
if is_normalized_windows_drive_letter(first_segment) {
self.serialization.push('/');
self.serialization.push_str(first_segment);
} else if let Some(host_str) = base_url.host_str() {
self.serialization.push_str(host_str);
host_end = self.serialization.len();
host = base_url.host;
}
}
}
// If c is the EOF code point, U+002F (/), U+005C (\), U+003F (?), or U+0023 (#), then decrease pointer by one
let parse_path_input = if let Some(c) = first_char {
if c == '/' || c == '\\' || c == '?' || c == '#' {
input
} else {
input_after_first_char
}
} else {
input_after_first_char
};
let remaining =
self.parse_path(SchemeType::File, &mut false, host_end, parse_path_input);
let host_start = host_start as u32;
let (query_start, fragment_start) =
self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;
let host_end = host_end as u32;
return Ok(Url {
serialization: self.serialization,
scheme_end,
username_end: host_start,
host_start,
host_end,
host,
port: None,
path_start: host_end,
query_start,
fragment_start,
});
}
}
if let Some(base_url) = base_file_url {
match first_char {
None => {
// Copy everything except the fragment
let before_fragment = match base_url.fragment_start {
Some(i) => &base_url.serialization[..i as usize],
None => &*base_url.serialization,
};
self.serialization.push_str(before_fragment);
Ok(Url {
serialization: self.serialization,
fragment_start: None,
..*base_url
})
}
Some('?') => {
// Copy everything up to the query string
let before_query = match (base_url.query_start, base_url.fragment_start) {
(None, None) => &*base_url.serialization,
(Some(i), _) | (None, Some(i)) => base_url.slice(..i),
};
self.serialization.push_str(before_query);
let (query_start, fragment_start) =
self.parse_query_and_fragment(scheme_type, base_url.scheme_end, input)?;
Ok(Url {
serialization: self.serialization,
query_start,
fragment_start,
..*base_url
})
}
Some('#') => self.fragment_only(base_url, input),
_ => {
if !starts_with_windows_drive_letter_segment(&input) {
let before_query = match (base_url.query_start, base_url.fragment_start) {
(None, None) => &*base_url.serialization,
(Some(i), _) | (None, Some(i)) => base_url.slice(..i),
};
self.serialization.push_str(before_query);
self.shorten_path(SchemeType::File, base_url.path_start as usize);
let remaining = self.parse_path(
SchemeType::File,
&mut true,
base_url.path_start as usize,
input,
);
self.with_query_and_fragment(
SchemeType::File,
base_url.scheme_end,
base_url.username_end,
base_url.host_start,
base_url.host_end,
base_url.host,
base_url.port,
base_url.path_start,
remaining,
)
} else {
let scheme_end = "file".len() as u32;
let path_start = "file://".len();
let remaining =
self.parse_path(SchemeType::File, &mut false, path_start, input);
let (query_start, fragment_start) =
self.parse_query_and_fragment(SchemeType::File, scheme_end, remaining)?;
let path_start = path_start as u32;
Ok(Url {
serialization: self.serialization,
scheme_end,
username_end: path_start,
host_start: path_start,
host_end: path_start,
host: HostInternal::None,
port: None,
path_start,
query_start,
fragment_start,
})
}
}
}
} else {
let scheme_end = "file".len() as u32;
let path_start = "file://".len();
let remaining = self.parse_path(SchemeType::File, &mut false, path_start, input);
let (query_start, fragment_start) =
self.parse_query_and_fragment(SchemeType::File, scheme_end, remaining)?;
let path_start = path_start as u32;
Ok(Url {
serialization: self.serialization,
scheme_end,
username_end: path_start,
host_start: path_start,
host_end: path_start,
host: HostInternal::None,
port: None,
path_start,
query_start,
fragment_start,
})
}
}
fn parse_relative(
mut self,
input: Input<'_>,
scheme_type: SchemeType,
base_url: &Url,
) -> ParseResult<Url> {
// relative state
debug_assert!(self.serialization.is_empty());
let (first_char, input_after_first_char) = input.split_first();
match first_char {
None => {
// Copy everything except the fragment
let before_fragment = match base_url.fragment_start {
Some(i) => &base_url.serialization[..i as usize],
None => &*base_url.serialization,
};
self.serialization.push_str(before_fragment);
Ok(Url {
serialization: self.serialization,
fragment_start: None,
..*base_url
})
}
Some('?') => {
// Copy everything up to the query string
let before_query = match (base_url.query_start, base_url.fragment_start) {
(None, None) => &*base_url.serialization,
(Some(i), _) | (None, Some(i)) => base_url.slice(..i),
};
self.serialization.push_str(before_query);
let (query_start, fragment_start) =
self.parse_query_and_fragment(scheme_type, base_url.scheme_end, input)?;
Ok(Url {
serialization: self.serialization,
query_start,
fragment_start,
..*base_url
})
}
Some('#') => self.fragment_only(base_url, input),
Some('/') | Some('\\') => {
let (slashes_count, remaining) = input.count_matching(|c| matches!(c, '/' | '\\'));
if slashes_count >= 2 {
self.log_violation_if(SyntaxViolation::ExpectedDoubleSlash, || {
input
.clone()
.take_while(|&c| matches!(c, '/' | '\\'))
.collect::<String>()
!= "//"
});
let scheme_end = base_url.scheme_end;
debug_assert!(base_url.byte_at(scheme_end) == b':');
self.serialization
.push_str(base_url.slice(..scheme_end + 1));
if let Some(after_prefix) = input.split_prefix("//") {
return self.after_double_slash(after_prefix, scheme_type, scheme_end);
}
return self.after_double_slash(remaining, scheme_type, scheme_end);
}
let path_start = base_url.path_start;
self.serialization.push_str(base_url.slice(..path_start));
self.serialization.push('/');
let remaining = self.parse_path(
scheme_type,
&mut true,
path_start as usize,
input_after_first_char,
);
self.with_query_and_fragment(
scheme_type,
base_url.scheme_end,
base_url.username_end,
base_url.host_start,
base_url.host_end,
base_url.host,
base_url.port,
base_url.path_start,
remaining,
)
}
_ => {
let before_query = match (base_url.query_start, base_url.fragment_start) {
(None, None) => &*base_url.serialization,
(Some(i), _) | (None, Some(i)) => base_url.slice(..i),
};
self.serialization.push_str(before_query);
// FIXME spec says just "remove last entry", not the "pop" algorithm
self.pop_path(scheme_type, base_url.path_start as usize);
// A special url always has a path.
// A path always starts with '/'
if self.serialization.len() == base_url.path_start as usize
&& (SchemeType::from(base_url.scheme()).is_special() || !input.is_empty())
{
self.serialization.push('/');
}
let remaining = match input.split_first() {
(Some('/'), remaining) => self.parse_path(
scheme_type,
&mut true,
base_url.path_start as usize,
remaining,
),
_ => {
self.parse_path(scheme_type, &mut true, base_url.path_start as usize, input)
}
};
self.with_query_and_fragment(
scheme_type,
base_url.scheme_end,
base_url.username_end,
base_url.host_start,
base_url.host_end,
base_url.host,
base_url.port,
base_url.path_start,
remaining,
)
}
}
}
fn after_double_slash(
mut self,
input: Input<'_>,
scheme_type: SchemeType,
scheme_end: u32,
) -> ParseResult<Url> {
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)?;
if host == HostInternal::None && has_authority {
return Err(ParseError::EmptyHost);
}
// path state
let path_start = to_u32(self.serialization.len())?;
let remaining = self.parse_path_start(scheme_type, &mut true, remaining);
self.with_query_and_fragment(
scheme_type,
scheme_end,
username_end,
host_start,
host_end,
host,
port,
path_start,
remaining,
)
}
/// Return (username_end, remaining)
fn parse_userinfo<'i>(
&mut self,
mut input: Input<'i>,
scheme_type: SchemeType,
) -> ParseResult<(u32, Input<'i>)> {
let mut last_at = None;
let mut remaining = input.clone();
let mut char_count = 0;
while let Some(c) = remaining.next() {
match c {
'@' => {
if last_at.is_some() {
self.log_violation(SyntaxViolation::UnencodedAtSign)
} else {
self.log_violation(SyntaxViolation::EmbeddedCredentials)
}
last_at = Some((char_count, remaining.clone()))
}
'/' | '?' | '#' => break,
'\\' if scheme_type.is_special() => break,
_ => (),
}
char_count += 1;
}
let (mut userinfo_char_count, remaining) = match last_at {
None => return Ok((to_u32(self.serialization.len())?, input)),
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::EmptyHost);
}
}
return Ok((to_u32(self.serialization.len())?, remaining));
}
Some(x) => x,
};
let mut username_end = None;
let mut has_password = false;
let mut has_username = false;
while userinfo_char_count > 0 {
let (c, utf8_c) = input.next_utf8().unwrap();
userinfo_char_count -= 1;
if c == ':' && username_end.is_none() {
// Start parsing password
username_end = Some(to_u32(self.serialization.len())?);
// We don't add a colon if the password is empty
if userinfo_char_count > 0 {
self.serialization.push(':');
has_password = true;
}
} else {
if !has_password {
has_username = true;
}
self.check_url_code_point(c, &input);
self.serialization
.extend(utf8_percent_encode(utf8_c, USERINFO));
}
}
let username_end = match username_end {
Some(i) => i,
None => to_u32(self.serialization.len())?,
};
if has_username || has_password {
self.serialization.push('@');
}
Ok((username_end, remaining))
}
fn parse_host_and_port<'i>(
&mut self,
input: Input<'i>,
scheme_end: u32,
scheme_type: SchemeType,
) -> 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 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);
}
}
};
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)?
} else {
(None, remaining)
};
if let Some(port) = port {
write!(&mut self.serialization, ":{}", port).unwrap()
}
Ok((host_end, host.into(), port, remaining))
}
pub fn parse_host(
mut input: Input<'_>,
scheme_type: SchemeType,
) -> ParseResult<(Host<String>, Input<'_>)> {
if scheme_type.is_file() {
return Parser::get_file_host(input);
}
// 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();
let mut inside_square_brackets = false;
let mut has_ignored_chars = false;
let mut non_ignored_chars = 0;
let mut bytes = 0;
for c in input_str.chars() {
match c {
':' if !inside_square_brackets => break,
'\\' if scheme_type.is_special() => break,
'/' | '?' | '#' => break,
'\t' | '\n' | '\r' => {
has_ignored_chars = true;
}
'[' => {
inside_square_brackets = true;
non_ignored_chars += 1
}
']' => {
inside_square_brackets = false;
non_ignored_chars += 1
}
_ => non_ignored_chars += 1,
}
bytes += c.len_utf8();
}
let replaced: String;
let host_str;
{
let host_input = input.by_ref().take(non_ignored_chars);
if has_ignored_chars {
replaced = host_input.collect();
host_str = &*replaced
} else {
for _ in host_input {}
host_str = &input_str[..bytes]
}
}
if scheme_type == SchemeType::SpecialNotFile && host_str.is_empty() {
return Err(ParseError::EmptyHost);
}
if !scheme_type.is_special() {
let host = Host::parse_opaque(host_str)?;
return Ok((host, input));
}
let host = Host::parse(host_str)?;
Ok((host, input))
}
fn get_file_host(input: Input<'_>) -> ParseResult<(Host<String>, Input<'_>)> {
let (_, host_str, remaining) = Parser::file_host(input)?;
let host = match Host::parse(&host_str)? {
Host::Domain(ref d) if d == "localhost" => Host::Domain("".to_string()),
host => host,
};
Ok((host, remaining))
}
fn parse_file_host<'i>(
&mut self,
input: Input<'i>,
) -> ParseResult<(bool, HostInternal, Input<'i>)> {
let has_host;
let (_, host_str, remaining) = Parser::file_host(input)?;
let host = if host_str.is_empty() {
has_host = false;
HostInternal::None
} else {
match Host::parse(&host_str)? {
Host::Domain(ref d) if d == "localhost" => {
has_host = false;
HostInternal::None
}
host => {
write!(&mut self.serialization, "{}", host).unwrap();
has_host = true;
host.into()
}
}
};
Ok((has_host, host, remaining))
}
pub fn file_host(input: Input) -> ParseResult<(bool, String, Input)> {
// 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();
let mut has_ignored_chars = false;
let mut non_ignored_chars = 0;
let mut bytes = 0;
for c in input_str.chars() {
match c {
'/' | '\\' | '?' | '#' => break,
'\t' | '\n' | '\r' => has_ignored_chars = true,
_ => non_ignored_chars += 1,
}
bytes += c.len_utf8();
}
let replaced: String;
let host_str;
let mut remaining = input.clone();
{
let host_input = remaining.by_ref().take(non_ignored_chars);
if has_ignored_chars {
replaced = host_input.collect();
host_str = &*replaced
} else {
for _ in host_input {}
host_str = &input_str[..bytes]
}
}
if is_windows_drive_letter(host_str) {
return Ok((false, "".to_string(), input));
}
Ok((true, host_str.to_string(), remaining))
}
pub fn parse_port<P>(
mut input: Input<'_>,
default_port: P,
context: Context,
) -> ParseResult<(Option<u16>, Input<'_>)>
where
P: Fn() -> Option<u16>,
{
let mut port: u32 = 0;
let mut has_any_digit = false;
while let (Some(c), remaining) = input.split_first() {
if let Some(digit) = c.to_digit(10) {
port = port * 10 + digit;
if port > ::std::u16::MAX as u32 {
return Err(ParseError::InvalidPort);
}
has_any_digit = true;
} else if context == Context::UrlParser && !matches!(c, '/' | '\\' | '?' | '#') {
return Err(ParseError::InvalidPort);
} else {
break;
}
input = remaining;
}
let mut opt_port = Some(port as u16);
if !has_any_digit || opt_port == default_port() {
opt_port = None;
}
Ok((opt_port, input))
}
pub fn parse_path_start<'i>(
&mut self,
scheme_type: SchemeType,
has_host: &mut bool,
input: Input<'i>,
) -> Input<'i> {
let path_start = self.serialization.len();
let (maybe_c, remaining) = input.split_first();
// If url is special, then:
if scheme_type.is_special() {
if maybe_c == Some('\\') {
// If c is U+005C (\), validation error.
self.log_violation(SyntaxViolation::Backslash);
}
// A special URL always has a non-empty path.
if !self.serialization.ends_with('/') {
self.serialization.push('/');
// We have already made sure the forward slash is present.
if maybe_c == Some('/') || maybe_c == Some('\\') {
return self.parse_path(scheme_type, has_host, path_start, remaining);
}
}
return self.parse_path(scheme_type, has_host, path_start, input);
} else if maybe_c == Some('?') || maybe_c == Some('#') {
// Otherwise, if state override is not given and c is U+003F (?),
// set url’s query to the empty string and state to query state.
// Otherwise, if state override is not given and c is U+0023 (#),
// set url’s fragment to the empty string and state to fragment state.
// The query and path states will be handled by the caller.
return input;
}
if maybe_c.is_some() && maybe_c != Some('/') {
self.serialization.push('/');
}
// Otherwise, if c is not the EOF code point:
self.parse_path(scheme_type, has_host, path_start, input)
}
pub fn parse_path<'i>(
&mut self,
scheme_type: SchemeType,
has_host: &mut bool,
path_start: usize,
mut input: Input<'i>,
) -> Input<'i> {
// Relative path state
loop {
let mut segment_start = self.serialization.len();
let mut ends_with_slash = false;
loop {
let input_before_c = input.clone();
let (c, utf8_c) = if let Some(x) = input.next_utf8() {
x
} else {
break;
};
match c {
'/' if self.context != Context::PathSegmentSetter => {
self.serialization.push(c);
ends_with_slash = true;
break;
}
'\\' if self.context != Context::PathSegmentSetter
&& scheme_type.is_special() =>
{
self.log_violation(SyntaxViolation::Backslash);
self.serialization.push('/');
ends_with_slash = true;
break;
}
'?' | '#' if self.context == Context::UrlParser => {
input = input_before_c;
break;
}
_ => {
self.check_url_code_point(c, &input);
if scheme_type.is_file()
&& self.serialization.len() > path_start
&& is_normalized_windows_drive_letter(
&self.serialization[path_start + 1..],
)
{
self.serialization.push('/');
segment_start += 1;
}
if self.context == Context::PathSegmentSetter {
if scheme_type.is_special() {
self.serialization
.extend(utf8_percent_encode(utf8_c, SPECIAL_PATH_SEGMENT));
} else {
self.serialization
.extend(utf8_percent_encode(utf8_c, PATH_SEGMENT));
}
} else {
self.serialization.extend(utf8_percent_encode(utf8_c, PATH));
}
}
}
}
let segment_before_slash = if ends_with_slash {
&self.serialization[segment_start..self.serialization.len() - 1]
} else {
&self.serialization[segment_start..self.serialization.len()]
};
match segment_before_slash {
// If buffer is a double-dot path segment, shorten url’s path,
".." | "%2e%2e" | "%2e%2E" | "%2E%2e" | "%2E%2E" | "%2e." | "%2E." | ".%2e"
| ".%2E" => {
debug_assert!(self.serialization.as_bytes()[segment_start - 1] == b'/');
self.serialization.truncate(segment_start);
if self.serialization.ends_with('/')
&& Parser::last_slash_can_be_removed(&self.serialization, path_start)
{
self.serialization.pop();
}
self.shorten_path(scheme_type, path_start);
// and then if neither c is U+002F (/), nor url is special and c is U+005C (\), append the empty string to url’s path.
if ends_with_slash && !self.serialization.ends_with('/') {
self.serialization.push('/');
}
}
// Otherwise, if buffer is a single-dot path segment and if neither c is U+002F (/),
// nor url is special and c is U+005C (\), append the empty string to url’s path.
"." | "%2e" | "%2E" => {
self.serialization.truncate(segment_start);
if !self.serialization.ends_with('/') {
self.serialization.push('/');
}
}
_ => {
// If url’s scheme is "file", url’s path is empty, and buffer is a Windows drive letter, then
if scheme_type.is_file()
&& segment_start == path_start + 1
&& is_windows_drive_letter(segment_before_slash)
{
// Replace the second code point in buffer with U+003A (:).
if let Some(c) = segment_before_slash.chars().next() {
self.serialization.truncate(segment_start);
self.serialization.push(c);
self.serialization.push(':');
if ends_with_slash {
self.serialization.push('/');
}
}
// If url’s host is neither the empty string nor null,
// validation error, set url’s host to the empty string.
if *has_host {
self.log_violation(SyntaxViolation::FileWithHostAndWindowsDrive);
*has_host = false; // FIXME account for this in callers
}
}
}
}
if !ends_with_slash {
break;
}
}
if scheme_type.is_file() {
// while url’s path’s size is greater than 1
// and url’s path[0] is the empty string,
// validation error, remove the first item from url’s path.
//FIXME: log violation
let path = self.serialization.split_off(path_start);
self.serialization.push('/');
self.serialization.push_str(path.trim_start_matches('/'));
}
input
}
fn last_slash_can_be_removed(serialization: &str, path_start: usize) -> bool {
let url_before_segment = &serialization[..serialization.len() - 1];
if let Some(segment_before_start) = url_before_segment.rfind('/') {
// Do not remove the root slash
segment_before_start >= path_start
// Or a windows drive letter slash
&& !path_starts_with_windows_drive_letter(&serialization[segment_before_start..])
} else {
false
}
}
fn shorten_path(&mut self, scheme_type: SchemeType, path_start: usize) {
// If path is empty, then return.
if self.serialization.len() == path_start {
return;
}
// If url’s scheme is "file", path’s size is 1, and path[0] is a normalized Windows drive letter, then return.
if scheme_type.is_file()
&& is_normalized_windows_drive_letter(&self.serialization[path_start..])
{
return;
}
// Remove path’s last item.
self.pop_path(scheme_type, path_start);
}
fn pop_path(&mut self, scheme_type: SchemeType, path_start: usize) {
if self.serialization.len() > path_start {
let slash_position = self.serialization[path_start..].rfind('/').unwrap();
// + 1 since rfind returns the position before the slash.
let segment_start = path_start + slash_position + 1;
// Don’t pop a Windows drive letter
if !(scheme_type.is_file()
&& is_normalized_windows_drive_letter(&self.serialization[segment_start..]))
{
self.serialization.truncate(segment_start);
}
}
}
pub fn parse_cannot_be_a_base_path<'i>(&mut self, mut input: Input<'i>) -> Input<'i> {
loop {
let input_before_c = input.clone();
match input.next_utf8() {
Some(('?', _)) | Some(('#', _)) if self.context == Context::UrlParser => {
return input_before_c
}
Some((c, utf8_c)) => {
self.check_url_code_point(c, &input);
self.serialization
.extend(utf8_percent_encode(utf8_c, CONTROLS));
}
None => return input,
}
}
}
#[allow(clippy::too_many_arguments)]
fn with_query_and_fragment(
mut self,
scheme_type: SchemeType,
scheme_end: u32,
username_end: u32,
host_start: u32,
host_end: u32,
host: HostInternal,
port: Option<u16>,
mut path_start: u32,
remaining: Input<'_>,
) -> ParseResult<Url> {
// Special case for anarchist URL's with a leading empty path segment
// This prevents web+demo:/.//not-a-host/ or web+demo:/path/..//not-a-host/,
// (they end up as web+demo:/.//not-a-host/).
//
// If url’s host is null, url does not have an opaque path,
// url’s path’s size is greater than 1, and url’s path[0] is the empty string,
// then append U+002F (/) followed by U+002E (.) to output.
let scheme_end_as_usize = scheme_end as usize;
let path_start_as_usize = path_start as usize;
if path_start_as_usize == scheme_end_as_usize + 1 {
// Anarchist URL
if self.serialization[path_start_as_usize..].starts_with("//") {
// Case 1: The base URL did not have an empty path segment, but the resulting one does
// Insert the "/." prefix
self.serialization.insert_str(path_start_as_usize, "/.");
path_start += 2;
}
assert!(!self.serialization[scheme_end_as_usize..].starts_with("://"));
} else if path_start_as_usize == scheme_end_as_usize + 3
&& &self.serialization[scheme_end_as_usize..path_start_as_usize] == ":/."
{
// Anarchist URL with leading empty path segment
// The base URL has a "/." between the host and the path
assert_eq!(self.serialization.as_bytes()[path_start_as_usize], b'/');
if self
.serialization
.as_bytes()
.get(path_start_as_usize + 1)
.copied()
!= Some(b'/')
{
// Case 2: The base URL had an empty path segment, but the resulting one does not
// Remove the "/." prefix
self.serialization
.replace_range(scheme_end_as_usize..path_start_as_usize, ":");
path_start -= 2;
}
assert!(!self.serialization[scheme_end_as_usize..].starts_with("://"));
}
let (query_start, fragment_start) =
self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;
Ok(Url {
serialization: self.serialization,
scheme_end,
username_end,
host_start,
host_end,
host,
port,
path_start,
query_start,
fragment_start,
})
}
/// Return (query_start, fragment_start)
fn parse_query_and_fragment(
&mut self,
scheme_type: SchemeType,
scheme_end: u32,
mut input: Input<'_>,
) -> ParseResult<(Option<u32>, Option<u32>)> {
let mut query_start = None;
match input.next() {
Some('#') => {}
Some('?') => {
query_start = Some(to_u32(self.serialization.len())?);
self.serialization.push('?');
let remaining = self.parse_query(scheme_type, scheme_end, input);
if let Some(remaining) = remaining {
input = remaining
} else {
return Ok((query_start, None));
}
}
None => return Ok((None, None)),
_ => panic!("Programming error. parse_query_and_fragment() called without ? or #"),
}
let fragment_start = to_u32(self.serialization.len())?;
self.serialization.push('#');
self.parse_fragment(input);
Ok((query_start, Some(fragment_start)))
}
pub fn parse_query<'i>(
&mut self,
scheme_type: SchemeType,
scheme_end: u32,
mut input: Input<'i>,
) -> Option<Input<'i>> {
let len = input.chars.as_str().len();
let mut query = String::with_capacity(len); // FIXME: use a streaming decoder instead
let mut remaining = None;
while let Some(c) = input.next() {
if c == '#' && self.context == Context::UrlParser {
remaining = Some(input);
break;
} else {
self.check_url_code_point(c, &input);
query.push(c);
}
}
let encoding = match &self.serialization[..scheme_end as usize] {
"http" | "https" | "file" | "ftp" => self.query_encoding_override,
_ => None,
};
let query_bytes = if let Some(o) = encoding {
o(&query)
} else {
query.as_bytes().into()
};
let set = if scheme_type.is_special() {
SPECIAL_QUERY
} else {
QUERY
};
self.serialization.extend(percent_encode(&query_bytes, set));
remaining
}
fn fragment_only(mut self, base_url: &Url, mut input: Input<'_>) -> ParseResult<Url> {
let before_fragment = match base_url.fragment_start {
Some(i) => base_url.slice(..i),
None => &*base_url.serialization,
};
debug_assert!(self.serialization.is_empty());
self.serialization
.reserve(before_fragment.len() + input.chars.as_str().len());
self.serialization.push_str(before_fragment);
self.serialization.push('#');
let next = input.next();
debug_assert!(next == Some('#'));
self.parse_fragment(input);
Ok(Url {
serialization: self.serialization,
fragment_start: Some(to_u32(before_fragment.len())?),
..*base_url
})
}
pub fn parse_fragment(&mut self, mut input: Input<'_>) {
while let Some((c, utf8_c)) = input.next_utf8() {
if c == '\0' {
self.log_violation(SyntaxViolation::NullInFragment)
} else {
self.check_url_code_point(c, &input);
}
self.serialization
.extend(utf8_percent_encode(utf8_c, FRAGMENT));
}
}
fn check_url_code_point(&self, c: char, input: &Input<'_>) {
if let Some(vfn) = self.violation_fn {
if c == '%' {
let mut input = input.clone();
if !matches!((input.next(), input.next()), (Some(a), Some(b))
if a.is_ascii_hexdigit() && b.is_ascii_hexdigit())
{
vfn(SyntaxViolation::PercentDecode)
}
} else if !is_url_code_point(c) {
vfn(SyntaxViolation::NonUrlCodePoint)
}
}
}
}
// Non URL code points:
// U+0000 to U+0020 (space)
// " # % < > [ \ ] ^ ` { | }
// U+007F to U+009F
// surrogates
// U+FDD0 to U+FDEF
// Last two of each plane: U+__FFFE to U+__FFFF for __ in 00 to 10 hex
#[inline]
fn is_url_code_point(c: char) -> bool {
matches!(c,
'a'..='z' |
'A'..='Z' |
'0'..='9' |
'!' | '$' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' |
'.' | '/' | ':' | ';' | '=' | '?' | '@' | '_' | '~' |
'\u{A0}'..='\u{D7FF}' | '\u{E000}'..='\u{FDCF}' | '\u{FDF0}'..='\u{FFFD}' |
'\u{10000}'..='\u{1FFFD}' | '\u{20000}'..='\u{2FFFD}' |
'\u{30000}'..='\u{3FFFD}' | '\u{40000}'..='\u{4FFFD}' |
'\u{50000}'..='\u{5FFFD}' | '\u{60000}'..='\u{6FFFD}' |
'\u{70000}'..='\u{7FFFD}' | '\u{80000}'..='\u{8FFFD}' |
'\u{90000}'..='\u{9FFFD}' | '\u{A0000}'..='\u{AFFFD}' |
'\u{B0000}'..='\u{BFFFD}' | '\u{C0000}'..='\u{CFFFD}' |
'\u{D0000}'..='\u{DFFFD}' | '\u{E1000}'..='\u{EFFFD}' |
'\u{F0000}'..='\u{FFFFD}' | '\u{100000}'..='\u{10FFFD}')
}
#[inline]
fn c0_control_or_space(ch: char) -> bool {
ch <= ' ' // U+0000 to U+0020
}
#[inline]
fn ascii_tab_or_new_line(ch: char) -> bool {
matches!(ch, '\t' | '\r' | '\n')
}
#[inline]
pub fn ascii_alpha(ch: char) -> bool {
ch.is_ascii_alphabetic()
}
#[inline]
pub fn to_u32(i: usize) -> ParseResult<u32> {
if i <= ::std::u32::MAX as usize {
Ok(i as u32)
} else {
Err(ParseError::Overflow)
}
}
fn is_normalized_windows_drive_letter(segment: &str) -> bool {
is_windows_drive_letter(segment) && segment.as_bytes()[1] == b':'
}
/// Whether the scheme is file:, the path has a single segment, and that segment
/// is a Windows drive letter
#[inline]
pub fn is_windows_drive_letter(segment: &str) -> bool {
segment.len() == 2 && starts_with_windows_drive_letter(segment)
}
/// Whether path starts with a root slash
/// and a windows drive letter eg: "/c:" or "/a:/"
fn path_starts_with_windows_drive_letter(s: &str) -> bool {
if let Some(c) = s.as_bytes().first() {
matches!(c, b'/' | b'\\' | b'?' | b'#') && starts_with_windows_drive_letter(&s[1..])
} else {
false
}
}
fn starts_with_windows_drive_letter(s: &str) -> bool {
s.len() >= 2
&& ascii_alpha(s.as_bytes()[0] as char)
&& matches!(s.as_bytes()[1], b':' | b'|')
&& (s.len() == 2 || matches!(s.as_bytes()[2], b'/' | b'\\' | b'?' | b'#'))
}
fn starts_with_windows_drive_letter_segment(input: &Input<'_>) -> bool {
let mut input = input.clone();
match (input.next(), input.next(), input.next()) {
// its first two code points are a Windows drive letter
// its third code point is U+002F (/), U+005C (\), U+003F (?), or U+0023 (#).
(Some(a), Some(b), Some(c))
if ascii_alpha(a) && matches!(b, ':' | '|') && matches!(c, '/' | '\\' | '?' | '#') =>
{
true
}
// its first two code points are a Windows drive letter
// its length is 2
(Some(a), Some(b), None) if ascii_alpha(a) && matches!(b, ':' | '|') => true,
_ => false,
}
}