--- a/src/vrrpv2.rs Wed Dec 07 13:35:25 2022 +0530
+++ b/src/vrrpv2.rs Sun Jan 01 11:59:24 2023 +0530
@@ -1,21 +1,45 @@
+use nom::bits::{bits, streaming::take};
+use nom::combinator::map_res;
+use nom::error::{Error, ErrorKind};
+use nom::multi::count;
+use nom::number::complete::{be_u16, be_u32, u8};
+use nom::sequence::tuple;
+use nom::{Err, IResult};
use std::net::Ipv4Addr;
-pub enum VRRPv2Error {}
+const VRRP_REQUIRED_VERSION: u8 = 2;
+const VRRP_REQUIRED_TYPE: u8 = 1; // Advertisement
-pub enum VRRPVersion {
- V2(u8),
+#[derive(Debug, Clone, PartialEq)]
+pub enum VRRPv2Error {
+ VRRPv2ParseError,
}
+type NomError<'a> = nom::Err<nom::error::Error<&'a [u8]>>;
+impl From<NomError<'_>> for VRRPv2Error {
+ fn from(_: NomError) -> Self {
+ Self::VRRPv2ParseError
+ }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum VRRPVersion {
+ V2,
+}
+
+#[derive(Debug, PartialEq)]
pub enum VRRPv2Type {
VRRPv2Advertisement,
}
+#[derive(Debug, PartialEq)]
pub enum VRRPv2AuthType {
VRRPv2AuthNoAuth = 0x00,
VRRPv2AuthReserved1 = 0x01,
VRRPv2AuthReserved2 = 0x02,
}
+#[derive(Debug, PartialEq)]
pub struct VRRPv2 {
pub version: VRRPVersion,
pub type_: VRRPv2Type,
@@ -28,6 +52,117 @@
pub ip_addrs: Vec<Ipv4Addr>,
}
-pub fn from_bytes(_bytes: &[u8]) -> Result<&VRRPv2, VRRPv2Error> {
- unimplemented!()
+fn two_nibbles(input: &[u8]) -> IResult<&[u8], (u8, u8)> {
+ bits::<_, _, Error<(&[u8], usize)>, _, _>(tuple((take(4usize), take(4usize))))(input)
+}
+
+fn parse_version_type(input: &[u8]) -> IResult<&[u8], (VRRPVersion, VRRPv2Type)> {
+ let (input, pair) = two_nibbles(input)?;
+ match pair {
+ (VRRP_REQUIRED_VERSION, VRRP_REQUIRED_TYPE) => {
+ Ok((input, (VRRPVersion::V2, VRRPv2Type::VRRPv2Advertisement)))
+ }
+ _ => Err(Err::Error(Error::new(input, ErrorKind::Alt))),
+ }
+}
+
+fn parse_auth_type(input: &[u8]) -> IResult<&[u8], VRRPv2AuthType> {
+ map_res(u8, |auth_type| {
+ Ok(match auth_type {
+ 0 => VRRPv2AuthType::VRRPv2AuthNoAuth,
+ 1 => VRRPv2AuthType::VRRPv2AuthReserved1,
+ 2 => VRRPv2AuthType::VRRPv2AuthReserved2,
+ _ => return Err(Err::Error(Error::new(input, ErrorKind::Alt))),
+ })
+ })(input)
+}
+
+fn parse(input: &[u8]) -> IResult<&[u8], VRRPv2> {
+ let (input, (version, type_)) = parse_version_type(input)?;
+ let (input, virtual_router_id) = u8(input)?;
+ let (input, priority) = u8(input)?;
+ let (input, count_ip_addrs) = u8(input)?;
+ let (input, auth_type) = parse_auth_type(input)?;
+ let (input, advertisement_interval) = u8(input)?;
+ let (input, checksum) = be_u16(input)?;
+ // TODO verify checksum
+ let (input, xs) = count(be_u32, usize::from(count_ip_addrs))(input)?;
+ let ip_addrs = xs.into_iter().map(Ipv4Addr::from).collect();
+ Ok((
+ input,
+ VRRPv2 {
+ version,
+ type_,
+ virtual_router_id,
+ priority,
+ count_ip_addrs,
+ auth_type,
+ advertisement_interval,
+ checksum,
+ ip_addrs,
+ },
+ ))
}
+
+pub fn from_bytes(bytes: &[u8]) -> Result<VRRPv2, VRRPv2Error> {
+ match parse(bytes) {
+ Ok((_, v)) => Ok(v),
+ Err(e) => Err(e.into()),
+ }
+}
+
+#[test]
+fn test_standard_bytes() {
+ let bytes = [
+ 0x21, 0x01, 0x64, 0x01, 0x00, 0x01, 0xba, 0x52, 0xc0, 0xa8, 0x00, 0x01, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+ let got = from_bytes(&bytes).unwrap();
+ let expected = VRRPv2 {
+ version: VRRPVersion::V2,
+ type_: VRRPv2Type::VRRPv2Advertisement,
+ virtual_router_id: 1,
+ priority: 100,
+ count_ip_addrs: 1,
+ auth_type: VRRPv2AuthType::VRRPv2AuthNoAuth,
+ checksum: 47698,
+ advertisement_interval: 1,
+ ip_addrs: vec![Ipv4Addr::from([192, 168, 0, 1])],
+ };
+ assert_eq!(got, expected);
+}
+
+#[test]
+fn test_incomplete_bytes() {
+ let bytes = [0x21, 0x01];
+ let got = from_bytes(&bytes);
+ assert_eq!(got.is_err(), true);
+ assert_eq!(got.err(), Some(VRRPv2Error::VRRPv2ParseError));
+}
+
+#[test]
+fn test_invalid_version_type() {
+ let bytes = [
+ 0x00, 0x01, 0x64, 0x01, 0x00, 0x01, 0xba, 0x52, 0xc0, 0xa8, 0x00, 0x01, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+ let got = from_bytes(&bytes);
+ assert_eq!(got.is_err(), true);
+ assert_eq!(got.err(), Some(VRRPv2Error::VRRPv2ParseError));
+}
+
+#[test]
+fn test_invalid_auth_type() {
+ let bytes = [
+ 0x21, 0x01, 0x64, 0x01, 0x03, 0x01, 0xba, 0x52, 0xc0, 0xa8, 0x00, 0x01, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+ let got = from_bytes(&bytes);
+ assert_eq!(got.is_err(), true);
+ assert_eq!(got.err(), Some(VRRPv2Error::VRRPv2ParseError));
+}
+
+#[test]
+fn test_invalid_checksum() {
+ panic!("fix me");
+}