1use super::*;
2use crate::config::Config;
3use anyhow::Result;
4use quick_xml::{Reader, events::Event};
5use reqwest::{
6 Url,
7 blocking::{Client, Response},
8};
9use scraper::{Html, Selector};
10use std::{
11 io::Read,
12 sync::{
13 Arc,
14 atomic::{AtomicBool, Ordering},
15 },
16 time::Duration,
17};
18const LIMIT: u64 = 10 * 1024 * 1024;
19#[derive(Debug, Clone, Serialize, Deserialize)]
20pub struct Preview {
21 pub feed: Feed,
22 pub episodes: Vec<Episode>,
23}
24pub(crate) fn url(value: &str, base: Option<&Url>) -> Result<Url> {
25 let mut u = match base {
26 Some(b) => b.join(value),
27 None => Url::parse(value),
28 }
29 .map_err(|_| error(crate::t!("podcast_invalid_url")))?;
30 if !matches!(u.scheme(), "http" | "https")
31 || u.host_str().is_none()
32 || !u.username().is_empty()
33 || u.password().is_some()
34 {
35 return Err(error(crate::t!("podcast_invalid_url")));
36 }
37 u.set_fragment(None);
38 Ok(u)
39}
40pub(crate) fn client(config: &Config) -> Result<Client> {
41 Client::builder()
42 .user_agent(crate::USER_AGENT)
43 .connect_timeout(Duration::from_secs(config.settings.connect_timeout_secs))
44 .timeout(Duration::from_secs(config.settings.request_timeout_secs))
45 .redirect(reqwest::redirect::Policy::custom(|a| {
46 if a.previous().len() >= 5
47 || !matches!(a.url().scheme(), "http" | "https")
48 || !a.url().username().is_empty()
49 || a.url().password().is_some()
50 {
51 a.stop()
52 } else {
53 a.follow()
54 }
55 }))
56 .build()
57 .map_err(|_| error(crate::t!("podcast_network")))
58}
59pub(crate) fn body(mut r: Response, stop: &AtomicBool) -> Result<(Url, Vec<u8>)> {
60 if !r.status().is_success() {
61 return Err(error(&format!(
62 "{} {}",
63 crate::t!("podcast_http"),
64 r.status().as_u16()
65 )));
66 }
67 let base = r.url().clone();
68 let mut data = Vec::new();
69 let mut buf = [0; 16384];
70 loop {
71 if stop.load(Ordering::Relaxed) {
72 return Err(DomainError::new(ErrorCode::Cancelled).into());
73 }
74 let n = r
75 .read(&mut buf)
76 .map_err(|_| error(crate::t!("podcast_network")))?;
77 if n == 0 {
78 break;
79 }
80 if data.len() as u64 + n as u64 > LIMIT {
81 return Err(error(crate::t!("podcast_limit")));
82 }
83 data.extend_from_slice(&buf[..n]);
84 }
85 Ok((base, data))
86}
87pub fn fetch(
88 config: &Config,
89 value: &str,
90 old: Option<&Feed>,
91 stop: &Arc<AtomicBool>,
92) -> Result<Option<Preview>> {
93 let u = url(value, None)?;
94 let mut req = client(config)?.get(u);
95 if let Some(f) = old {
96 if let Some(v) = &f.etag {
97 req = req.header("If-None-Match", v);
98 }
99 if let Some(v) = &f.modified {
100 req = req.header("If-Modified-Since", v);
101 }
102 }
103 let r = req
104 .send()
105 .map_err(|_| error(crate::t!("podcast_network")))?;
106 if r.status() == 304 && old.is_some() {
107 return Ok(None);
108 }
109 let etag = r
110 .headers()
111 .get("etag")
112 .and_then(|h| h.to_str().ok())
113 .map(str::to_owned);
114 let modified = r
115 .headers()
116 .get("last-modified")
117 .and_then(|h| h.to_str().ok())
118 .map(str::to_owned);
119 let (base, data) = body(r, stop)?;
120 let mut p = parse(&data, &base)?;
121 p.feed.etag = etag;
122 p.feed.modified = modified;
123 p.feed.refreshed_at = Some(chrono::Utc::now().to_rfc3339());
124 Ok(Some(p))
125}
126fn plain(value: &str) -> String {
127 Html::parse_fragment(value)
128 .root_element()
129 .text()
130 .collect::<Vec<_>>()
131 .join(" ")
132 .split_whitespace()
133 .collect::<Vec<_>>()
134 .join(" ")
135}
136fn duration(value: &str) -> Option<u64> {
137 let mut n = 0u64;
138 for part in value.trim().split(':') {
139 n = n.checked_mul(60)?.checked_add(part.parse::<u64>().ok()?)?;
140 }
141 n.checked_mul(1000)
142}
143struct Node {
144 name: String,
145 text: String,
146 base: Url,
147 html: bool,
148 updated: Option<String>,
149}
150#[derive(Clone, Copy, PartialEq, Eq)]
151enum Scope {
152 Feed,
153 Episode,
154 Other,
155}
156fn scope(stack: &[Node]) -> Scope {
157 match stack {
158 [feed] if feed.name == "feed" => Scope::Feed,
159 [rss, channel] if rss.name == "rss" && channel.name == "channel" => Scope::Feed,
160 [feed, entry] if feed.name == "feed" && entry.name == "entry" => Scope::Episode,
161 [rss, channel, item]
162 if rss.name == "rss" && channel.name == "channel" && item.name == "item" =>
163 {
164 Scope::Episode
165 }
166 _ => Scope::Other,
167 }
168}
169pub(crate) fn parse(data: &[u8], base: &Url) -> Result<Preview> {
170 if data.len() as u64 > LIMIT {
171 return Err(error(crate::t!("podcast_limit")));
172 }
173 if data.starts_with(&[0xff, 0xfe]) || data.starts_with(&[0xfe, 0xff]) {
174 return Err(error(crate::t!("podcast_invalid_feed")));
175 }
176 let invalid = || error(crate::t!("podcast_invalid_feed"));
177 let mut reader = Reader::from_reader(data);
178 reader.config_mut().check_end_names = true;
179 let mut stack: Vec<Node> = vec![];
180 let mut f = Feed {
181 url: base.to_string(),
182 ..Default::default()
183 };
184 let mut episodes = vec![];
185 let mut current: Option<Episode> = None;
186 let mut count = 0;
187 let mut root = String::new();
188 loop {
189 match reader.read_event().map_err(|_| invalid())? {
190 Event::Start(e) | Event::Empty(e) => {
191 let empty =
192 data.get(reader.buffer_position().saturating_sub(2) as usize) == Some(&b'/');
193 let name = e.local_name().as_ref().to_owned();
194 if stack.is_empty() {
195 if !root.is_empty() || !matches!(name.as_str(), "rss" | "feed") {
196 return Err(invalid());
197 }
198 root = name.clone();
199 }
200 if stack.len() >= 64 {
201 return Err(error(crate::t!("podcast_limit")));
202 }
203 let parent_base = stack.last().map(|n| &n.base).unwrap_or(base);
204 let mut attrs = std::collections::HashMap::new();
205 for a in e.attributes() {
206 let a = a.map_err(|_| invalid())?;
207 attrs.insert(
208 a.key.as_ref().to_owned(),
209 a.normalized_value(quick_xml::XmlVersion::Implicit1_0)
210 .map_err(|_| invalid())?
211 .into_owned(),
212 );
213 }
214 let node_base = if let Some(b) = attrs.get("xml:base") {
215 url(b, Some(parent_base))?
216 } else {
217 parent_base.clone()
218 };
219 let attr_url = |key: &str| {
220 attrs
221 .get(key)
222 .and_then(|v| url(v, Some(&node_base)).ok())
223 .map(|u| u.to_string())
224 };
225 let parent_scope = scope(&stack);
226 if parent_scope == Scope::Feed
227 && ((root == "feed" && name == "entry") || (root == "rss" && name == "item"))
228 {
229 count += 1;
230 if count > 10000 || current.is_some() {
231 return Err(error(crate::t!("podcast_limit")));
232 }
233 current = Some(Episode::default());
234 }
235 if parent_scope == Scope::Episode
236 && (name == "enclosure"
237 || (name == "link" && attrs.get("rel").is_some_and(|r| r == "enclosure")))
238 {
239 if let Some(ep) = current.as_mut() {
240 let mime = attrs.get("type").cloned().unwrap_or_default();
241 if ep.url.is_empty()
242 && (mime.is_empty()
243 || mime.starts_with("audio/")
244 || mime == "application/octet-stream")
245 && let Some(u) = attr_url(if name == "link" { "href" } else { "url" })
246 {
247 ep.url = u;
248 ep.mime = mime;
249 ep.bytes = attrs.get("length").and_then(|v| v.parse().ok());
250 }
251 }
252 } else if parent_scope == Scope::Feed
253 && name == "image"
254 && let Some(u) = attr_url("href")
255 {
256 f.image = u;
257 } else if matches!(parent_scope, Scope::Feed | Scope::Episode)
258 && name == "link"
259 && attrs.get("rel").is_none_or(|v| v == "alternate")
260 && let Some(u) = attr_url("href")
261 {
262 if let Some(e) = current.as_mut() {
263 e.website = u;
264 } else {
265 f.website = u;
266 }
267 }
268 stack.push(Node {
269 name,
270 text: String::new(),
271 base: node_base,
272 html: root != "feed"
275 || attrs
276 .get("type")
277 .is_some_and(|t| matches!(t.as_str(), "html" | "text/html")),
278 updated: None,
279 });
280 if !empty {
281 continue;
282 }
283 finish(&mut stack, &mut f, &mut current, &mut episodes);
284 }
285 Event::End(_) => finish(&mut stack, &mut f, &mut current, &mut episodes),
286 Event::Text(t) => {
287 if let Some(n) = stack.last_mut() {
288 n.text.push_str(t.as_ref());
289 }
290 }
291 Event::CData(t) => {
292 if let Some(n) = stack.last_mut() {
293 n.text.push_str(t.as_ref());
294 }
295 }
296 Event::GeneralRef(t) => {
297 if let Some(n) = stack.last_mut() {
298 let t = t.as_ref();
299 let v = quick_xml::escape::unescape(&format!("&{t};"))
300 .map_err(|_| invalid())?
301 .into_owned();
302 n.text.push_str(&v);
303 }
304 }
305 Event::DocType(_) => return Err(invalid()),
306 Event::Eof => break,
307 _ => {}
308 }
309 }
310 if !stack.is_empty() || root.is_empty() || f.title.is_empty() || episodes.is_empty() {
311 return Err(invalid());
312 }
313 Ok(Preview { feed: f, episodes })
314}
315fn finish(
316 stack: &mut Vec<Node>,
317 f: &mut Feed,
318 current: &mut Option<Episode>,
319 episodes: &mut Vec<Episode>,
320) {
321 let Some(n) = stack.pop() else { return };
322 let text = n.text.trim();
323 let display_text = || {
324 if n.html {
325 plain(text)
326 } else {
327 text.split_whitespace().collect::<Vec<_>>().join(" ")
328 }
329 };
330 let parent = stack.last().map(|n| n.name.as_str()).unwrap_or("");
331 let parent_scope = scope(stack);
332 let resolved = || {
333 url(text, Some(&n.base))
334 .map(|u| u.to_string())
335 .unwrap_or_default()
336 };
337 if let Some(e) = current.as_mut() {
338 if parent_scope == Scope::Episode {
339 match n.name.as_str() {
340 "title" => e.title = display_text(),
341 "guid" | "id" if !text.is_empty() => e.guid = Some(text.into()),
342 "description" | "summary" | "content" => e.description = display_text(),
343 "pubDate" | "published" => {
344 e.published = chrono::DateTime::parse_from_rfc2822(text)
345 .or_else(|_| chrono::DateTime::parse_from_rfc3339(text))
346 .ok()
347 .map(|d| d.to_utc().to_rfc3339())
348 }
349 "updated" => {
350 stack.last_mut().unwrap().updated = chrono::DateTime::parse_from_rfc3339(text)
351 .ok()
352 .map(|d| d.to_utc().to_rfc3339());
353 }
354 "link" if !text.is_empty() => e.website = resolved(),
355 "duration" => e.duration_ms = duration(text),
356 _ => {}
357 }
358 }
359 if parent_scope == Scope::Feed && matches!(n.name.as_str(), "item" | "entry") {
360 let mut e = current.take().unwrap();
361 e.published = e.published.or(n.updated);
362 if !e.url.is_empty() {
363 episodes.push(e);
364 }
365 }
366 } else {
367 let nested_feed_field = stack
368 .split_last()
369 .is_some_and(|(_, ancestors)| scope(ancestors) == Scope::Feed);
370 match n.name.as_str() {
371 "title" if parent_scope == Scope::Feed => f.title = display_text(),
372 "author" | "managingEditor" if parent_scope == Scope::Feed => f.author = display_text(),
373 "name" if parent == "author" && nested_feed_field => f.author = display_text(),
374 "description" | "subtitle" if parent_scope == Scope::Feed => {
375 f.description = display_text()
376 }
377 "link" if parent_scope == Scope::Feed && !text.is_empty() => f.website = resolved(),
378 "url" if parent == "image" && nested_feed_field && f.image.is_empty() => {
379 f.image = resolved()
380 }
381 "logo" | "icon" if parent_scope == Scope::Feed => f.image = resolved(),
382 _ => {}
383 }
384 }
385 if let Some(parent) = stack.last_mut().filter(|p| {
386 !matches!(
387 p.name.as_str(),
388 "rss" | "channel" | "feed" | "item" | "entry"
389 )
390 }) && parent.text.len().saturating_add(n.text.len()) <= 1024 * 1024
391 {
392 parent.text.push_str(&n.text);
393 }
394}
395pub fn discover(config: &Config, value: &str, stop: &Arc<AtomicBool>) -> Result<Vec<String>> {
396 let u = url(value, None)?;
397 if matches!(
398 u.host_str(),
399 Some("podcasts.apple.com" | "itunes.apple.com")
400 ) && let Some(id) = u
401 .path_segments()
402 .and_then(|s| {
403 s.filter_map(|p| p.strip_prefix("id").map(str::to_owned))
404 .next_back()
405 })
406 .or_else(|| {
407 u.query_pairs()
408 .find(|(k, _)| k == "id")
409 .map(|(_, v)| v.into_owned())
410 })
411 {
412 return apple(config, "lookup", &[("id", &id)], stop).map(|v| {
413 v.into_iter()
414 .filter_map(|v| {
415 v["feedUrl"]
416 .as_str()
417 .and_then(|s| url(s, None).ok())
418 .map(|u| u.to_string())
419 })
420 .collect()
421 });
422 }
423 let (base, data) = body(
424 client(config)?
425 .get(u)
426 .send()
427 .map_err(|_| error(crate::t!("podcast_network")))?,
428 stop,
429 )?;
430 if parse(&data, &base).is_ok() {
431 return Ok(vec![base.to_string()]);
432 }
433 let html = Html::parse_document(&String::from_utf8_lossy(&data));
434 let mut found = vec![];
435 let base = html
436 .select(&Selector::parse("head base[href]").unwrap())
437 .next()
438 .and_then(|e| url(e.value().attr("href")?, Some(&base)).ok())
439 .unwrap_or(base);
440 for e in html.select(&Selector::parse("head link[href]").unwrap()) {
441 let rel = e.value().attr("rel").unwrap_or("");
442 let mime = e.value().attr("type").unwrap_or("").to_ascii_lowercase();
443 if rel
444 .split_whitespace()
445 .any(|r| r.eq_ignore_ascii_case("alternate") || r.eq_ignore_ascii_case("feed"))
446 && matches!(
447 mime.as_str(),
448 "application/rss+xml" | "application/atom+xml"
449 )
450 && let Some(u) = e
451 .value()
452 .attr("href")
453 .and_then(|s| url(s, Some(&base)).ok())
454 && !found.contains(&u.to_string())
455 {
456 found.push(u.to_string());
457 }
458 }
459 Ok(found)
460}
461fn apple(
462 config: &Config,
463 endpoint: &str,
464 args: &[(&str, &str)],
465 stop: &Arc<AtomicBool>,
466) -> Result<Vec<serde_json::Value>> {
467 use std::sync::{Mutex, OnceLock};
468 use std::time::Instant;
469 type Cache = std::collections::HashMap<String, (Instant, Vec<serde_json::Value>)>;
470 static CACHE: OnceLock<Mutex<Cache>> = OnceLock::new();
471 static LAST: Mutex<Option<Instant>> = Mutex::new(None);
472 let key = format!("{endpoint}{args:?}");
473 let cache = CACHE.get_or_init(Mutex::default);
474 if let Some((at, v)) = cache.lock().unwrap().get(&key)
475 && at.elapsed() < Duration::from_secs(600)
476 {
477 return Ok(v.clone());
478 }
479 {
480 let mut last = LAST.lock().unwrap();
481 while last.is_some_and(|at| at.elapsed() < Duration::from_secs(3)) {
482 if stop.load(Ordering::Relaxed) {
483 return Err(DomainError::new(ErrorCode::Cancelled).into());
484 }
485 std::thread::sleep(Duration::from_millis(50));
486 }
487 *last = Some(Instant::now());
488 }
489 let r = client(config)?
490 .get(format!("https://itunes.apple.com/{endpoint}"))
491 .query(args)
492 .send()
493 .map_err(|_| error(crate::t!("podcast_network")))?;
494 if r.status() == 429 {
495 let seconds = r
496 .headers()
497 .get("retry-after")
498 .and_then(|v| v.to_str().ok())
499 .and_then(|v| v.parse::<u64>().ok())
500 .unwrap_or(60)
501 .min(3600);
502 *LAST.lock().unwrap() = Some(Instant::now() + Duration::from_secs(seconds));
503 return Err(error(crate::t!("podcast_rate_limited")));
504 }
505 let (_, data) = body(r, stop)?;
506 let value: serde_json::Value =
507 serde_json::from_slice(&data).map_err(|_| error(crate::t!("podcast_invalid_feed")))?;
508 let rows = value["results"].as_array().cloned().unwrap_or_default();
509 let mut c = cache.lock().unwrap();
510 if c.len() > 100 {
511 c.clear();
512 }
513 c.insert(key, (Instant::now(), rows.clone()));
514 Ok(rows)
515}
516pub fn search(
517 config: &Config,
518 query: &str,
519 country: &str,
520 limit: usize,
521 stop: &Arc<AtomicBool>,
522) -> Result<Vec<serde_json::Value>> {
523 apple(
524 config,
525 "search",
526 &[
527 ("term", query),
528 ("media", "podcast"),
529 ("entity", "podcast"),
530 ("country", country),
531 ("limit", &limit.to_string()),
532 ],
533 stop,
534 )
535}
536
537#[cfg(test)]
538mod tests {
539 use super::*;
540 fn parse_xml(xml: &str) -> Result<Preview> {
541 parse(
542 xml.as_bytes(),
543 &Url::parse("https://example.test/a/feed").unwrap(),
544 )
545 }
546 #[test]
547 fn atom_source_metadata_stays_separate_from_entry_identity_and_content() {
548 for source_first in [false, true] {
549 let source = r#"<source xml:base="https://source.test/">
550 <id>shared-source</id><title>Source title</title>
551 <updated>2026-02-01T00:00:00Z</updated>
552 <link rel="alternate" href="source"/>
553 <link rel="enclosure" href="source.mp3" type="audio/mpeg"/>
554 <logo>source.jpg</logo><author><name>Source author</name></author>
555 </source>"#;
556 let entries = ["one", "two"].map(|id| {
557 let fields = format!(
558 r#"<id>{id}</id><title>Episode {id}</title>
559 <published>2026-01-01T00:00:00Z</published>
560 <summary>Episode description</summary>
561 <link rel="alternate" href="{id}"/>
562 <link rel="enclosure" href="{id}.mp3" type="audio/mpeg"/>"#
563 );
564 if source_first {
565 format!("<entry>{source}{fields}</entry>")
566 } else {
567 format!("<entry>{fields}{source}</entry>")
568 }
569 });
570 let p = parse_xml(&format!(
571 r#"<feed xmlns="http://www.w3.org/2005/Atom">
572 <title>Show</title><author><name>Show author</name></author>
573 <logo>show.jpg</logo>{}</feed>"#,
574 entries.join("")
575 ))
576 .unwrap();
577 assert_eq!(p.feed.author, "Show author");
578 assert_eq!(p.feed.image, "https://example.test/a/show.jpg");
579 for (episode, id) in p.episodes.iter().zip(["one", "two"]) {
580 assert_eq!(episode.guid.as_deref(), Some(id));
581 assert_eq!(episode.title, format!("Episode {id}"));
582 assert_eq!(episode.description, "Episode description");
583 assert_eq!(
584 episode.published.as_deref(),
585 Some("2026-01-01T00:00:00+00:00")
586 );
587 assert_eq!(episode.website, format!("https://example.test/a/{id}"));
588 assert_eq!(episode.url, format!("https://example.test/a/{id}.mp3"));
589 }
590 let dir = tempfile::tempdir().unwrap();
591 let store = crate::store::Store::open(&dir.path().join("radio.db")).unwrap();
592 let feed = store.podcast_subscribe(&p, &p.feed.url).unwrap();
593 assert_eq!(store.podcast_episodes(&feed.id).unwrap().len(), 2);
594 }
595 }
596 #[test]
597 fn rss_episode_images_never_replace_or_supply_show_artwork() {
598 for show_image in ["", r#"<itunes:image href="show.jpg"/>"#] {
599 for show_first in [false, true] {
600 let episodes = r#"<item><title>One</title><enclosure url="one.mp3"/>
601 <itunes:image href="one.jpg"/></item>
602 <item><title>Two</title><enclosure url="two.mp3"/>
603 <itunes:image href="two.jpg"/></item>"#;
604 let content = if show_first {
605 format!("{show_image}{episodes}")
606 } else {
607 format!("{episodes}{show_image}")
608 };
609 let p = parse_xml(&format!(
610 r#"<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd">
611 <channel><title>Show</title>{content}</channel></rss>"#
612 ))
613 .unwrap();
614 assert_eq!(p.episodes.len(), 2);
615 assert_eq!(
616 p.feed.image,
617 if show_image.is_empty() {
618 ""
619 } else {
620 "https://example.test/a/show.jpg"
621 }
622 );
623 }
624 }
625 let p = parse_xml(
626 r#"<rss><channel><title>Show</title><image>
627 <title>Image title</title><url>rss.jpg</url><link>https://image.test/</link>
628 </image><link>https://show.test/</link>
629 <item><title>Episode</title><enclosure url="one.mp3"/></item>
630 </channel></rss>"#,
631 )
632 .unwrap();
633 assert_eq!(p.feed.title, "Show");
634 assert_eq!(p.feed.website, "https://show.test/");
635 assert_eq!(p.feed.image, "https://example.test/a/rss.jpg");
636 }
637 #[test]
638 fn rss_metadata_entities_cdata_and_relative_enclosures() {
639 let p=parse_xml(r#"<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd"><channel><title>节目 & 测试</title><itunes:author>作者</itunes:author><item><title><![CDATA[第 <b>一</b> 集]]></title><guid>opaque</guid><itunes:duration>1:02:03</itunes:duration><enclosure url="../audio.m4a?a=1&b=2" type="audio/mp4" length="123"/></item></channel></rss>"#).unwrap();
640 assert_eq!(p.feed.title, "节目 & 测试");
641 assert_eq!(p.feed.author, "作者");
642 assert_eq!(p.episodes[0].title, "第 一 集");
643 assert_eq!(p.episodes[0].duration_ms, Some(3723000));
644 assert_eq!(p.episodes[0].bytes, Some(123));
645 assert_eq!(p.episodes[0].url, "https://example.test/audio.m4a?a=1&b=2");
646 }
647 #[test]
648 fn atom_enclosures_respect_xml_base_and_unknown_duration() {
649 let p=parse_xml(r#"<feed xmlns="http://www.w3.org/2005/Atom" xml:base="https://media.test/"><title>Atom</title><entry><id>x</id><title>one</title><link rel="enclosure" href="one.mp3" type="audio/mpeg"/></entry></feed>"#).unwrap();
650 assert_eq!(p.episodes[0].url, "https://media.test/one.mp3");
651 assert_eq!(p.episodes[0].duration_ms, None);
652 }
653 #[test]
654 fn atom_publication_dates_prefer_published_independently_of_tag_order() {
655 let published = "<published>2026-01-01T00:00:00Z</published>";
656 let updated = "<updated>2026-03-01T00:00:00Z</updated>";
657 for (dates, expected) in [
658 (format!("{published}{updated}"), "2026-01-01T00:00:00+00:00"),
659 (format!("{updated}{published}"), "2026-01-01T00:00:00+00:00"),
660 (published.into(), "2026-01-01T00:00:00+00:00"),
661 (updated.into(), "2026-03-01T00:00:00+00:00"),
662 (
663 format!("{updated}<published>invalid</published>"),
664 "2026-03-01T00:00:00+00:00",
665 ),
666 (
667 format!("<published>invalid</published>{updated}"),
668 "2026-03-01T00:00:00+00:00",
669 ),
670 (
671 format!("{published}<updated>invalid</updated>"),
672 "2026-01-01T00:00:00+00:00",
673 ),
674 ] {
675 let p = parse_xml(&format!(
676 r#"<feed xmlns="http://www.w3.org/2005/Atom"><title>Show</title>
677 <entry><id>one</id><title>One</title>{dates}<link rel="enclosure" href="one.mp3"/></entry>
678 <entry><id>two</id><title>Two</title><published>2026-02-01T00:00:00Z</published>
679 <link rel="enclosure" href="two.mp3"/></entry></feed>"#
680 )).unwrap();
681 assert_eq!(
682 p.episodes[0].published.as_deref(),
683 Some(expected),
684 "{dates}"
685 );
686 let dir = tempfile::tempdir().unwrap();
687 let store = crate::store::Store::open(&dir.path().join("radio.db")).unwrap();
688 let feed = store.podcast_subscribe(&p, &p.feed.url).unwrap();
689 let (page, total) = store
690 .podcast_episodes_page(
691 &feed.id,
692 "",
693 &crate::cli::Page {
694 offset: 0,
695 limit: 1,
696 all: false,
697 },
698 )
699 .unwrap();
700 assert_eq!(total, 2);
701 assert_eq!(
702 page[0].guid.as_deref(),
703 Some(if expected.contains("01-01") {
704 "two"
705 } else {
706 "one"
707 })
708 );
709 }
710 }
711 #[test]
712 fn atom_text_constructs_preserve_literal_markup() {
713 for (kind, content) in [
714 ("", "Show <test> &lt;literal&gt;"),
715 (
716 r#" type="text""#,
717 "Show <test> &lt;literal&gt;",
718 ),
719 (r#" type="text""#, "<![CDATA[Show <test> <literal>]]>"),
720 (
721 r#" type="html""#,
722 "<b>Show</b> &lt;test&gt; &amp;lt;literal&amp;gt;",
723 ),
724 (
725 r#" type="xhtml""#,
726 r#"<div xmlns="http://www.w3.org/1999/xhtml"><b>Show</b> <test> &lt;literal&gt;</div>"#,
727 ),
728 ] {
729 let p = parse_xml(&format!(
730 r#"<feed xmlns="http://www.w3.org/2005/Atom">
731 <title{kind}>{content}</title><subtitle{kind}>{content}</subtitle>
732 <entry><id>one</id><title{kind}>{content}</title>
733 <summary{kind}>{content}</summary>
734 <link rel="enclosure" href="one.mp3" type="audio/mpeg"/>
735 </entry></feed>"#,
736 ))
737 .unwrap();
738 let expected = "Show <test> <literal>";
739 assert_eq!(p.feed.title, expected, "{kind}: {content}");
740 assert_eq!(p.feed.description, expected);
741 assert_eq!(p.episodes[0].title, expected);
742 assert_eq!(p.episodes[0].description, expected);
743 }
744 }
745 #[test]
746 fn malformed_external_entities_and_missing_audio_are_rejected() {
747 for xml in [
748 "<!DOCTYPE rss SYSTEM 'http://bad.test/dtd'><rss/>",
749 "<rss><channel><title>x</title><item><enclosure url='file:///etc/passwd'/></item></channel></rss>",
750 "<rss><channel><title>x</title><item><enclosure url='https://example.test/a'/></channel>",
751 "<html><title>x</title></html>",
752 ] {
753 assert!(parse_xml(xml).is_err(), "{xml}");
754 }
755 let xml = format!("<rss>{}</rss>", "<a>".repeat(65));
756 assert!(parse_xml(&xml).is_err());
757 }
758}