use std::error::Error;
use std::fmt::{self, Debug, Display, Formatter};
use crate::redact::Bytes;
#[derive(Clone, Eq, PartialEq)]
pub struct Payload(Box<[u8]>);
impl Debug for Payload {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
Bytes(self.0.len()).fmt(formatter)
}
}
impl Payload {
#[must_use]
pub fn from_vec(bytes: Vec<u8>) -> Self {
Self(bytes.into_boxed_slice())
}
#[must_use]
pub fn copy_from_slice(bytes: &[u8]) -> Self {
Self(Box::from(bytes))
}
#[must_use]
pub fn as_bytes(&self) -> &[u8] {
&self.0
}
#[must_use]
pub fn into_bytes(self) -> Box<[u8]> {
self.0
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Envelope {
namespace: String,
kind: String,
data: Payload,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum EnvelopeError {
EmptyNamespace,
EmptyKind,
EmptyData,
InvalidJson,
}
impl Display for EnvelopeError {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::EmptyNamespace => "opaque envelope namespace is empty",
Self::EmptyKind => "opaque envelope kind is empty",
Self::EmptyData => "opaque envelope data is empty",
Self::InvalidJson => "opaque envelope data is not valid JSON",
})
}
}
impl Error for EnvelopeError {}
impl Envelope {
pub fn try_new(namespace: String, kind: String, data: Payload) -> Result<Self, EnvelopeError> {
if namespace.is_empty() {
return Err(EnvelopeError::EmptyNamespace);
}
if kind.is_empty() {
return Err(EnvelopeError::EmptyKind);
}
if data.as_bytes().is_empty() {
return Err(EnvelopeError::EmptyData);
}
if !valid_json(data.as_bytes()) {
return Err(EnvelopeError::InvalidJson);
}
Ok(Self {
namespace,
kind,
data,
})
}
#[must_use]
pub fn namespace(&self) -> &str {
&self.namespace
}
#[must_use]
pub fn kind(&self) -> &str {
&self.kind
}
#[must_use]
pub const fn data(&self) -> &Payload {
&self.data
}
#[must_use]
pub fn into_parts(self) -> (String, String, Payload) {
(self.namespace, self.kind, self.data)
}
}
const MAX_JSON_DEPTH: usize = 10_000;
#[derive(Clone, Copy)]
enum State {
RootValue,
RootDone,
ArrayFirst,
ArrayValue,
ArraySeparator,
ObjectFirst,
ObjectKey,
ObjectColon,
ObjectValue,
ObjectSeparator,
}
fn valid_json(bytes: &[u8]) -> bool {
let mut parser = JsonParser {
bytes,
position: 0,
states: vec![State::RootValue],
};
parser.parse()
}
struct JsonParser<'a> {
bytes: &'a [u8],
position: usize,
states: Vec<State>,
}
impl JsonParser<'_> {
fn parse(&mut self) -> bool {
loop {
self.skip_whitespace();
match *self.states.last().expect("root state is retained") {
State::RootValue => {
if !self.parse_value(State::RootDone) {
return false;
}
}
State::RootDone => return self.position == self.bytes.len(),
State::ArrayFirst => {
if self.take(b']') {
self.states.pop();
} else if !self.parse_value(State::ArraySeparator) {
return false;
}
}
State::ArrayValue => {
if !self.parse_value(State::ArraySeparator) {
return false;
}
}
State::ArraySeparator => {
if self.take(b',') {
*self.states.last_mut().expect("state exists") = State::ArrayValue;
} else if self.take(b']') {
self.states.pop();
} else {
return false;
}
}
State::ObjectFirst => {
if self.take(b'}') {
self.states.pop();
} else {
*self.states.last_mut().expect("state exists") = State::ObjectKey;
}
}
State::ObjectKey => {
if !self.parse_string() {
return false;
}
*self.states.last_mut().expect("state exists") = State::ObjectColon;
}
State::ObjectColon => {
if !self.take(b':') {
return false;
}
*self.states.last_mut().expect("state exists") = State::ObjectValue;
}
State::ObjectValue => {
if !self.parse_value(State::ObjectSeparator) {
return false;
}
}
State::ObjectSeparator => {
if self.take(b',') {
*self.states.last_mut().expect("state exists") = State::ObjectKey;
} else if self.take(b'}') {
self.states.pop();
} else {
return false;
}
}
}
}
}
fn parse_value(&mut self, next: State) -> bool {
self.skip_whitespace();
*self.states.last_mut().expect("state exists") = next;
match self.peek() {
Some(b'{') => {
self.position += 1;
self.push_container(State::ObjectFirst)
}
Some(b'[') => {
self.position += 1;
self.push_container(State::ArrayFirst)
}
Some(b'"') => self.parse_string(),
Some(b't') => self.parse_literal(b"true"),
Some(b'f') => self.parse_literal(b"false"),
Some(b'n') => self.parse_literal(b"null"),
Some(b'-' | b'0'..=b'9') => self.parse_number(),
_ => false,
}
}
fn push_container(&mut self, state: State) -> bool {
if self.states.len() > MAX_JSON_DEPTH {
return false;
}
self.states.push(state);
true
}
fn parse_literal(&mut self, literal: &[u8]) -> bool {
if self.bytes[self.position..].starts_with(literal) {
self.position += literal.len();
true
} else {
false
}
}
fn parse_string(&mut self) -> bool {
if !self.take(b'"') {
return false;
}
while let Some(byte) = self.peek() {
self.position += 1;
match byte {
b'"' => return true,
b'\\' => match self.peek() {
Some(b'"' | b'\\' | b'/' | b'b' | b'f' | b'n' | b'r' | b't') => {
self.position += 1;
}
Some(b'u') => {
self.position += 1;
for _ in 0..4 {
if !self.peek().is_some_and(|digit| digit.is_ascii_hexdigit()) {
return false;
}
self.position += 1;
}
}
_ => return false,
},
0..=0x1f => return false,
_ => {}
}
}
false
}
fn parse_number(&mut self) -> bool {
if self.take(b'-') && self.peek().is_none() {
return false;
}
match self.peek() {
Some(b'0') => self.position += 1,
Some(b'1'..=b'9') => self.take_digits(),
_ => return false,
}
if self.take(b'.') {
if !self.peek().is_some_and(|byte| byte.is_ascii_digit()) {
return false;
}
self.take_digits();
}
if matches!(self.peek(), Some(b'e' | b'E')) {
self.position += 1;
if matches!(self.peek(), Some(b'+' | b'-')) {
self.position += 1;
}
if !self.peek().is_some_and(|byte| byte.is_ascii_digit()) {
return false;
}
self.take_digits();
}
true
}
fn take_digits(&mut self) {
while self.peek().is_some_and(|byte| byte.is_ascii_digit()) {
self.position += 1;
}
}
fn skip_whitespace(&mut self) {
while matches!(self.peek(), Some(b' ' | b'\n' | b'\r' | b'\t')) {
self.position += 1;
}
}
fn take(&mut self, expected: u8) -> bool {
if self.peek() == Some(expected) {
self.position += 1;
true
} else {
false
}
}
fn peek(&self) -> Option<u8> {
self.bytes.get(self.position).copied()
}
}
#[cfg(feature = "serde")]
mod serde_impl {
use std::fmt::{self, Formatter};
use serde_core::de::{Deserialize, Deserializer, Error as _, MapAccess, SeqAccess, Visitor};
use serde_core::ser::{Serialize, SerializeStruct, Serializer};
use super::{Envelope, Payload};
use crate::wire::{self, ByteBuf, Bytes, IdentifierSeed};
const ENVELOPE_FIELDS: &[&str] = &["namespace", "kind", "data"];
impl Serialize for Payload {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
Bytes(&self.0).serialize(serializer)
}
}
impl<'de> Deserialize<'de> for Payload {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
ByteBuf::deserialize(deserializer).map(|buffer| Self(buffer.0))
}
}
impl Serialize for Envelope {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut record = serializer.serialize_struct("Envelope", 3)?;
record.serialize_field("namespace", &self.namespace)?;
record.serialize_field("kind", &self.kind)?;
record.serialize_field("data", &self.data)?;
record.end()
}
}
impl<'de> Deserialize<'de> for Envelope {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_struct("Envelope", ENVELOPE_FIELDS, EnvelopeVisitor)
}
}
struct EnvelopeVisitor;
impl EnvelopeVisitor {
fn build<E>(namespace: String, kind: String, data: Payload) -> Result<Envelope, E>
where
E: serde_core::de::Error,
{
Envelope::try_new(namespace, kind, data).map_err(E::custom)
}
}
impl<'de> Visitor<'de> for EnvelopeVisitor {
type Value = Envelope;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("an opaque envelope")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let namespace = wire::element(&mut sequence, 0)?;
let kind = wire::element(&mut sequence, 1)?;
let data = wire::element(&mut sequence, 2)?;
wire::end(&mut sequence, 3)?;
Self::build(namespace, kind, data)
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut namespace = None;
let mut kind = None;
let mut data = None;
while let Some(field) = entries.next_key_seed(IdentifierSeed(ENVELOPE_FIELDS))? {
match field.0.as_str() {
"namespace" => {
wire::accept(&mut namespace, entries.next_value()?, "namespace")?
}
"kind" => wire::accept(&mut kind, entries.next_value()?, "kind")?,
"data" => wire::accept(&mut data, entries.next_value()?, "data")?,
unknown => return Err(A::Error::unknown_field(unknown, ENVELOPE_FIELDS)),
}
}
Self::build(
wire::require(namespace, "namespace")?,
wire::require(kind, "kind")?,
wire::require(data, "data")?,
)
}
}
}
#[cfg(test)]
#[path = "opaque_tests.rs"]
mod opaque_tests;