use crate::registry_settings::{
self,
wire::{FieldValue, Reader},
};
#[derive(Clone, Copy, Debug)]
pub struct Limits {
pub bytes: usize,
pub fields: usize,
pub allocation: usize,
pub items: usize,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Error {
ByteLimit,
FieldLimit,
Malformed,
UnsupportedWireType,
DuplicateField,
ItemLimit,
AllocationLimit,
ChunkedValue,
OutputLimit,
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Registry protobuf refusal: {self:?}")
}
}
impl std::error::Error for Error {}
impl From<registry_settings::Error> for Error {
fn from(value: registry_settings::Error) -> Self {
match value {
registry_settings::Error::ByteLimit => Self::ByteLimit,
registry_settings::Error::FieldLimit => Self::FieldLimit,
registry_settings::Error::Malformed => Self::Malformed,
registry_settings::Error::UnsupportedWireType => Self::UnsupportedWireType,
registry_settings::Error::DuplicateField => Self::DuplicateField,
}
}
}
struct Budget {
fields: usize,
allocation: usize,
items: usize,
}
trait Field<'a>: Default {
const REPEATED: bool = false;
fn read(&mut self, value: FieldValue<'a>, budget: &mut Budget) -> Result<(), Error>;
}
impl<'a> Field<'a> for &'a [u8] {
fn read(&mut self, value: FieldValue<'a>, _: &mut Budget) -> Result<(), Error> {
let FieldValue::Bytes(bytes) = value else {
return Err(Error::Malformed);
};
*self = bytes;
Ok(())
}
}
impl<'a> Field<'a> for &'a str {
fn read(&mut self, value: FieldValue<'a>, budget: &mut Budget) -> Result<(), Error> {
let mut bytes = &[][..];
bytes.read(value, budget)?;
*self = std::str::from_utf8(bytes).map_err(|_| Error::Malformed)?;
Ok(())
}
}
impl<'a> Field<'a> for u64 {
fn read(&mut self, value: FieldValue<'a>, _: &mut Budget) -> Result<(), Error> {
let FieldValue::Integer(number) = value else {
return Err(Error::Malformed);
};
*self = number;
Ok(())
}
}
impl<'a> Field<'a> for i32 {
fn read(&mut self, value: FieldValue<'a>, budget: &mut Budget) -> Result<(), Error> {
let mut number = 0u64;
number.read(value, budget)?;
let result = number as i32;
if number != u64::from(result as u32) && number != result as i64 as u64 {
return Err(Error::Malformed);
}
*self = result;
Ok(())
}
}
impl<'a> Field<'a> for bool {
fn read(&mut self, value: FieldValue<'a>, budget: &mut Budget) -> Result<(), Error> {
let mut number = 0u64;
number.read(value, budget)?;
*self = match number {
0 => false,
1 => true,
_ => return Err(Error::Malformed),
};
Ok(())
}
}
impl<'a, T: Field<'a>> Field<'a> for Option<T> {
fn read(&mut self, value: FieldValue<'a>, budget: &mut Budget) -> Result<(), Error> {
let mut result = T::default();
result.read(value, budget)?;
*self = Some(result);
Ok(())
}
}
impl<'a, T: Field<'a>> Field<'a> for Vec<T> {
const REPEATED: bool = true;
fn read(&mut self, value: FieldValue<'a>, budget: &mut Budget) -> Result<(), Error> {
budget.items = budget.items.checked_sub(1).ok_or(Error::ItemLimit)?;
budget.allocation = budget
.allocation
.checked_sub(std::mem::size_of::<T>())
.ok_or(Error::AllocationLimit)?;
let mut item = T::default();
item.read(value, budget)?;
self.try_reserve_exact(1)
.map_err(|_| Error::AllocationLimit)?;
self.push(item);
Ok(())
}
}
macro_rules! record {
($(#[$meta:meta])* $name:ident { $($(#[$doc:meta])* $number:literal => $field:ident : $ty:ty),+ $(,)? }) => {
$(#[$meta])* #[derive(Debug,Default,PartialEq,Eq)]
pub struct $name<'a> { $($(#[$doc])* pub $field:$ty,)+ }
impl<'a> Field<'a> for $name<'a> {
fn read(&mut self,value:FieldValue<'a>,budget:&mut Budget)->Result<(),Error>{
let FieldValue::Bytes(bytes)=value else{return Err(Error::Malformed)};
let mut reader=Reader::new(bytes); let mut seen=0u64;
while let Some((number,value))=reader.next(&mut budget.fields)? {
match number {
$($number=>{
if !<$ty as Field>::REPEATED && seen & (1u64 << $number)!=0 {return Err(Error::DuplicateField)}
seen|=1u64 << $number; self.$field.read(value,budget)?;
},)+
_=>(),
}
} Ok(())
}
}
}
}
record! {
RegistryError {
1 => code:i32,
2 => reason:&'a str,
3 => key:&'a [u8],
}
}
record! {
SubnetRecord {
3 => membership:Vec<&'a [u8]>,
9 => replica_version_id:&'a str,
15 => subnet_type:i32,
17 => is_halted:bool,
28 => halt_at_cup_height:bool,
}
}
record! {
NodeRecord {
15 => node_operator_id:&'a [u8],
16 => chip_id:Option<&'a [u8]>,
17 => hostos_version_id:Option<&'a str>,
}
}
record! {
NodeOperatorRecord {
1 => node_operator_principal_id:&'a [u8],
3 => node_provider_principal_id:&'a [u8],
4 => dc_id:&'a str,
}
}
record! {
DataCenterRecord {
1 => id:&'a str,
2 => region:&'a str,
3 => owner:&'a str,
}
}
fn decode<'a, T: Field<'a>>(bytes: &'a [u8], limits: Limits) -> Result<T, Error> {
if bytes.len() > limits.bytes {
return Err(Error::ByteLimit);
}
let mut result = T::default();
let mut budget = Budget {
fields: limits.fields,
allocation: limits.allocation,
items: limits.items,
};
result.read(FieldValue::Bytes(bytes), &mut budget)?;
Ok(result)
}
macro_rules! decoder {
($name:ident,$ty:ident) => {
pub fn $name(bytes: &[u8], limits: Limits) -> Result<$ty<'_>, Error> {
decode(bytes, limits)
}
};
}
decoder!(decode_subnet_record, SubnetRecord);
decoder!(decode_node_record, NodeRecord);
decoder!(decode_node_operator_record, NodeOperatorRecord);
decoder!(decode_data_center_record, DataCenterRecord);
mod envelope;
pub use envelope::{
GetValueResponse, decode_get_latest_version_response, decode_get_value_response,
decode_subnet_list, encode_get_value_request,
};
#[cfg(test)]
mod tests;