1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
use std::fmt::{self, Display};
use std::borrow::Cow;
use crate::ext::IntoOwned;
use crate::parse::{Extent, IndexedStr};
use crate::uri::{as_utf8_unchecked, error::Error};
/// A URI with an authority only: `user:pass@host:8000`.
///
/// # Structure
///
/// The following diagram illustrates the syntactic structure of an authority
/// URI:
///
/// ```text
/// username:password@some.host:8088
/// |---------------| |-------| |--|
/// user info host port
/// ```
///
/// Only the host part of the URI is required.
///
/// # (De)serialization
///
/// `Authority` is both `Serialize` and `Deserialize`:
///
/// ```rust
/// # #[cfg(feature = "serde")] mod serde {
/// # use serde_ as serde;
/// use serde::{Serialize, Deserialize};
/// use rocket::http::uri::Authority;
///
/// #[derive(Deserialize, Serialize)]
/// # #[serde(crate = "serde_")]
/// struct UriOwned {
/// uri: Authority<'static>,
/// }
///
/// #[derive(Deserialize, Serialize)]
/// # #[serde(crate = "serde_")]
/// struct UriBorrowed<'a> {
/// uri: Authority<'a>,
/// }
/// # }
/// ```
#[derive(Debug, Clone)]
pub struct Authority<'a> {
pub(crate) source: Option<Cow<'a, str>>,
pub(crate) user_info: Option<IndexedStr<'a>>,
host: IndexedStr<'a>,
port: Option<u16>,
}
impl<'a> Authority<'a> {
// SAFETY: `source` must be valid UTF-8.
// CORRECTNESS: `host` must be non-empty.
pub(crate) unsafe fn raw(
source: Cow<'a, [u8]>,
user_info: Option<Extent<&'a [u8]>>,
host: Extent<&'a [u8]>,
port: Option<u16>
) -> Authority<'a> {
Authority {
source: Some(as_utf8_unchecked(source)),
user_info: user_info.map(IndexedStr::from),
host: IndexedStr::from(host),
port,
}
}
/// PRIVATE. Used by core.
#[doc(hidden)]
pub fn new(
user_info: impl Into<Option<&'a str>>,
host: &'a str,
port: impl Into<Option<u16>>,
) -> Self {
Authority::const_new(user_info.into(), host, port.into())
}
/// PRIVATE. Used by codegen.
#[doc(hidden)]
pub const fn const_new(user_info: Option<&'a str>, host: &'a str, port: Option<u16>) -> Self {
Authority {
source: None,
user_info: match user_info {
Some(info) => Some(IndexedStr::Concrete(Cow::Borrowed(info))),
None => None
},
host: IndexedStr::Concrete(Cow::Borrowed(host)),
port,
}
}
/// Parses the string `string` into an `Authority`. Parsing will never
/// allocate. Returns an `Error` if `string` is not a valid authority URI.
///
/// # Example
///
/// ```rust
/// # #[macro_use] extern crate rocket;
/// use rocket::http::uri::Authority;
///
/// // Parse a valid authority URI.
/// let uri = Authority::parse("user:pass@host").expect("valid URI");
/// assert_eq!(uri.user_info(), Some("user:pass"));
/// assert_eq!(uri.host(), "host");
/// assert_eq!(uri.port(), None);
///
/// // Invalid authority URIs fail to parse.
/// Authority::parse("https://rocket.rs").expect_err("invalid authority");
///
/// // Prefer to use `uri!()` when the input is statically known:
/// let uri = uri!("user:pass@host");
/// assert_eq!(uri.user_info(), Some("user:pass"));
/// assert_eq!(uri.host(), "host");
/// assert_eq!(uri.port(), None);
/// ```
pub fn parse(string: &'a str) -> Result<Authority<'a>, Error<'a>> {
crate::parse::uri::authority_from_str(string)
}
/// Parses the string `string` into an `Authority`. Parsing never allocates
/// on success. May allocate on error.
///
/// This method should be used instead of [`Authority::parse()`] when
/// the source URI is already a `String`. Returns an `Error` if `string` is
/// not a valid authority URI.
///
/// # Example
///
/// ```rust
/// # extern crate rocket;
/// use rocket::http::uri::Authority;
///
/// let source = format!("rocket.rs:8000");
/// let uri = Authority::parse_owned(source).expect("valid URI");
/// assert!(uri.user_info().is_none());
/// assert_eq!(uri.host(), "rocket.rs");
/// assert_eq!(uri.port(), Some(8000));
/// ```
pub fn parse_owned(string: String) -> Result<Authority<'static>, Error<'static>> {
let authority = Authority::parse(&string).map_err(|e| e.into_owned())?;
debug_assert!(authority.source.is_some(), "Authority parsed w/o source");
let authority = Authority {
host: authority.host.into_owned(),
user_info: authority.user_info.into_owned(),
port: authority.port,
source: Some(Cow::Owned(string)),
};
Ok(authority)
}
/// Returns the user info part of the authority URI, if there is one.
///
/// # Example
/// ```rust
/// # #[macro_use] extern crate rocket;
/// let uri = uri!("username:password@host");
/// assert_eq!(uri.user_info(), Some("username:password"));
/// ```
pub fn user_info(&self) -> Option<&str> {
self.user_info.as_ref().map(|u| u.from_cow_source(&self.source))
}
/// Returns the host part of the authority URI.
///
/// # Example
///
/// ```rust
/// # #[macro_use] extern crate rocket;
/// let uri = uri!("domain.com:123");
/// assert_eq!(uri.host(), "domain.com");
///
/// let uri = uri!("username:password@host:123");
/// assert_eq!(uri.host(), "host");
///
/// let uri = uri!("username:password@[1::2]:123");
/// assert_eq!(uri.host(), "[1::2]");
/// ```
#[inline(always)]
pub fn host(&self) -> &str {
self.host.from_cow_source(&self.source)
}
/// Returns the port part of the authority URI, if there is one.
///
/// # Example
///
/// ```rust
/// # #[macro_use] extern crate rocket;
/// // With a port.
/// let uri = uri!("username:password@host:123");
/// assert_eq!(uri.port(), Some(123));
///
/// let uri = uri!("domain.com:8181");
/// assert_eq!(uri.port(), Some(8181));
///
/// // Without a port.
/// let uri = uri!("username:password@host");
/// assert_eq!(uri.port(), None);
/// ```
#[inline(always)]
pub fn port(&self) -> Option<u16> {
self.port
}
}
impl_serde!(Authority<'a>, "an authority-form URI");
impl_traits!(Authority, user_info, host, port);
impl Display for Authority<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if let Some(user_info) = self.user_info() {
write!(f, "{}@", user_info)?;
}
self.host().fmt(f)?;
if let Some(port) = self.port {
write!(f, ":{}", port)?;
}
Ok(())
}
}