pub use minicbor::{self, Encode, Decode};
use serde::{Deserialize, Serialize};
use serde_big_array::BigArray;#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct About {#[cbor(n(0), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub site: [u8; 32],#[cbor(n(1), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub ver_os: [u8; 32],#[cbor(n(2), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub ver_atx: [u8; 32],#[cbor(n(3), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub ver_prj: [u8; 32],#[cbor(n(4), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub product: [u8; 32],#[cbor(n(5), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub board: [u8; 32],#[cbor(n(6), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub sid: [u8; 32],#[cbor(n(7), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub mac: [u8; 32],}impl Default for About {
fn default() -> About {
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(),}
}
}#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct Common {#[n(0)]
pub about: About,#[n(1)]
pub network: Network,}impl Default for Common {
fn default() -> Common {
Common {about: Default::default(),network: Default::default(),}
}
}#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct Network {#[n(0)]
pub security: NetworkSecurity,#[n(1)]
pub ip: NetworkIp,#[n(2)]
pub ports: NetworkPorts,#[n(3)]
pub cert: NetworkCertSetup,#[n(4)]
pub zmtp: NetworkZmtp,}impl Default for Network {
fn default() -> Network {
Network {security: Default::default(),ip: Default::default(),ports: Default::default(),cert: Default::default(),zmtp: Default::default(),}
}
}#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct NetworkCertSetup {}impl Default for NetworkCertSetup {
fn default() -> NetworkCertSetup {
NetworkCertSetup {}
}
}#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct NetworkIp {#[n(0)]
pub keep_alive: bool,#[cbor(n(1), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub meth: [u8; 8],#[cbor(n(2), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub ip: [u8; 16],#[cbor(n(3), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub sn: [u8; 16],#[cbor(n(4), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub gw: [u8; 16],}impl Default for NetworkIp {
fn default() -> NetworkIp {
NetworkIp {keep_alive: Default::default(),meth: Default::default(),ip: Default::default(),sn: Default::default(),gw: Default::default(),}
}
}#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct NetworkPorts {#[n(0)]
pub http_port: u16,#[n(1)]
pub https_port: u16,#[n(2)]
pub http_port_en: bool,#[n(3)]
pub https_port_en: bool,}impl Default for NetworkPorts {
fn default() -> NetworkPorts {
NetworkPorts {http_port: Default::default(),https_port: Default::default(),http_port_en: Default::default(),https_port_en: Default::default(),}
}
}#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct NetworkSecurity {#[n(0)]
pub policies: u8,}impl Default for NetworkSecurity {
fn default() -> NetworkSecurity {
NetworkSecurity {policies: Default::default(),}
}
}#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct NetworkZmtp {#[cbor(n(0), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub ip: [u8; 16],#[n(1)]
pub port: u16,#[n(2)]
pub port_en: bool,#[n(3)]
pub tls_en: bool,}impl Default for NetworkZmtp {
fn default() -> NetworkZmtp {
NetworkZmtp {ip: Default::default(),port: Default::default(),port_en: Default::default(),tls_en: Default::default(),}
}
}#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct ResponseMeta {#[n(0)]
pub code: i32,#[cbor(n(1), with = "minicbor::bytes")]
#[serde(serialize_with = "ser_bytes_as_str")]
#[serde(deserialize_with = "de_str_as_bytes")]
pub mesg: [u8; 32],}impl Default for ResponseMeta {
fn default() -> ResponseMeta {
ResponseMeta {code: Default::default(),mesg: Default::default(),}
}
}#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct Update {#[n(0)]
pub offset: u32,#[cbor(n(1), with = "minicbor::bytes")]
#[serde(with="BigArray")]
pub data: [u8; 512],}impl Default for Update {
fn default() -> Update {
Update {offset: Default::default(),data: [0; 512],}
}
}pub trait Edit {
fn edit(&mut self, bytes: &str);
}
impl Edit for [u8] {
fn edit(&mut self, bytes: &str) {
self[0..bytes.len()].copy_from_slice(bytes.as_bytes());
self[bytes.len()..].fill(0);
}
}
pub trait FromBytes {
fn from_bytes(&self) -> core::result::Result<&str, core::str::Utf8Error>;
}
impl FromBytes for [u8] {
fn from_bytes(&self) -> core::result::Result<&str, core::str::Utf8Error> {
core::str::from_utf8(&self[0..]).map(|s| match s.find("\0") {
Some(n) => &s[0..n],
None => s,
})
}
}
struct StrToBytes<const N: usize> {}
impl<'de, const N: usize> serde::de::Visitor<'de> for StrToBytes<N> {
type Value = [u8; N];
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(formatter, "a string")
}
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E> {
let mut ret: [u8; N] = [0; N];
let min = if s.len() < N { s.len() } else { N };
ret[0..min].copy_from_slice(&s.as_bytes()[0..min]);
Ok(ret)
}
}
fn ser_bytes_as_str<S: serde::Serializer>(ty: &[u8], s: S) -> std::result::Result<S::Ok, S::Error> {
ty.from_bytes()
.map_err(|e| serde::ser::Error::custom(format!("{}", e)))
.and_then(|val| s.serialize_str(val))
}
fn de_str_as_bytes<'de, D, const N: usize>(de: D) -> std::result::Result<[u8; N], D::Error>
where
D: serde::de::Deserializer<'de>,
{
de.deserialize_str(StrToBytes::<N> {})
}#[cfg(test)]
mod tests {
#[test]
fn test_about_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&About::default(), &mut buffer[0..]).unwrap();
let about = minicbor::decode::<About>(&buffer).unwrap();
let about_json = serde_json::to_string(&about).unwrap();
let _about = serde_json::from_str::<About>(&about_json).unwrap();
}#[test]
fn test_common_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&Common::default(), &mut buffer[0..]).unwrap();
let common = minicbor::decode::<Common>(&buffer).unwrap();
let common_json = serde_json::to_string(&common).unwrap();
let _common = serde_json::from_str::<Common>(&common_json).unwrap();
}#[test]
fn test_network_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&Network::default(), &mut buffer[0..]).unwrap();
let network = minicbor::decode::<Network>(&buffer).unwrap();
let network_json = serde_json::to_string(&network).unwrap();
let _network = serde_json::from_str::<Network>(&network_json).unwrap();
}#[test]
fn test_network_cert_setup_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&NetworkCertSetup::default(), &mut buffer[0..]).unwrap();
let network_cert_setup = minicbor::decode::<NetworkCertSetup>(&buffer).unwrap();
let network_cert_setup_json = serde_json::to_string(&network_cert_setup).unwrap();
let _network_cert_setup = serde_json::from_str::<NetworkCertSetup>(&network_cert_setup_json).unwrap();
}#[test]
fn test_network_ip_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&NetworkIp::default(), &mut buffer[0..]).unwrap();
let network_ip = minicbor::decode::<NetworkIp>(&buffer).unwrap();
let network_ip_json = serde_json::to_string(&network_ip).unwrap();
let _network_ip = serde_json::from_str::<NetworkIp>(&network_ip_json).unwrap();
}#[test]
fn test_network_ports_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&NetworkPorts::default(), &mut buffer[0..]).unwrap();
let network_ports = minicbor::decode::<NetworkPorts>(&buffer).unwrap();
let network_ports_json = serde_json::to_string(&network_ports).unwrap();
let _network_ports = serde_json::from_str::<NetworkPorts>(&network_ports_json).unwrap();
}#[test]
fn test_network_security_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&NetworkSecurity::default(), &mut buffer[0..]).unwrap();
let network_security = minicbor::decode::<NetworkSecurity>(&buffer).unwrap();
let network_security_json = serde_json::to_string(&network_security).unwrap();
let _network_security = serde_json::from_str::<NetworkSecurity>(&network_security_json).unwrap();
}#[test]
fn test_network_zmtp_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&NetworkZmtp::default(), &mut buffer[0..]).unwrap();
let network_zmtp = minicbor::decode::<NetworkZmtp>(&buffer).unwrap();
let network_zmtp_json = serde_json::to_string(&network_zmtp).unwrap();
let _network_zmtp = serde_json::from_str::<NetworkZmtp>(&network_zmtp_json).unwrap();
}#[test]
fn test_response_meta_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&ResponseMeta::default(), &mut buffer[0..]).unwrap();
let response_meta = minicbor::decode::<ResponseMeta>(&buffer).unwrap();
let response_meta_json = serde_json::to_string(&response_meta).unwrap();
let _response_meta = serde_json::from_str::<ResponseMeta>(&response_meta_json).unwrap();
}#[test]
fn test_update_serde() {
use super::*;
let mut buffer = [0; 4096];
minicbor::encode(&Update::default(), &mut buffer[0..]).unwrap();
let update = minicbor::decode::<Update>(&buffer).unwrap();
let update_json = serde_json::to_string(&update).unwrap();
let _update = serde_json::from_str::<Update>(&update_json).unwrap();
}
}