From 07561131e9ec3d1f3aef99a8df2e3b9b7282156e Mon Sep 17 00:00:00 2001 From: Max Audron Date: Fri, 17 Jan 2020 12:30:27 +0100 Subject: add error handling --- src/protocol/primitive/basic.rs | 149 +++++++++++++++++--------------- src/protocol/primitive/mod.rs | 17 ++-- src/protocol/primitive/variant.rs | 177 +++++++++++++++++++------------------- 3 files changed, 181 insertions(+), 162 deletions(-) (limited to 'src/protocol/primitive') diff --git a/src/protocol/primitive/basic.rs b/src/protocol/primitive/basic.rs index 30de1c7..15b712f 100644 --- a/src/protocol/primitive/basic.rs +++ b/src/protocol/primitive/basic.rs @@ -29,122 +29,133 @@ pub const UCHAR: u32 = 0x00000086; // uint8_t extern crate byteorder; use std::io::Cursor; -use byteorder::{ByteOrder, BigEndian, ReadBytesExt}; +use byteorder::{BigEndian, ReadBytesExt}; -use std::io::Read; use std::vec::Vec; +use std::result::Result; use std::convert::TryInto; use crate::util; +use crate::protocol::error::ErrorKind; use crate::protocol::primitive::{deserialize, serialize, qread}; impl deserialize::Deserialize for bool { - fn parse(b: &[u8]) -> (usize, Self) { - if b[0] == 0 { return (1, false) } else { return (1, true) }; + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> { + if b[0] == 0 { + return Ok((1, false)) + } else if b[0] == 1 { + return Ok((1, true)) + } else { + return Err(ErrorKind::BoolOutOfRange); + }; } } impl qread::QRead for bool { - fn read(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut b[0..1]).unwrap() + fn read(s: &mut T, b: &mut [u8]) -> Result { + Ok(s.read(&mut b[0..1])?) } } impl deserialize::Deserialize for u64 { - fn parse(b: &[u8]) -> (usize, Self) { - return (8, BigEndian::read_u64(b)); + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> { + let mut rdr = Cursor::new(&b[0..8]); + return Ok((8, rdr.read_u64::()?)); } } impl qread::QRead for u64 { - fn read(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut b[0..8]).unwrap() + fn read(s: &mut T, b: &mut [u8]) -> Result { + Ok(s.read(&mut b[0..8])?) } } impl deserialize::Deserialize for u32 { - fn parse(b: &[u8]) -> (usize, Self) { - // self = &rdr.read_u32::().unwrap() - return (4, BigEndian::read_u32(b)); + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> { + let mut rdr = Cursor::new(&b[0..4]); + return Ok((4, rdr.read_u32::()?)); } } impl qread::QRead for u32 { - fn read(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut b[0..4]).unwrap() + fn read(s: &mut T, b: &mut [u8]) -> Result { + Ok(s.read(&mut b[0..4])?) } } impl deserialize::Deserialize for u16 { - fn parse(b: &[u8]) -> (usize, Self) { - return (2, BigEndian::read_u16(b)); + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> { + let mut rdr = Cursor::new(&b[0..2]); + return Ok((2, rdr.read_u16::()?)); } } impl qread::QRead for u16 { - fn read(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut b[0..2]).unwrap() + fn read(s: &mut T, b: &mut [u8]) -> Result { + Ok(s.read(&mut b[0..2])?) } } impl deserialize::Deserialize for u8 { - fn parse(b: &[u8]) -> (usize, Self) { - return (1, b[0]); + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> { + return Ok((1, b[0])); } } impl qread::QRead for u8 { - fn read(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut [b[0]]).unwrap() + fn read(s: &mut T, b: &mut [u8]) -> Result { + Ok(s.read(&mut [b[0]])?) } } impl deserialize::Deserialize for i64 { - fn parse(b: &[u8]) -> (usize, Self) { - return (8, BigEndian::read_i64(b)); + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> { + let mut rdr = Cursor::new(&b[0..8]); + return Ok((8, rdr.read_i64::()?)); } } impl qread::QRead for i64 { - fn read(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut b[0..8]).unwrap() + fn read(s: &mut T, b: &mut [u8]) -> Result { + Ok(s.read(&mut b[0..8])?) } } impl deserialize::Deserialize for i32 { - fn parse(b: &[u8]) -> (usize, Self) { + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> { let mut rdr = Cursor::new(&b[0..4]); - return (4, rdr.read_i32::().unwrap()); + return Ok((4, rdr.read_i32::()?)); } } impl qread::QRead for i32 { - fn read(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut b[0..4]).unwrap() + fn read(s: &mut T, b: &mut [u8]) -> Result { + Ok(s.read(&mut b[0..4])?) } } impl deserialize::Deserialize for i16 { - fn parse(b: &[u8]) -> (usize, Self) { - return (2, BigEndian::read_i16(b)); + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> { + let mut rdr = Cursor::new(&b[0..2]); + return Ok((2, rdr.read_i16::()?)); } } impl qread::QRead for i16 { - fn read(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut b[0..2]).unwrap() + fn read(s: &mut T, b: &mut [u8]) -> Result { + Ok(s.read(&mut b[0..2])?) } } impl deserialize::Deserialize for i8 { - fn parse(b: &[u8]) -> (usize, Self) { - return (1, b[0].try_into().unwrap()); + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> { + return Ok((1, b[0].try_into()?)); } } impl qread::QRead for i8 { - fn read(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut [b[0]]).unwrap() + fn read(s: &mut T, b: &mut [u8]) -> Result { + return Ok(s.read(&mut [b[0]])?) } } @@ -152,7 +163,7 @@ impl qread::QRead for i8 { pub type String = std::string::String; impl serialize::Serialize for String { - fn serialize(&self) -> Vec { + fn serialize(&self) -> Result, ErrorKind> { let mut res: Vec = Vec::new(); let utf16: Vec = self.encode_utf16().collect(); @@ -161,109 +172,109 @@ impl serialize::Serialize for String { } util::prepend_byte_len(&mut res); - return res; + return Ok(res); } } impl serialize::SerializeUTF8 for String { - fn serialize_utf8(&self) -> Vec { + fn serialize_utf8(&self) -> Result, ErrorKind> { let mut res: Vec = Vec::new(); res.extend(self.clone().into_bytes()); util::prepend_byte_len(&mut res); - return res; + return Ok(res); } } impl deserialize::Deserialize for String { - 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 ulen = len as usize; let mut pos: usize = 4; let mut chars: Vec = Vec::new(); loop { if pos >= (ulen + 4) { break; } - let (slen, uchar) = u16::parse(&b[pos..(pos+2)]); + let (slen, uchar) = u16::parse(&b[pos..(pos+2)])?; chars.push(uchar); pos += slen; } let res: String = String::from_utf16(&chars).unwrap(); - return (pos, res); + return Ok((pos, res)); } } impl deserialize::DeserializeUTF8 for String { - fn parse_utf8(b: &[u8]) -> (usize, Self) { + fn parse_utf8(b: &[u8]) -> Result<(usize, Self), ErrorKind> { use crate::protocol::primitive::deserialize::Deserialize; - let (_, len) = i32::parse(&b[0..4]); + let (_, len) = i32::parse(&b[0..4])?; let ulen = len as usize; - let res: String = String::from_utf8(b[4..(ulen+4)].to_vec()).unwrap(); - return (ulen + 4, res); + let res: String = String::from_utf8(b[4..(ulen+4)].to_vec())?; + return Ok((ulen + 4, res)); } } impl qread::QRead for String { - fn read(s: &mut T, b: &mut [u8]) -> usize { + fn read(s: &mut T, b: &mut [u8]) -> Result { use crate::protocol::primitive::deserialize::Deserialize; - s.read(&mut b[0..4]).unwrap(); - let (_, len) = i32::parse(&b[0..4]); + s.read(&mut b[0..4])?; + let (_, len) = i32::parse(&b[0..4])?; let ulen = len as usize; - s.read(&mut b[4..(4+ulen)]).unwrap(); + s.read(&mut b[4..(4+ulen)])?; - return 4 + ulen; + return Ok(4 + ulen); } } pub type StringList = Vec; impl serialize::Serialize for StringList { - fn serialize(&self) -> Vec { - let len: i32 = self.len().try_into().unwrap(); + fn serialize(&self) -> Result, ErrorKind> { + let len: i32 = self.len().try_into()?; let mut res: Vec = Vec::new(); res.extend(len.to_be_bytes().iter()); for x in self { - res.extend(x.serialize()); + res.extend(x.serialize()?); } - return res; + return Ok(res); } } impl deserialize::Deserialize for StringList { - 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: StringList = StringList::new(); let mut pos = 4; if len > 0 { for _ in 0..len { - let (lpos, val) = String::parse(&b[pos..]); + let (lpos, val) = String::parse(&b[pos..])?; pos += lpos; res.push(val); } } - return (pos, res); + return Ok((pos, res)); } } impl qread::QRead for StringList { - fn read(s: &mut T, b: &mut [u8]) -> usize { + fn read(s: &mut T, b: &mut [u8]) -> Result { use crate::protocol::primitive::deserialize::Deserialize; - s.read(&mut b[0..4]).unwrap(); - let (_, len) = i32::parse(&b[0..4]); + s.read(&mut b[0..4])?; + let (_, len) = i32::parse(&b[0..4])?; let mut pos: usize = 4; for _ in 0..len { - pos += String::read(s, &mut b[pos..]); + pos += String::read(s, &mut b[pos..])?; } - return pos; + return Ok(pos); } } diff --git a/src/protocol/primitive/mod.rs b/src/protocol/primitive/mod.rs index 2cdd20a..42f6aae 100644 --- a/src/protocol/primitive/mod.rs +++ b/src/protocol/primitive/mod.rs @@ -5,26 +5,33 @@ pub mod variant; pub use basic::*; pub use variant::*; + pub mod serialize { + use crate::protocol::error::ErrorKind; + pub trait Serialize { - fn serialize(&self) -> Vec; + fn serialize(&self) -> Result, ErrorKind>; } pub trait SerializeUTF8 { - fn serialize_utf8(&self) -> Vec; + fn serialize_utf8(&self) -> Result, ErrorKind>; } } pub mod deserialize { + use crate::protocol::error::ErrorKind; + pub trait Deserialize { - fn parse(b: &[u8]) -> (usize, Self); + fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> where Self: std::marker::Sized ; } pub trait DeserializeUTF8 { - fn parse_utf8(b: &[u8]) -> (usize, Self); + fn parse_utf8(b: &[u8]) -> Result<(usize, Self), ErrorKind> where Self: std::marker::Sized ; } } pub mod qread { + use crate::protocol::error::ErrorKind; + pub trait QRead { - fn read(stream: &mut T, buf: &mut [u8]) -> usize; + fn read(stream: &mut T, buf: &mut [u8]) -> Result; } } 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; impl Serialize for VariantMap { - fn serialize<'a>(&'a self) -> Vec { + fn serialize<'a>(&'a self) -> Result, ErrorKind> { let mut res: Vec = 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(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut b[0..4]).unwrap(); + fn read(s: &mut T, b: &mut [u8]) -> Result { + 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; impl Serialize for VariantList { - fn serialize(&self) -> Vec { - let len: i32 = self.len().try_into().unwrap(); + fn serialize(&self) -> Result, ErrorKind> { + let len: i32 = self.len().try_into()?; let mut res: Vec = 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(s: &mut T, b: &mut [u8]) -> usize { - s.read(&mut b[0..4]).unwrap(); + fn read(s: &mut T, b: &mut [u8]) -> Result { + 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 { + fn serialize(&self) -> Result, ErrorKind> { let unknown: u8 = 0x00; let mut res: Vec = 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(s: &mut T, b: &mut [u8]) -> usize { + fn read(s: &mut T, b: &mut [u8]) -> Result { - 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); } } -- cgit v1.2.3