mod base64;
pub(super) mod stored;
use self::stored::{Stored, Text};
use crate::common::checksum;
use crate::common::error::{twice, InputError, RebindError};
use crate::common::limits::{MAX_TOKEN_BYTES, MAX_TOKEN_NESTING, MAX_TOKEN_STATE};
use crate::common::versions::{SEMANTICS_VERSION, TOKEN_VERSION};
use crate::flow::{hex, Flow};
use serde::de::{DeserializeOwned, IgnoredAny};
use smol_str::SmolStr;
use std::collections::HashMap;
use std::fmt;
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct Token(Vec<u8>);
impl fmt::Debug for Token {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Token({})", self.to_base64())
}
}
impl Token {
pub fn from_bytes(bytes: Vec<u8>) -> Token {
Token(bytes)
}
pub fn as_bytes(&self) -> &[u8] {
&self.0
}
pub fn into_bytes(self) -> Vec<u8> {
self.0
}
pub fn to_base64(&self) -> String {
base64::encode(&self.0)
}
pub fn from_base64(text: &str) -> Result<Token, InputError> {
base64::decode(text)
.map(Token)
.ok_or_else(|| InputError::corrupt("not valid base64"))
}
pub fn inspect(&self) -> Result<TokenInfo, InputError> {
let (_, hash, flow, node, _, _, sequence, asks, wake_at, ask): Fields<
IgnoredAny,
IgnoredAny,
> = fields(&self.0)?;
Ok(TokenInfo {
flow: flow.to_string(),
hash: hex(&hash),
node: node.to_string(),
sequence,
asks,
ask: ask.map(|ask| ask.to_string()),
wake_at,
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TokenInfo {
pub flow: String,
pub hash: String,
pub node: String,
pub sequence: u64,
pub asks: u64,
pub ask: Option<String>,
pub wake_at: Option<i64>,
}
const SIGNATURE: [u8; 4] = *b"FTOK";
const VERSION_AT: usize = SIGNATURE.len();
const FIELDS_AT: usize = VERSION_AT + 1;
const TYPICAL_TOKEN_BYTES: usize = 128;
#[derive(Debug, Clone)]
pub(super) struct Data {
pub semantics: u32,
pub hash: Vec<u8>,
pub flow: Text,
pub node: Text,
pub args: Vec<Stored>,
pub params: Vec<(Text, Stored)>,
pub sequence: u64,
pub asks: u64,
pub wake_at: Option<i64>,
pub ask: Option<Text>,
}
type Fields<Args, Params> = (
u32,
serde_bytes::ByteBuf,
Text,
Text,
Args,
Params,
u64,
u64,
Option<i64>,
Option<Text>,
);
impl Data {
pub(super) fn encode(&self) -> Token {
let fields = (
self.semantics,
serde_bytes::Bytes::new(&self.hash),
&self.flow,
&self.node,
&self.args,
&self.params,
self.sequence,
self.asks,
self.wake_at,
&self.ask,
);
let mut out = Vec::with_capacity(TYPICAL_TOKEN_BYTES);
out.extend_from_slice(&SIGNATURE);
out.push(TOKEN_VERSION);
ciborium::ser::into_writer(&fields, &mut out).expect("writing to a Vec can't fail");
checksum::append(&mut out);
Token(out)
}
pub(super) fn decode(bytes: &[u8], flow: &Flow) -> Result<Data, InputError> {
let (semantics, hash, name, node, args, params, sequence, asks, wake_at, ask) =
fields(bytes)?;
if *name != *flow.name {
return Err(InputError::OtherFlow(name.to_string()));
}
if semantics > SEMANTICS_VERSION {
return Err(InputError::NewerToken);
}
Ok(Data {
semantics,
hash: hash.into_vec(),
flow: name,
node,
args,
params,
sequence,
asks,
wake_at,
ask,
})
}
}
fn fields<Args, Params>(bytes: &[u8]) -> Result<Fields<Args, Params>, InputError>
where
Args: DeserializeOwned,
Params: DeserializeOwned,
{
if bytes.len() > MAX_TOKEN_BYTES {
return Err(InputError::corrupt("longer than any token"));
}
if !bytes.starts_with(&SIGNATURE) {
return Err(InputError::corrupt("not a flow token"));
}
let body = checksum::strip(bytes).ok_or_else(|| InputError::corrupt("checksum mismatch"))?;
match body.get(VERSION_AT) {
Some(&TOKEN_VERSION) => {}
Some(&version) if version > TOKEN_VERSION => return Err(InputError::NewerToken),
_ => return Err(InputError::corrupt("no known token version")),
}
let mut rest = &body[FIELDS_AT..];
let fields = ciborium::de::from_reader_with_recursion_limit(&mut rest, MAX_TOKEN_NESTING)
.map_err(|error| InputError::corrupt(format!("malformed: {error}")))?;
if !rest.is_empty() {
return Err(InputError::corrupt("bytes after its end"));
}
Ok(fields)
}
impl Flow {
pub fn rebind(&self, token: &Token) -> Result<Token, RebindError> {
let data = Data::decode(&token.0, self).map_err(RebindError::Token)?;
let Some(id) = self.node_by_name(&data.node) else {
return Err(RebindError::NodeGone(data.node.to_string()));
};
let node = &self.nodes[id.index()];
if node.params.len() != data.args.len() || node.resumes_ask != data.ask.is_some() {
return Err(RebindError::NodeChanged(data.node.to_string()));
}
let mut carried: HashMap<SmolStr, Stored> = HashMap::with_capacity(data.params.len());
for (Text(name), value) in data.params {
if carried.contains_key(&name) {
let error = InputError::corrupt(twice("param", &name));
return Err(RebindError::Token(error));
}
if !self.param_positions.contains_key(&name) {
return Err(RebindError::ParamGone(name.to_string()));
}
carried.insert(name, value);
}
let params: Vec<(Text, Stored)> = self
.params
.iter()
.map(|param| {
let value = carried
.remove(param.name.as_str())
.unwrap_or_else(|| stored::encode(¶m.default).unwrap_or(Stored::Null));
(Text(SmolStr::new(¶m.name)), value)
})
.collect();
if stored::state_len(&data.args, ¶ms) > MAX_TOKEN_STATE {
return Err(RebindError::TooLarge);
}
Ok(Data {
semantics: SEMANTICS_VERSION,
hash: self.hash.to_vec(),
params,
..data
}
.encode())
}
}