//! Opens an explicitly selected ebook loan in the account's reader service. //! //! Only the account service receives the bearer. The returned short-lived //! reader credential is handed to the download engine as a secret. use std::fmt; use base64::Engine as _; use secrecy::SecretString; use serde::Deserialize; use serde_json::json; use url::Url; use super::Client; use super::http::SentryCall; use crate::error::{Error, Result, Service}; use crate::models::{Card, Loan}; /// Short-lived information for opening the reader without the account bearer. #[derive(Clone)] pub struct ReaderPassport { /// The authorized reader's origin. pub web: Url, /// The short-lived reader bootstrap credential. pub message: SecretString, } impl fmt::Debug for ReaderPassport { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("ReaderPassport") .field("web_host", &self.web.host_str()) .field("message", &"[REDACTED]") .finish() } } #[derive(Deserialize)] struct PassportReply { urls: PassportUrls, message: String, } #[derive(Deserialize)] struct PassportUrls { web: String, } impl Client { /// Opens `loan` using its card's reader access. This does not lock a loan /// to an Adobe or Kindle format and does not return the loan. /// /// # Errors /// Invalid or mismatched loan metadata, a denied device, or malformed /// reader authorization. The reader host is never sent the account token. pub async fn open_reader(&self, loan: &Loan, card: &Card) -> Result { self.ensure_not_suspended(&card.id)?; if loan.card_id != card.id { return Err(Error::InvalidInput( "reader loan belongs to another card".into(), )); } let (reader_type, format) = match &loan.kind { crate::models::MediaKind::Ebook => ("book", "ebook-overdrive"), crate::models::MediaKind::Audiobook => ("audiobook", "audiobook-overdrive"), crate::models::MediaKind::Magazine => ("magazine", "magazine-overdrive"), _ => return Err(Error::InvalidInput("unsupported reader media kind".into())), }; if !loan .usable_formats() .any(|candidate| candidate.id.as_str() == format) { return Err(Error::NotDownloadable { format: format.into(), }); } let key = card .advantage_key .as_ref() .ok_or_else(|| Error::InvalidInput("reader card has no library key".into()))?; let website = loan .website_id .or(card.library.website_id) .ok_or_else(|| Error::InvalidInput("reader loan has no library website id".into()))?; let title = loan.title_id.as_str(); let psn = format!("{}-{title}", card.id); let cover = loan .best_cover(600) .map_or("https://libbyapp.com/favicon.ico", |cover| { cover.href.as_str() }); let context = json!({ "codex": { "title": {"titleId": title, "slug": title, "cover": {"imageURL": cover, "color": "#ffffff"}}, "loan": {"psnKey": psn, "slug": psn}, "library": {"key": key.as_str(), "name": card.library.name, "colors": ["#000000", "#ffffff"]}, }, "dewey-url": "https://libbyapp.com", "spec": "V31", }); let encoded = base64::engine::general_purpose::STANDARD.encode(context.to_string()); let website = website.to_string(); let query = [("t", encoded.as_str()), ("website_id", website.as_str())]; let path = [ "open", reader_type, "card", card.id.as_str(), "title", title, ]; // Renewal is explicit and occurs before the reader request, so the // account API is never polled or repeatedly re-tried. self.renew_reader_identity().await?; let reply = self .sentry( SentryCall { query: &query, card: Some(&card.id), ..SentryCall::get(&path) }, "open reader", ) .await?; let passport: PassportReply = reply.json(Service::Sentry, "reader passport")?; let web = Url::parse(&passport.urls.web).map_err(|_| Error::Malformed { service: Service::Sentry, message: "invalid reader URL".into(), })?; let host = web.host_str().unwrap_or_default(); let authorized = web.scheme() == "https" && match reader_type { "book" | "magazine" => { host.ends_with(".read.libbyapp.com") || host.ends_with(".read.libbyshelf.com") } "audiobook" => { host.ends_with(".listen.libbyapp.com") || host.ends_with(".listen.libbyshelf.com") } _ => false, }; let test_origin = self.inner.config.sentry_base.scheme() == "http" && web.origin() == self.inner.config.sentry_base.origin(); if (!authorized && !test_origin) || !web.username().is_empty() || web.password().is_some() || web.fragment().is_some() || passport.message.is_empty() || passport.message.len() > 16384 { return Err(Error::Malformed { service: Service::Sentry, message: "invalid reader authorization".into(), }); } Ok(ReaderPassport { web, message: SecretString::from(passport.message), }) } }