aboutsummaryrefslogtreecommitdiff
path: root/src/protocol/primitive/variant.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/protocol/primitive/variant.rs')
-rw-r--r--src/protocol/primitive/variant.rs177
1 files changed, 89 insertions, 88 deletions
diff --git a/src/protocol/primitive/variant.rs b/src/protocol/primitive/variant.rs
index fdf93ad..8c6173f 100644
--- a/src/protocol/primitive/variant.rs
+++ b/src/protocol/primitive/variant.rs
@@ -8,60 +8,61 @@ use crate::protocol::primitive::serialize::{Serialize, SerializeUTF8};
use crate::protocol::primitive::deserialize::{Deserialize, DeserializeUTF8};
use crate::protocol::primitive::qread::QRead;
use crate::protocol::primitive::{String,StringList};
+use crate::protocol::error::ErrorKind;
use crate::protocol::primitive;
pub type VariantMap = HashMap<String, Variant>;
impl Serialize for VariantMap {
- fn serialize<'a>(&'a self) -> Vec<u8> {
+ fn serialize<'a>(&'a self) -> Result<Vec<u8>, ErrorKind> {
let mut res: Vec<u8> = Vec::new();
for (k, v) in self {
- res.extend(k.serialize());
- res.extend(v.serialize());
+ res.extend(k.serialize()?);
+ res.extend(v.serialize()?);
}
- let len: i32 = self.len().try_into().unwrap();
+ let len: i32 = self.len().try_into()?;
util::insert_bytes(0, &mut res, &mut len.to_be_bytes());
- return res;
+ return Ok(res);
}
}
impl Deserialize for VariantMap {
- fn parse(b: &[u8]) -> (usize, Self) {
- let (_, len) = i32::parse(&b[0..4]);
+ fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+ let (_, len) = i32::parse(&b[0..4])?;
let mut pos = 4;
let mut map = VariantMap::new();
for _ in 0..len {
- let (nlen, name) = String::parse(&b[(pos)..]);
+ let (nlen, name) = String::parse(&b[(pos)..])?;
pos += nlen;
- let (vlen, value) = Variant::parse(&b[(pos)..]);
+ let (vlen, value) = Variant::parse(&b[(pos)..])?;
pos += vlen;
map.insert(name, value);
}
- return (pos, map);
+ return Ok((pos, map));
}
}
impl QRead for VariantMap {
- fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
- s.read(&mut b[0..4]).unwrap();
+ fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+ s.read(&mut b[0..4])?;
- let (_, len) = i32::parse(&b[0..4]);
+ let (_, len) = i32::parse(&b[0..4])?;
let mut pos = 4;
for _ in 0..len {
- pos += String::read(s, &mut b[pos..]);
- pos += Variant::read(s, &mut b[(pos+3..)]);
+ pos += String::read(s, &mut b[pos..])?;
+ pos += Variant::read(s, &mut b[(pos+3..)])?;
}
- return pos;
+ return Ok(pos);
}
}
@@ -69,47 +70,47 @@ impl QRead for VariantMap {
pub type VariantList = Vec<Variant>;
impl Serialize for VariantList {
- fn serialize(&self) -> Vec<u8> {
- let len: i32 = self.len().try_into().unwrap();
+ fn serialize(&self) -> Result<Vec<u8>, ErrorKind> {
+ let len: i32 = self.len().try_into()?;
let mut res: Vec<u8> = Vec::new();
res.extend(len.to_be_bytes().iter());
for v in self {
- res.extend(v.serialize().iter());
+ res.extend(v.serialize()?.iter());
}
- return res;
+ return Ok(res);
}
}
impl Deserialize for VariantList {
- fn parse(b: &[u8]) -> (usize, Self) {
- let (_, len) = i32::parse(&b[0..4]);
+ fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+ let (_, len) = i32::parse(&b[0..4])?;
let mut res: VariantList = VariantList::new();
let mut pos: usize = 4;
for _ in 0..len {
- let (vlen, val) = Variant::parse(&b[pos..]);
+ let (vlen, val) = Variant::parse(&b[pos..])?;
res.push(val);
pos += vlen;
}
- return (pos, res);
+ return Ok((pos, res));
}
}
impl QRead for VariantList {
- fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
- s.read(&mut b[0..4]).unwrap();
+ fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+ s.read(&mut b[0..4])?;
- let (_, len) = i32::parse(&b[0..4]);
+ let (_, len) = i32::parse(&b[0..4])?;
let mut pos = 4;
for _ in 0..len {
- pos += Variant::read(s, &mut b[(pos+3..)]);
+ pos += Variant::read(s, &mut b[(pos+3..)])?;
}
- return pos;
+ return Ok(pos);
}
}
@@ -135,38 +136,38 @@ pub enum Variant {
}
impl Serialize for Variant {
- fn serialize(&self) -> Vec<u8> {
+ fn serialize(&self) -> Result<Vec<u8>, ErrorKind> {
let unknown: u8 = 0x00;
let mut res: Vec<u8> = Vec::new();
match self {
Variant::Unknown => {
- return res;
+ return Err(ErrorKind::UnknownVariant);
},
Variant::VariantMap(v) => {
res.extend(primitive::QVARIANTMAP.to_be_bytes().iter());
res.extend(unknown.to_be_bytes().iter());
- res.extend(v.serialize().iter());
+ res.extend(v.serialize()?.iter());
},
Variant::VariantList(v) => {
res.extend(primitive::QVARIANTLIST.to_be_bytes().iter());
res.extend(unknown.to_be_bytes().iter());
- res.extend(v.serialize().iter());
+ res.extend(v.serialize()?.iter());
},
Variant::String(v) => {
res.extend(primitive::QSTRING.to_be_bytes().iter());
res.extend(unknown.to_be_bytes().iter());
- res.extend(v.serialize().iter());
+ res.extend(v.serialize()?.iter());
},
Variant::StringUTF8(v) => {
res.extend(primitive::QBYTEARRAY.to_be_bytes().iter());
res.extend(unknown.to_be_bytes().iter());
- res.extend(v.serialize_utf8().iter());
+ res.extend(v.serialize_utf8()?.iter());
},
Variant::StringList(v) => {
res.extend(primitive::QSTRINGLIST.to_be_bytes().iter());
res.extend(unknown.to_be_bytes().iter());
- res.extend(v.serialize().iter());
+ res.extend(v.serialize()?.iter());
},
Variant::bool(v) => {
res.extend(primitive::BOOL.to_be_bytes().iter());
@@ -216,13 +217,13 @@ impl Serialize for Variant {
},
}
- return res
+ return Ok(res)
}
}
impl Deserialize for Variant {
- fn parse(b: &[u8]) -> (usize, Self) {
- let (_, qtype) = i32::parse(&b[0..4]);
+ fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+ let (_, qtype) = i32::parse(&b[0..4])?;
let qtype = qtype as u32;
#[allow(unused_variables)]
@@ -231,96 +232,96 @@ impl Deserialize for Variant {
let len = 5;
match qtype {
primitive::QVARIANTMAP => {
- let (vlen, value) = VariantMap::parse(&b[len..]);
- return (len+vlen, Variant::VariantMap(value));
+ let (vlen, value) = VariantMap::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::VariantMap(value)));
},
primitive::QVARIANTLIST => {
- let (vlen, value) = VariantList::parse(&b[len..]);
- return (len+vlen, Variant::VariantList(value));
+ let (vlen, value) = VariantList::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::VariantList(value)));
},
primitive::QSTRING => {
- let (vlen, value) = String::parse(&b[len..]);
- return (len+vlen, Variant::String(value.clone()));
+ let (vlen, value) = String::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::String(value.clone())));
},
primitive::QBYTEARRAY => {
- let (vlen, value) = String::parse_utf8(&b[len..]);
- return (len+vlen, Variant::StringUTF8(value.clone()));
+ let (vlen, value) = String::parse_utf8(&b[len..])?;
+ return Ok((len+vlen, Variant::StringUTF8(value.clone())));
},
primitive::QSTRINGLIST => {
- let (vlen, value) = StringList::parse(&b[len..]);
- return (len+vlen, Variant::StringList(value.clone()));
+ let (vlen, value) = StringList::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::StringList(value.clone())));
},
primitive::BOOL => {
- let (vlen, value) = bool::parse(&b[len..]);
- return (len+vlen, Variant::bool(value));
+ let (vlen, value) = bool::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::bool(value)));
},
primitive::ULONG => {
- let (vlen, value) = u64::parse(&b[len..]);
- return (len+vlen, Variant::u64(value));
+ let (vlen, value) = u64::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::u64(value)));
},
primitive::UINT => {
- let (vlen, value) = u32::parse(&b[len..]);
- return (len+vlen, Variant::u32(value));
+ let (vlen, value) = u32::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::u32(value)));
},
primitive::USHORT => {
- let (vlen, value) = u16::parse(&b[len..]);
- return (len+vlen, Variant::u16(value));
+ let (vlen, value) = u16::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::u16(value)));
},
primitive::UCHAR => {
- let (vlen, value) = u8::parse(&b[len..]);
- return (len+vlen, Variant::u8(value));
+ let (vlen, value) = u8::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::u8(value)));
},
primitive::LONG => {
- let (vlen, value) = i64::parse(&b[len..]);
- return (len+vlen, Variant::i64(value));
+ let (vlen, value) = i64::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::i64(value)));
},
primitive::INT => {
- let (vlen, value) = i32::parse(&b[len..]);
- return (len+vlen, Variant::i32(value));
+ let (vlen, value) = i32::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::i32(value)));
},
primitive::SHORT => {
- let (vlen, value) = i16::parse(&b[len..]);
- return (len+vlen, Variant::i16(value));
+ let (vlen, value) = i16::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::i16(value)));
},
primitive::CHAR => {
- let (vlen, value) = i8::parse(&b[len..]);
- return (len+vlen, Variant::i8(value));
+ let (vlen, value) = i8::parse(&b[len..])?;
+ return Ok((len+vlen, Variant::i8(value)));
},
_ => {
- return (0, Variant::Unknown);
+ return Err(ErrorKind::UnknownVariant);
}
}
}
}
impl QRead for Variant {
- fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
+ fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
- s.read(&mut b[0..4]).unwrap();
- let (_, qtype) = i32::parse(&b[0..4]);
+ s.read(&mut b[0..4])?;
+ let (_, qtype) = i32::parse(&b[0..4])?;
let qtype = qtype as u32;
- s.read(&mut [b[4]]).unwrap();
+ s.read(&mut [b[4]])?;
let mut len = 5;
match qtype {
- primitive::QVARIANTMAP => len += VariantMap::read(s, &mut b[len..]),
- primitive::QVARIANTLIST => len += VariantList::read(s, &mut b[len..]),
- primitive::QSTRING => len += String::read(s, &mut b[len..]),
- primitive::QBYTEARRAY => len += String::read(s, &mut b[len..]),
- primitive::QSTRINGLIST => len += StringList::read(s, &mut b[len..]),
- primitive::BOOL => len += bool::read(s, &mut b[len..]),
- primitive::ULONG => len += u64::read(s, &mut b[len..]),
- primitive::UINT => len += u32::read(s, &mut b[len..]),
- primitive::USHORT => len += u16::read(s, &mut b[len..]),
- primitive::UCHAR => len += u8::read(s, &mut b[len..]),
- primitive::LONG => len += i64::read(s, &mut b[len..]),
- primitive::INT => len += i32::read(s, &mut b[len..]),
- primitive::SHORT => len += i16::read(s, &mut b[len..]),
- primitive::CHAR => len += i8::read(s, &mut b[len..]),
- _ => return len
+ primitive::QVARIANTMAP => len += VariantMap::read(s, &mut b[len..])?,
+ primitive::QVARIANTLIST => len += VariantList::read(s, &mut b[len..])?,
+ primitive::QSTRING => len += String::read(s, &mut b[len..])?,
+ primitive::QBYTEARRAY => len += String::read(s, &mut b[len..])?,
+ primitive::QSTRINGLIST => len += StringList::read(s, &mut b[len..])?,
+ primitive::BOOL => len += bool::read(s, &mut b[len..])?,
+ primitive::ULONG => len += u64::read(s, &mut b[len..])?,
+ primitive::UINT => len += u32::read(s, &mut b[len..])?,
+ primitive::USHORT => len += u16::read(s, &mut b[len..])?,
+ primitive::UCHAR => len += u8::read(s, &mut b[len..])?,
+ primitive::LONG => len += i64::read(s, &mut b[len..])?,
+ primitive::INT => len += i32::read(s, &mut b[len..])?,
+ primitive::SHORT => len += i16::read(s, &mut b[len..])?,
+ primitive::CHAR => len += i8::read(s, &mut b[len..])?,
+ _ => return Err(ErrorKind::UnknownVariant)
}
- return len;
+ return Ok(len);
}
}
generated by cgit v1.2.3 (git 2.46.0) at 2026-03-03 18:03:58 +0000