netlink_packet_sock_diag/
message.rs

1// SPDX-License-Identifier: MIT
2
3use netlink_packet_core::{
4    NetlinkDeserializable, NetlinkHeader, NetlinkPayload, NetlinkSerializable,
5};
6use netlink_packet_utils::DecodeError;
7use netlink_packet_utils::traits::{Emitable, ParseableParametrized};
8
9use crate::{SOCK_DESTROY, SOCK_DIAG_BY_FAMILY, SockDiagBuffer, inet, unix};
10
11#[derive(Debug, PartialEq, Eq, Clone)]
12pub enum SockDiagRequest {
13    InetRequest(inet::InetRequest),
14    UnixRequest(unix::UnixRequest),
15    InetSockDestroy(inet::InetRequest),
16}
17
18impl SockDiagRequest {
19    pub fn message_type(&self) -> u16 {
20        match self {
21            SockDiagRequest::InetRequest(_) | SockDiagRequest::UnixRequest(_) => {
22                SOCK_DIAG_BY_FAMILY
23            }
24            SockDiagRequest::InetSockDestroy(_) => SOCK_DESTROY,
25        }
26    }
27}
28
29impl Emitable for SockDiagRequest {
30    fn buffer_len(&self) -> usize {
31        match self {
32            SockDiagRequest::InetRequest(msg) => msg.buffer_len(),
33            SockDiagRequest::UnixRequest(msg) => msg.buffer_len(),
34            SockDiagRequest::InetSockDestroy(msg) => msg.buffer_len(),
35        }
36    }
37
38    fn emit(&self, buffer: &mut [u8]) {
39        match self {
40            SockDiagRequest::InetRequest(msg) => msg.emit(buffer),
41            SockDiagRequest::UnixRequest(msg) => msg.emit(buffer),
42            SockDiagRequest::InetSockDestroy(msg) => msg.emit(buffer),
43        }
44    }
45}
46
47impl NetlinkSerializable for SockDiagRequest {
48    fn message_type(&self) -> u16 {
49        self.message_type()
50    }
51
52    fn buffer_len(&self) -> usize {
53        <Self as Emitable>::buffer_len(self)
54    }
55
56    fn serialize(&self, buffer: &mut [u8]) {
57        self.emit(buffer)
58    }
59}
60
61/// `SOCK_DIAG` message deserialization does not take any options.
62#[derive(Default)]
63pub struct EmptyDeserializeOptions;
64
65impl NetlinkDeserializable for SockDiagRequest {
66    type DeserializeOptions = EmptyDeserializeOptions;
67    type Error = DecodeError;
68    fn deserialize(
69        header: &NetlinkHeader,
70        payload: &[u8],
71        _options: EmptyDeserializeOptions,
72    ) -> Result<Self, Self::Error> {
73        let buffer = SockDiagBuffer::new(&payload)?;
74        SockDiagRequest::parse_with_param(&buffer, header.message_type)
75    }
76}
77
78impl From<SockDiagRequest> for NetlinkPayload<SockDiagRequest> {
79    fn from(message: SockDiagRequest) -> Self {
80        NetlinkPayload::InnerMessage(message)
81    }
82}
83
84#[derive(Debug, PartialEq, Eq, Clone)]
85pub enum SockDiagResponse {
86    InetResponse(Box<inet::InetResponse>),
87    UnixResponse(Box<unix::UnixResponse>),
88}
89
90impl SockDiagResponse {
91    pub fn message_type(&self) -> u16 {
92        match self {
93            SockDiagResponse::InetResponse(_) | SockDiagResponse::UnixResponse(_) => {
94                SOCK_DIAG_BY_FAMILY
95            }
96        }
97    }
98}
99
100impl Emitable for SockDiagResponse {
101    fn buffer_len(&self) -> usize {
102        match self {
103            SockDiagResponse::InetResponse(msg) => msg.buffer_len(),
104            SockDiagResponse::UnixResponse(msg) => msg.buffer_len(),
105        }
106    }
107
108    fn emit(&self, buffer: &mut [u8]) {
109        match self {
110            SockDiagResponse::InetResponse(msg) => msg.emit(buffer),
111            SockDiagResponse::UnixResponse(msg) => msg.emit(buffer),
112        }
113    }
114}
115
116impl NetlinkSerializable for SockDiagResponse {
117    fn message_type(&self) -> u16 {
118        self.message_type()
119    }
120
121    fn buffer_len(&self) -> usize {
122        <Self as Emitable>::buffer_len(self)
123    }
124
125    fn serialize(&self, buffer: &mut [u8]) {
126        self.emit(buffer)
127    }
128}
129
130impl NetlinkDeserializable for SockDiagResponse {
131    type DeserializeOptions = EmptyDeserializeOptions;
132    type Error = DecodeError;
133    fn deserialize(
134        header: &NetlinkHeader,
135        payload: &[u8],
136        _options: EmptyDeserializeOptions,
137    ) -> Result<Self, Self::Error> {
138        let buffer = SockDiagBuffer::new(&payload)?;
139        SockDiagResponse::parse_with_param(&buffer, header.message_type)
140    }
141}
142
143impl From<SockDiagResponse> for NetlinkPayload<SockDiagResponse> {
144    fn from(message: SockDiagResponse) -> Self {
145        NetlinkPayload::InnerMessage(message)
146    }
147}
netlink_packet_sock_diag/message.rs

netlink_packet_sock_diag/
message.rs
