docsrs_cli/domain/
origin.rs1use std::fmt;
4
5use serde::{Deserialize, Deserializer, Serialize, Serializer};
6use url::Url;
7
8use crate::config::{
9 HOST_CRATES_IO, HOST_DOC_RUST_LANG_ORG, HOST_DOCS_RS, HOST_STATIC_DOCS_RS, SCHEME_HTTPS,
10 is_allowed_origin_scheme_host, normalize_origin,
11};
12use crate::error::{AppError, AppResult, ErrorKind};
13
14#[repr(transparent)]
20#[derive(Debug, Clone, PartialEq, Eq, Hash)]
21pub struct AllowedOrigin(String);
22
23impl AllowedOrigin {
24 pub fn parse(raw: &str) -> AppResult<Self> {
34 Self::parse_with(raw, false)
35 }
36
37 pub fn parse_with(raw: &str, allow_loopback: bool) -> AppResult<Self> {
49 let normalized = normalize_origin(raw);
50 if normalized.is_empty() {
51 return Err(AppError::new(ErrorKind::Config, "origin URL must not be empty"));
52 }
53 let url = url::Url::parse(&normalized).map_err(|e| {
54 AppError::with_source(
55 ErrorKind::Config,
56 format!("invalid origin URL '{normalized}'"),
57 e,
58 )
59 })?;
60 let scheme = url.scheme();
61 if scheme != "http" && scheme != "https" {
62 return Err(AppError::new(
63 ErrorKind::Config,
64 format!("origin scheme must be http or https, got '{scheme}'"),
65 ));
66 }
67 let Some(host) = url.host_str() else {
68 return Err(AppError::new(
69 ErrorKind::Config,
70 format!("origin URL must include a host: '{normalized}'"),
71 ));
72 };
73 if !is_allowed_origin_scheme_host(scheme, host, allow_loopback) {
74 return Err(AppError::new(
75 ErrorKind::Config,
76 format!(
77 "origin host not allowlisted: '{host}' (allowed: {HOST_CRATES_IO}, {HOST_DOCS_RS}, {HOST_STATIC_DOCS_RS}, {HOST_DOC_RUST_LANG_ORG}; loopback requires allow_loopback via CLI or config.toml)"
78 ),
79 ));
80 }
81 let port = url
83 .port()
84 .map(|p| format!(":{p}"))
85 .unwrap_or_default();
86 Ok(Self(format!("{scheme}://{host}{port}")))
87 }
88
89 #[must_use]
91 pub fn crates_io_default() -> Self {
92 Self(format!("{SCHEME_HTTPS}://{HOST_CRATES_IO}"))
93 }
94
95 #[must_use]
97 pub fn docs_rs_default() -> Self {
98 Self(format!("{SCHEME_HTTPS}://{HOST_DOCS_RS}"))
99 }
100
101 #[must_use]
103 pub fn stdlib_docs_default() -> Self {
104 Self(format!("{SCHEME_HTTPS}://{HOST_DOC_RUST_LANG_ORG}"))
105 }
106
107 #[must_use]
109 pub fn as_str(&self) -> &str {
110 &self.0
111 }
112
113 pub fn to_url(&self) -> AppResult<Url> {
124 Url::parse(self.as_str()).map_err(|e| {
125 AppError::with_source(
126 ErrorKind::Internal,
127 format!("allowed origin is not a valid URL: '{}'", self.as_str()),
128 e,
129 )
130 })
131 }
132}
133
134impl AsRef<str> for AllowedOrigin {
135 fn as_ref(&self) -> &str {
136 self.as_str()
137 }
138}
139
140impl fmt::Display for AllowedOrigin {
141 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
142 f.write_str(self.as_str())
143 }
144}
145
146impl Serialize for AllowedOrigin {
147 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
148 serializer.serialize_str(self.as_str())
149 }
150}
151
152impl<'de> Deserialize<'de> for AllowedOrigin {
153 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
154 let s = String::deserialize(deserializer)?;
155 Self::parse(&s).map_err(serde::de::Error::custom)
156 }
157}
158
159#[cfg(test)]
160mod tests {
161 use super::*;
162
163 #[test]
164 fn parse_accepts_https_and_rejects_garbage() {
165 assert_eq!(
166 AllowedOrigin::parse("https://docs.rs/").unwrap().as_str(),
167 format!("{SCHEME_HTTPS}://{HOST_DOCS_RS}")
168 );
169 assert!(AllowedOrigin::parse("https://evil.example").is_err());
170 assert!(AllowedOrigin::parse("not-a-url").is_err());
171 assert!(AllowedOrigin::parse("").is_err());
172 assert!(AllowedOrigin::parse("http://127.0.0.1:9").is_err());
173 assert_eq!(
174 AllowedOrigin::parse_with("http://127.0.0.1:9/", true)
175 .unwrap()
176 .as_str(),
177 "http://127.0.0.1:9"
178 );
179 }
180
181 #[test]
182 fn defaults_round_trip() {
183 assert_eq!(
184 AllowedOrigin::crates_io_default().as_str(),
185 format!("{SCHEME_HTTPS}://{HOST_CRATES_IO}")
186 );
187 assert_eq!(
188 AllowedOrigin::docs_rs_default().as_str(),
189 format!("{SCHEME_HTTPS}://{HOST_DOCS_RS}")
190 );
191 }
192
193 #[test]
194 fn to_url_round_trips_defaults() {
195 let o = AllowedOrigin::docs_rs_default();
196 let u = o.to_url().unwrap();
197 assert_eq!(u.scheme(), SCHEME_HTTPS);
198 assert_eq!(u.host_str(), Some(HOST_DOCS_RS));
199 assert_eq!(u.as_str().trim_end_matches('/'), o.as_str());
200 }
201}