netlink_packet_generic/ctrl/nlas/
mcast.rs

1// SPDX-License-Identifier: MIT
2
3use crate::constants::*;
4use anyhow::Context;
5use byteorder::{ByteOrder, NativeEndian};
6use netlink_packet_utils::nla::{Nla, NlaBuffer};
7use netlink_packet_utils::parsers::*;
8use netlink_packet_utils::traits::*;
9use netlink_packet_utils::DecodeError;
10use std::mem::size_of_val;
11use std::ops::Deref;
12
13pub(crate) struct McastGroupList(Vec<McastGroup>);
14
15impl Deref for McastGroupList {
16    type Target = Vec<McastGroup>;
17
18    fn deref(&self) -> &Self::Target {
19        &self.0
20    }
21}
22
23impl From<&Vec<Vec<McastGrpAttrs>>> for McastGroupList {
24    fn from(groups: &Vec<Vec<McastGrpAttrs>>) -> Self {
25        Self(
26            groups
27                .iter()
28                .cloned()
29                .enumerate()
30                .map(|(index, nlas)| McastGroup { index: index as u16, nlas })
31                .collect(),
32        )
33    }
34}
35
36#[derive(Clone, Debug, PartialEq, Eq)]
37pub struct McastGroup {
38    pub index: u16,
39    pub nlas: Vec<McastGrpAttrs>,
40}
41
42impl Nla for McastGroup {
43    fn value_len(&self) -> usize {
44        self.nlas.as_slice().buffer_len()
45    }
46
47    fn kind(&self) -> u16 {
48        self.index + 1
49    }
50
51    fn emit_value(&self, buffer: &mut [u8]) {
52        self.nlas.as_slice().emit(buffer);
53    }
54}
55
56#[derive(Clone, Debug, PartialEq, Eq)]
57pub enum McastGrpAttrs {
58    Name(String),
59    Id(u32),
60}
61
62impl Nla for McastGrpAttrs {
63    fn value_len(&self) -> usize {
64        use McastGrpAttrs::*;
65        match self {
66            Name(s) => s.as_bytes().len() + 1,
67            Id(v) => size_of_val(v),
68        }
69    }
70
71    fn kind(&self) -> u16 {
72        use McastGrpAttrs::*;
73        match self {
74            Name(_) => CTRL_ATTR_MCAST_GRP_NAME,
75            Id(_) => CTRL_ATTR_MCAST_GRP_ID,
76        }
77    }
78
79    fn emit_value(&self, buffer: &mut [u8]) {
80        use McastGrpAttrs::*;
81        match self {
82            Name(s) => {
83                buffer[..s.len()].copy_from_slice(s.as_bytes());
84                buffer[s.len()] = 0;
85            }
86            Id(v) => NativeEndian::write_u32(buffer, *v),
87        }
88    }
89}
90
91impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>> for McastGrpAttrs {
92    type Error = DecodeError;
93    fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
94        let payload = buf.value();
95        Ok(match buf.kind() {
96            CTRL_ATTR_MCAST_GRP_NAME => {
97                Self::Name(parse_string(payload).context("invalid CTRL_ATTR_MCAST_GRP_NAME value")?)
98            }
99            CTRL_ATTR_MCAST_GRP_ID => {
100                Self::Id(parse_u32(payload).context("invalid CTRL_ATTR_MCAST_GRP_ID value")?)
101            }
102            kind => return Err(DecodeError::from(format!("Unknown NLA type: {kind}"))),
103        })
104    }
105}