1pub use minicbor::{self, Encode, Decode};
2 use serde::{Deserialize, Serialize};
3 use serde_big_array::BigArray;#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
4 pub struct About {#[cbor(n(0), with = "minicbor::bytes")]
5 #[serde(serialize_with = "ser_bytes_as_str")]
6 #[serde(deserialize_with = "de_str_as_bytes")]
7 pub site: [u8; 32],#[cbor(n(1), with = "minicbor::bytes")]
8 #[serde(serialize_with = "ser_bytes_as_str")]
9 #[serde(deserialize_with = "de_str_as_bytes")]
10 pub ver_os: [u8; 32],#[cbor(n(2), with = "minicbor::bytes")]
11 #[serde(serialize_with = "ser_bytes_as_str")]
12 #[serde(deserialize_with = "de_str_as_bytes")]
13 pub ver_atx: [u8; 32],#[cbor(n(3), with = "minicbor::bytes")]
14 #[serde(serialize_with = "ser_bytes_as_str")]
15 #[serde(deserialize_with = "de_str_as_bytes")]
16 pub ver_prj: [u8; 32],#[cbor(n(4), with = "minicbor::bytes")]
17 #[serde(serialize_with = "ser_bytes_as_str")]
18 #[serde(deserialize_with = "de_str_as_bytes")]
19 pub product: [u8; 32],#[cbor(n(5), with = "minicbor::bytes")]
20 #[serde(serialize_with = "ser_bytes_as_str")]
21 #[serde(deserialize_with = "de_str_as_bytes")]
22 pub board: [u8; 32],#[cbor(n(6), with = "minicbor::bytes")]
23 #[serde(serialize_with = "ser_bytes_as_str")]
24 #[serde(deserialize_with = "de_str_as_bytes")]
25 pub sid: [u8; 32],#[cbor(n(7), with = "minicbor::bytes")]
26 #[serde(serialize_with = "ser_bytes_as_str")]
27 #[serde(deserialize_with = "de_str_as_bytes")]
28 pub mac: [u8; 32],}impl Default for About {
29 fn default() -> About {
30 About {site: Default::default(),ver_os: Default::default(),ver_atx: Default::default(),ver_prj: Default::default(),product: Default::default(),board: Default::default(),sid: Default::default(),mac: Default::default(),}
31 }
32 }#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
33 pub struct Common {#[n(0)]
34 pub about: About,#[n(1)]
35 pub network: Network,}impl Default for Common {
36 fn default() -> Common {
37 Common {about: Default::default(),network: Default::default(),}
38 }
39 }#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
40 pub struct Network {#[n(0)]
41 pub security: NetworkSecurity,#[n(1)]
42 pub ip: NetworkIp,#[n(2)]
43 pub ports: NetworkPorts,#[n(3)]
44 pub cert: NetworkCertSetup,#[n(4)]
45 pub zmtp: NetworkZmtp,}impl Default for Network {
46 fn default() -> Network {
47 Network {security: Default::default(),ip: Default::default(),ports: Default::default(),cert: Default::default(),zmtp: Default::default(),}
48 }
49 }#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
50 pub struct NetworkCertSetup {}impl Default for NetworkCertSetup {
51 fn default() -> NetworkCertSetup {
52 NetworkCertSetup {}
53 }
54 }#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
55 pub struct NetworkIp {#[n(0)]
56 pub keep_alive: bool,#[cbor(n(1), with = "minicbor::bytes")]
57 #[serde(serialize_with = "ser_bytes_as_str")]
58 #[serde(deserialize_with = "de_str_as_bytes")]
59 pub meth: [u8; 8],#[cbor(n(2), with = "minicbor::bytes")]
60 #[serde(serialize_with = "ser_bytes_as_str")]
61 #[serde(deserialize_with = "de_str_as_bytes")]
62 pub ip: [u8; 16],#[cbor(n(3), with = "minicbor::bytes")]
63 #[serde(serialize_with = "ser_bytes_as_str")]
64 #[serde(deserialize_with = "de_str_as_bytes")]
65 pub sn: [u8; 16],#[cbor(n(4), with = "minicbor::bytes")]
66 #[serde(serialize_with = "ser_bytes_as_str")]
67 #[serde(deserialize_with = "de_str_as_bytes")]
68 pub gw: [u8; 16],}impl Default for NetworkIp {
69 fn default() -> NetworkIp {
70 NetworkIp {keep_alive: Default::default(),meth: Default::default(),ip: Default::default(),sn: Default::default(),gw: Default::default(),}
71 }
72 }#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
73 pub struct NetworkPorts {#[n(0)]
74 pub http_port: u16,#[n(1)]
75 pub https_port: u16,#[n(2)]
76 pub http_port_en: bool,#[n(3)]
77 pub https_port_en: bool,}impl Default for NetworkPorts {
78 fn default() -> NetworkPorts {
79 NetworkPorts {http_port: Default::default(),https_port: Default::default(),http_port_en: Default::default(),https_port_en: Default::default(),}
80 }
81 }#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
82 pub struct NetworkSecurity {#[n(0)]
83 pub policies: u8,}impl Default for NetworkSecurity {
84 fn default() -> NetworkSecurity {
85 NetworkSecurity {policies: Default::default(),}
86 }
87 }#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
88 pub struct NetworkZmtp {#[cbor(n(0), with = "minicbor::bytes")]
89 #[serde(serialize_with = "ser_bytes_as_str")]
90 #[serde(deserialize_with = "de_str_as_bytes")]
91 pub ip: [u8; 16],#[n(1)]
92 pub port: u16,#[n(2)]
93 pub port_en: bool,#[n(3)]
94 pub tls_en: bool,}impl Default for NetworkZmtp {
95 fn default() -> NetworkZmtp {
96 NetworkZmtp {ip: Default::default(),port: Default::default(),port_en: Default::default(),tls_en: Default::default(),}
97 }
98 }#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
99 pub struct ResponseMeta {#[n(0)]
100 pub code: i32,#[cbor(n(1), with = "minicbor::bytes")]
101 #[serde(serialize_with = "ser_bytes_as_str")]
102 #[serde(deserialize_with = "de_str_as_bytes")]
103 pub mesg: [u8; 32],}impl Default for ResponseMeta {
104 fn default() -> ResponseMeta {
105 ResponseMeta {code: Default::default(),mesg: Default::default(),}
106 }
107 }#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
108 pub struct Update {#[n(0)]
109 pub offset: u32,#[cbor(n(1), with = "minicbor::bytes")]
110 #[serde(with="BigArray")]
111 pub data: [u8; 512],}impl Default for Update {
112 fn default() -> Update {
113 Update {offset: Default::default(),data: [0; 512],}
114 }
115 }pub trait Edit {
116 fn edit(&mut self, bytes: &str);
117 }
118
119 impl Edit for [u8] {
120 fn edit(&mut self, bytes: &str) {
121 self[0..bytes.len()].copy_from_slice(bytes.as_bytes());
122 self[bytes.len()..].fill(0);
123 }
124 }
125
126 pub trait FromBytes {
127 fn from_bytes(&self) -> core::result::Result<&str, core::str::Utf8Error>;
128 }
129
130 impl FromBytes for [u8] {
131 fn from_bytes(&self) -> core::result::Result<&str, core::str::Utf8Error> {
132 core::str::from_utf8(&self[0..]).map(|s| match s.find("\0") {
133 Some(n) => &s[0..n],
134 None => s,
135 })
136 }
137 }
138
139 struct StrToBytes<const N: usize> {}
140 impl<'de, const N: usize> serde::de::Visitor<'de> for StrToBytes<N> {
141 type Value = [u8; N];
142 fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
143 write!(formatter, "a string")
144 }
145
146 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E> {
147 let mut ret: [u8; N] = [0; N];
148 let min = if s.len() < N { s.len() } else { N };
149 ret[0..min].copy_from_slice(&s.as_bytes()[0..min]);
150 Ok(ret)
151 }
152 }
153
154 fn ser_bytes_as_str<S: serde::Serializer>(ty: &[u8], s: S) -> std::result::Result<S::Ok, S::Error> {
155 ty.from_bytes()
156 .map_err(|e| serde::ser::Error::custom(format!("{}", e)))
157 .and_then(|val| s.serialize_str(val))
158 }
159
160 fn de_str_as_bytes<'de, D, const N: usize>(de: D) -> std::result::Result<[u8; N], D::Error>
161 where
162 D: serde::de::Deserializer<'de>,
163 {
164 de.deserialize_str(StrToBytes::<N> {})
165 }#[cfg(test)]
166mod tests {
167
168 #[test]
169 fn test_about_serde() {
170 use super::*;
171 let mut buffer = [0; 4096];
172 minicbor::encode(&About::default(), &mut buffer[0..]).unwrap();
173 let about = minicbor::decode::<About>(&buffer).unwrap();
174 let about_json = serde_json::to_string(&about).unwrap();
175 let _about = serde_json::from_str::<About>(&about_json).unwrap();
176 }#[test]
177 fn test_common_serde() {
178 use super::*;
179 let mut buffer = [0; 4096];
180 minicbor::encode(&Common::default(), &mut buffer[0..]).unwrap();
181 let common = minicbor::decode::<Common>(&buffer).unwrap();
182 let common_json = serde_json::to_string(&common).unwrap();
183 let _common = serde_json::from_str::<Common>(&common_json).unwrap();
184 }#[test]
185 fn test_network_serde() {
186 use super::*;
187 let mut buffer = [0; 4096];
188 minicbor::encode(&Network::default(), &mut buffer[0..]).unwrap();
189 let network = minicbor::decode::<Network>(&buffer).unwrap();
190 let network_json = serde_json::to_string(&network).unwrap();
191 let _network = serde_json::from_str::<Network>(&network_json).unwrap();
192 }#[test]
193 fn test_network_cert_setup_serde() {
194 use super::*;
195 let mut buffer = [0; 4096];
196 minicbor::encode(&NetworkCertSetup::default(), &mut buffer[0..]).unwrap();
197 let network_cert_setup = minicbor::decode::<NetworkCertSetup>(&buffer).unwrap();
198 let network_cert_setup_json = serde_json::to_string(&network_cert_setup).unwrap();
199 let _network_cert_setup = serde_json::from_str::<NetworkCertSetup>(&network_cert_setup_json).unwrap();
200 }#[test]
201 fn test_network_ip_serde() {
202 use super::*;
203 let mut buffer = [0; 4096];
204 minicbor::encode(&NetworkIp::default(), &mut buffer[0..]).unwrap();
205 let network_ip = minicbor::decode::<NetworkIp>(&buffer).unwrap();
206 let network_ip_json = serde_json::to_string(&network_ip).unwrap();
207 let _network_ip = serde_json::from_str::<NetworkIp>(&network_ip_json).unwrap();
208 }#[test]
209 fn test_network_ports_serde() {
210 use super::*;
211 let mut buffer = [0; 4096];
212 minicbor::encode(&NetworkPorts::default(), &mut buffer[0..]).unwrap();
213 let network_ports = minicbor::decode::<NetworkPorts>(&buffer).unwrap();
214 let network_ports_json = serde_json::to_string(&network_ports).unwrap();
215 let _network_ports = serde_json::from_str::<NetworkPorts>(&network_ports_json).unwrap();
216 }#[test]
217 fn test_network_security_serde() {
218 use super::*;
219 let mut buffer = [0; 4096];
220 minicbor::encode(&NetworkSecurity::default(), &mut buffer[0..]).unwrap();
221 let network_security = minicbor::decode::<NetworkSecurity>(&buffer).unwrap();
222 let network_security_json = serde_json::to_string(&network_security).unwrap();
223 let _network_security = serde_json::from_str::<NetworkSecurity>(&network_security_json).unwrap();
224 }#[test]
225 fn test_network_zmtp_serde() {
226 use super::*;
227 let mut buffer = [0; 4096];
228 minicbor::encode(&NetworkZmtp::default(), &mut buffer[0..]).unwrap();
229 let network_zmtp = minicbor::decode::<NetworkZmtp>(&buffer).unwrap();
230 let network_zmtp_json = serde_json::to_string(&network_zmtp).unwrap();
231 let _network_zmtp = serde_json::from_str::<NetworkZmtp>(&network_zmtp_json).unwrap();
232 }#[test]
233 fn test_response_meta_serde() {
234 use super::*;
235 let mut buffer = [0; 4096];
236 minicbor::encode(&ResponseMeta::default(), &mut buffer[0..]).unwrap();
237 let response_meta = minicbor::decode::<ResponseMeta>(&buffer).unwrap();
238 let response_meta_json = serde_json::to_string(&response_meta).unwrap();
239 let _response_meta = serde_json::from_str::<ResponseMeta>(&response_meta_json).unwrap();
240 }#[test]
241 fn test_update_serde() {
242 use super::*;
243 let mut buffer = [0; 4096];
244 minicbor::encode(&Update::default(), &mut buffer[0..]).unwrap();
245 let update = minicbor::decode::<Update>(&buffer).unwrap();
246 let update_json = serde_json::to_string(&update).unwrap();
247 let _update = serde_json::from_str::<Update>(&update_json).unwrap();
248 }
249}