#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg))]
#![doc = include_str!("../README.md")]
#![cfg_attr(not(ci_arti_stable), allow(renamed_and_removed_lints))]
#![cfg_attr(not(ci_arti_nightly), allow(unknown_lints))]
#![deny(missing_docs)]
#![warn(noop_method_call)]
#![deny(unreachable_pub)]
#![warn(clippy::all)]
#![deny(clippy::await_holding_lock)]
#![deny(clippy::cargo_common_metadata)]
#![deny(clippy::cast_lossless)]
#![deny(clippy::checked_conversions)]
#![warn(clippy::cognitive_complexity)]
#![deny(clippy::debug_assert_with_mut_call)]
#![deny(clippy::exhaustive_enums)]
#![deny(clippy::exhaustive_structs)]
#![deny(clippy::expl_impl_clone_on_copy)]
#![deny(clippy::fallible_impl_from)]
#![deny(clippy::implicit_clone)]
#![deny(clippy::large_stack_arrays)]
#![warn(clippy::manual_ok_or)]
#![deny(clippy::missing_docs_in_private_items)]
#![deny(clippy::missing_panics_doc)]
#![warn(clippy::needless_borrow)]
#![warn(clippy::needless_pass_by_value)]
#![warn(clippy::option_option)]
#![warn(clippy::rc_buffer)]
#![deny(clippy::ref_option_ref)]
#![warn(clippy::semicolon_if_nothing_returned)]
#![warn(clippy::trait_duplication_in_bounds)]
#![deny(clippy::unnecessary_wraps)]
#![warn(clippy::unseparated_literal_suffix)]
#![deny(clippy::unwrap_used)]
#![allow(clippy::let_unit_value)] #![allow(clippy::significant_drop_in_scrutinee)] #![allow(clippy::result_large_err)]
#![allow(non_upper_case_globals)]
#![allow(clippy::upper_case_acronyms)]
use caret::caret_int;
use thiserror::Error;
caret_int! {
#[derive(Hash,Ord,PartialOrd)]
pub struct ProtoKind(u16) {
Link = 0,
LinkAuth = 1,
Relay = 2,
DirCache = 3,
HSDir = 4,
HSIntro = 5,
HSRend = 6,
Desc = 7,
MicroDesc = 8,
Cons = 9,
Padding = 10,
FlowCtrl = 11,
}
}
const N_RECOGNIZED: usize = 12;
#[derive(Eq, PartialEq, Clone, Debug, Hash, Ord, PartialOrd)]
enum Protocol {
Proto(ProtoKind),
Unrecognized(String),
}
impl Protocol {
fn is_unrecognized(&self, s: &str) -> bool {
match self {
Protocol::Unrecognized(s2) => s2 == s,
_ => false,
}
}
fn to_str(&self) -> &str {
match self {
Protocol::Proto(k) => k.to_str().unwrap_or("<bug>"),
Protocol::Unrecognized(s) => s,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
struct SubprotocolEntry {
proto: Protocol,
supported: u64,
}
#[derive(Debug, Clone, Default, Eq, PartialEq, Hash)]
pub struct Protocols {
recognized: [u64; N_RECOGNIZED],
unrecognized: Vec<SubprotocolEntry>,
}
impl Protocols {
pub fn new() -> Self {
Protocols::default()
}
fn supports_recognized_ver(&self, proto: usize, ver: u8) -> bool {
if ver > 63 {
return false;
}
if proto >= self.recognized.len() {
return false;
}
(self.recognized[proto] & (1 << ver)) != 0
}
fn supports_unrecognized_ver(&self, proto: &str, ver: u8) -> bool {
if ver > 63 {
return false;
}
let ent = self
.unrecognized
.iter()
.find(|ent| ent.proto.is_unrecognized(proto));
match ent {
Some(e) => (e.supported & (1 << ver)) != 0,
None => false,
}
}
pub fn supports_known_subver(&self, proto: ProtoKind, ver: u8) -> bool {
self.supports_recognized_ver(proto.get() as usize, ver)
}
pub fn supports_subver(&self, proto: &str, ver: u8) -> bool {
match ProtoKind::from_name(proto) {
Some(p) => self.supports_recognized_ver(p.get() as usize, ver),
None => self.supports_unrecognized_ver(proto, ver),
}
}
fn add(&mut self, foundmask: &mut u64, ent: SubprotocolEntry) -> Result<(), ParseError> {
match ent.proto {
Protocol::Proto(k) => {
let idx = k.get() as usize;
let bit = 1 << u64::from(k.get());
if (*foundmask & bit) != 0 {
return Err(ParseError::Duplicate);
}
*foundmask |= bit;
self.recognized[idx] = ent.supported;
}
Protocol::Unrecognized(ref s) => {
if self
.unrecognized
.iter()
.any(|ent| ent.proto.is_unrecognized(s))
{
return Err(ParseError::Duplicate);
}
self.unrecognized.push(ent);
}
}
Ok(())
}
}
#[derive(Error, Debug, PartialEq, Eq, Clone)]
#[non_exhaustive]
pub enum ParseError {
#[error("Protocol version out of range")]
OutOfRange,
#[error("Duplicate protocol entry")]
Duplicate,
#[error("Malformed protocol entry")]
Malformed,
}
fn bitrange(lo: u64, hi: u64) -> u64 {
assert!(lo <= hi && lo <= 63 && hi <= 63);
let mut mask = !0;
mask <<= 63 - hi;
mask >>= 63 - hi + lo;
mask <<= lo;
mask
}
fn is_good_number(n: &str) -> bool {
n.chars().all(|ch| ch.is_ascii_digit()) && !n.starts_with('0')
}
impl std::str::FromStr for SubprotocolEntry {
type Err = ParseError;
fn from_str(s: &str) -> Result<Self, ParseError> {
let (name, versions) = {
let eq_idx = s.find('=').ok_or(ParseError::Malformed)?;
(&s[..eq_idx], &s[eq_idx + 1..])
};
let proto = match ProtoKind::from_name(name) {
Some(p) => Protocol::Proto(p),
None => Protocol::Unrecognized(name.to_string()),
};
if versions.is_empty() {
return Ok(SubprotocolEntry {
proto,
supported: 0,
});
}
let mut supported = 0_u64;
for ent in versions.split(',') {
let (lo_s, hi_s) = {
match ent.find('-') {
Some(pos) => (&ent[..pos], &ent[pos + 1..]),
None => (ent, ent),
}
};
if !is_good_number(lo_s) {
return Err(ParseError::Malformed);
}
if !is_good_number(hi_s) {
return Err(ParseError::Malformed);
}
let lo: u64 = lo_s.parse().map_err(|_| ParseError::Malformed)?;
let hi: u64 = hi_s.parse().map_err(|_| ParseError::Malformed)?;
if lo > 63 || hi > 63 {
return Err(ParseError::OutOfRange);
}
if lo > hi {
return Err(ParseError::Malformed);
}
let mask = bitrange(lo, hi);
if (supported & mask) != 0 {
return Err(ParseError::Duplicate);
}
supported |= mask;
}
Ok(SubprotocolEntry { proto, supported })
}
}
impl std::str::FromStr for Protocols {
type Err = ParseError;
fn from_str(s: &str) -> Result<Self, ParseError> {
let mut result = Protocols::new();
let mut foundmask = 0_u64;
for ent in s.split(' ') {
if ent.is_empty() {
continue;
}
let s: SubprotocolEntry = ent.parse()?;
result.add(&mut foundmask, s)?;
}
result.unrecognized.sort();
Ok(result)
}
}
fn dumpmask(mut mask: u64) -> String {
fn append(v: &mut Vec<String>, lo: u32, hi: u32) {
if lo == hi {
v.push(lo.to_string());
} else {
v.push(format!("{}-{}", lo, hi));
}
}
let mut result = Vec::new();
let mut shift = 0;
while mask != 0 {
let zeros = mask.trailing_zeros();
mask >>= zeros;
shift += zeros;
let ones = mask.trailing_ones();
append(&mut result, shift, shift + ones - 1);
shift += ones;
if ones == 64 {
break;
}
mask >>= ones;
}
result.join(",")
}
impl std::fmt::Display for Protocols {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut entries = Vec::new();
for (idx, mask) in self.recognized.iter().enumerate() {
if *mask != 0 {
let pk: ProtoKind = (idx as u16).into();
entries.push(format!("{}={}", pk, dumpmask(*mask)));
}
}
for ent in &self.unrecognized {
if ent.supported != 0 {
entries.push(format!(
"{}={}",
ent.proto.to_str(),
dumpmask(ent.supported)
));
}
}
entries.sort();
write!(f, "{}", entries.join(" "))
}
}
#[cfg(test)]
mod test {
#![allow(clippy::unwrap_used)]
use super::*;
#[test]
fn test_bitrange() {
assert_eq!(0b1, bitrange(0, 0));
assert_eq!(0b10, bitrange(1, 1));
assert_eq!(0b11, bitrange(0, 1));
assert_eq!(0b1111110000000, bitrange(7, 12));
assert_eq!(!0, bitrange(0, 63));
}
#[test]
fn test_dumpmask() {
assert_eq!("", dumpmask(0));
assert_eq!("0-5", dumpmask(0b111111));
assert_eq!("4-5", dumpmask(0b110000));
assert_eq!("1,4-5", dumpmask(0b110010));
assert_eq!("0-63", dumpmask(!0));
}
#[test]
fn test_canonical() -> Result<(), ParseError> {
fn t(orig: &str, canonical: &str) -> Result<(), ParseError> {
let protos: Protocols = orig.parse()?;
let enc = format!("{}", protos);
assert_eq!(enc, canonical);
Ok(())
}
t("", "")?;
t(" ", "")?;
t("Link=5,6,7,9 Relay=4-7,2", "Link=5-7,9 Relay=2,4-7")?;
t("FlowCtrl= Padding=8,7 Desc=1-5,6-8", "Desc=1-8 Padding=7-8")?;
t("Zelda=7 Gannon=3,6 Link=4", "Gannon=3,6 Link=4 Zelda=7")?;
Ok(())
}
#[test]
fn test_invalid() {
fn t(s: &str) -> ParseError {
let protos: Result<Protocols, ParseError> = s.parse();
assert!(protos.is_err());
protos.err().unwrap()
}
assert_eq!(t("Link=1-100"), ParseError::OutOfRange);
assert_eq!(t("Zelda=100"), ParseError::OutOfRange);
assert_eq!(t("Link=100-200"), ParseError::OutOfRange);
assert_eq!(t("Link=1,1"), ParseError::Duplicate);
assert_eq!(t("Link=1 Link=1"), ParseError::Duplicate);
assert_eq!(t("Link=1 Link=3"), ParseError::Duplicate);
assert_eq!(t("Zelda=1 Zelda=3"), ParseError::Duplicate);
assert_eq!(t("Link=Zelda"), ParseError::Malformed);
assert_eq!(t("Link=6-2"), ParseError::Malformed);
assert_eq!(t("Link=6-"), ParseError::Malformed);
assert_eq!(t("Link=6-,2"), ParseError::Malformed);
assert_eq!(t("Link=1,,2"), ParseError::Malformed);
assert_eq!(t("Link=6-frog"), ParseError::Malformed);
assert_eq!(t("Link=gannon-9"), ParseError::Malformed);
assert_eq!(t("Link Zelda"), ParseError::Malformed);
assert_eq!(t("Link=01"), ParseError::Malformed);
assert_eq!(t("Link=waffle"), ParseError::Malformed);
assert_eq!(t("Link=1_1"), ParseError::Malformed);
}
#[test]
fn test_supports() -> Result<(), ParseError> {
let p: Protocols = "Link=4,5-7 Padding=2 Lonk=1-3,5".parse()?;
assert!(p.supports_known_subver(ProtoKind::Padding, 2));
assert!(!p.supports_known_subver(ProtoKind::Padding, 1));
assert!(p.supports_known_subver(ProtoKind::Link, 6));
assert!(!p.supports_known_subver(ProtoKind::Link, 255));
assert!(!p.supports_known_subver(ProtoKind::Cons, 1));
assert!(!p.supports_known_subver(ProtoKind::Cons, 0));
assert!(p.supports_subver("Link", 6));
assert!(!p.supports_subver("link", 6));
assert!(!p.supports_subver("Cons", 0));
assert!(p.supports_subver("Lonk", 3));
assert!(!p.supports_subver("Lonk", 4));
assert!(!p.supports_subver("lonk", 3));
assert!(!p.supports_subver("Lonk", 64));
Ok(())
}
}