use std::str::FromStr;
use std::{borrow::Cow, fmt};
use base64::Engine as _;
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
pub const HEADER_UPLOAD_LENGTH: &str = "upload-length";
pub const HEADER_UPLOAD_OFFSET: &str = "upload-offset";
const OFFSET_WILDCARD: &str = "*";
#[derive(Clone, PartialEq, Eq)]
pub struct SessionToken(Vec<u8>);
impl SessionToken {
pub fn new(bytes: impl Into<Vec<u8>>) -> Self {
Self(bytes.into())
}
pub fn as_bytes(&self) -> &[u8] {
&self.0
}
pub fn into_bytes(self) -> Vec<u8> {
self.0
}
pub fn from_base64url(encoded: &str) -> Result<Self, InvalidSessionToken> {
let bytes = URL_SAFE_NO_PAD
.decode(encoded)
.map_err(|_| InvalidSessionToken)?;
if URL_SAFE_NO_PAD.encode(&bytes) != encoded {
return Err(InvalidSessionToken);
}
Ok(Self(bytes))
}
pub fn to_base64url(&self) -> String {
URL_SAFE_NO_PAD.encode(&self.0)
}
}
impl fmt::Debug for SessionToken {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("SessionToken")
}
}
impl Serialize for SessionToken {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&self.to_base64url())
}
}
impl<'de> Deserialize<'de> for SessionToken {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let encoded = Cow::<'static, String>::deserialize(deserializer)?;
Self::from_base64url(&encoded).map_err(de::Error::custom)
}
}
#[derive(Debug, thiserror::Error)]
#[error("session token must use unpadded base64url encoding")]
pub struct InvalidSessionToken;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum UploadOffset {
At(u64),
Unknown,
}
#[derive(Debug, thiserror::Error)]
#[error("invalid {HEADER_UPLOAD_OFFSET} value: {0}")]
pub struct InvalidUploadOffset(String);
impl FromStr for UploadOffset {
type Err = InvalidUploadOffset;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if s == OFFSET_WILDCARD {
return Ok(Self::Unknown);
}
if !s.bytes().all(|b| b.is_ascii_digit()) {
return Err(InvalidUploadOffset(s.to_owned()));
}
let offset = s.parse().map_err(|_| InvalidUploadOffset(s.to_owned()))?;
Ok(Self::At(offset))
}
}
impl fmt::Display for UploadOffset {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::At(offset) => offset.fmt(f),
Self::Unknown => f.write_str(OFFSET_WILDCARD),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum UploadProgress {
Incomplete {
offset: u64,
},
Complete,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateSessionResponse {
pub key: String,
pub session: SessionToken,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompleteUploadResponse {
pub key: String,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn create_session_response_encodes_token_once() -> Result<(), serde_json::Error> {
let response = CreateSessionResponse {
key: "key".into(),
session: SessionToken::new(b"../opaque +? \xc3\xbc"),
};
assert_eq!(
serde_json::to_string(&response)?,
r#"{"key":"key","session":"Li4vb3BhcXVlICs_IMO8"}"#
);
Ok(())
}
#[test]
fn session_token_round_trips_arbitrary_bytes() -> Result<(), serde_json::Error> {
let token = SessionToken::new([0, 1, 2, 0xfe, 0xff]);
let json = serde_json::to_string(&token)?;
assert_eq!(json, r#""AAEC_v8""#);
assert_eq!(serde_json::from_str::<SessionToken>(&json)?, token);
Ok(())
}
#[test]
fn session_token_rejects_noncanonical_encodings() {
for invalid in ["%%%", "dG9rM24="] {
assert!(
SessionToken::from_base64url(invalid).is_err(),
"accepted {invalid:?}"
);
}
}
#[test]
fn upload_offset_parses_wildcard_and_offsets() -> Result<(), InvalidUploadOffset> {
assert_eq!("*".parse::<UploadOffset>()?, UploadOffset::Unknown);
assert_eq!("0".parse::<UploadOffset>()?, UploadOffset::At(0));
assert_eq!("262144".parse::<UploadOffset>()?, UploadOffset::At(262144));
Ok(())
}
#[test]
fn upload_offset_rejects_malformed_values() {
for invalid in ["", "-1", "+1", " 1", "1 ", "1.5", "0x10", "**", "abc"] {
assert!(
invalid.parse::<UploadOffset>().is_err(),
"expected {invalid:?} to be rejected"
);
}
}
#[test]
fn upload_offset_round_trips_through_display() -> Result<(), InvalidUploadOffset> {
for offset in [
UploadOffset::Unknown,
UploadOffset::At(0),
UploadOffset::At(7),
] {
assert_eq!(offset.to_string().parse::<UploadOffset>()?, offset);
}
Ok(())
}
}