use std::fmt;
use rustorb_cdr::{ByteOrder, Encoding};
use crate::{Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Version {
pub major: u8,
pub minor: u8,
}
impl Version {
pub const V1_0: Version = Version { major: 1, minor: 0 };
pub const V1_1: Version = Version { major: 1, minor: 1 };
pub const V1_2: Version = Version { major: 1, minor: 2 };
pub fn is_supported(self) -> bool {
self.major == 1 && self.minor <= 2
}
pub fn cdr_version(self) -> Encoding {
match self.minor {
0 => Encoding::Giop1_0,
1 => Encoding::Giop1_1,
_ => Encoding::Giop1_2,
}
}
}
impl fmt::Display for Version {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}.{}", self.major, self.minor)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum MsgType {
Request,
Reply,
CancelRequest,
LocateRequest,
LocateReply,
CloseConnection,
MessageError,
Fragment,
}
impl MsgType {
pub fn to_u8(self) -> u8 {
self as u8
}
pub fn from_u8(value: u8, version: Version) -> Result<MsgType> {
Ok(match value {
0 => MsgType::Request,
1 => MsgType::Reply,
2 => MsgType::CancelRequest,
3 => MsgType::LocateRequest,
4 => MsgType::LocateReply,
5 => MsgType::CloseConnection,
6 => MsgType::MessageError,
7 if version.minor >= 1 => MsgType::Fragment,
other => return Err(Error::UnknownMessageType(other)),
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MessageHeader {
pub version: Version,
pub byte_order: ByteOrder,
pub more_fragments: bool,
pub msg_type: MsgType,
pub message_size: u32,
}
impl MessageHeader {
pub const SIZE: usize = 12;
pub const MAGIC: [u8; 4] = *b"GIOP";
const FLAG_LITTLE_ENDIAN: u8 = 0x01;
const FLAG_FRAGMENT: u8 = 0x02;
pub fn parse(buf: &[u8]) -> Result<MessageHeader> {
let Some(bytes) = buf.first_chunk::<{ Self::SIZE }>() else {
return Err(Error::Truncated {
expected: Self::SIZE,
actual: buf.len(),
});
};
let magic = [bytes[0], bytes[1], bytes[2], bytes[3]];
if magic != Self::MAGIC {
return Err(Error::BadMagic(magic));
}
let version = Version {
major: bytes[4],
minor: bytes[5],
};
if !version.is_supported() {
return Err(Error::UnsupportedVersion(version));
}
let flags = bytes[6];
let (byte_order, more_fragments) = if version.minor == 0 {
let order = ByteOrder::from_flag(flags).map_err(|_| Error::InvalidFlags(flags))?;
(order, false)
} else {
let order = if flags & Self::FLAG_LITTLE_ENDIAN != 0 {
ByteOrder::Little
} else {
ByteOrder::Big
};
(order, flags & Self::FLAG_FRAGMENT != 0)
};
let msg_type = MsgType::from_u8(bytes[7], version)?;
let size = [bytes[8], bytes[9], bytes[10], bytes[11]];
let message_size = match byte_order {
ByteOrder::Big => u32::from_be_bytes(size),
ByteOrder::Little => u32::from_le_bytes(size),
};
Ok(MessageHeader {
version,
byte_order,
more_fragments,
msg_type,
message_size,
})
}
pub fn flags(&self) -> u8 {
if self.version.minor == 0 {
self.byte_order.flag()
} else {
let mut flags = self.byte_order.flag();
if self.more_fragments {
flags |= Self::FLAG_FRAGMENT;
}
flags
}
}
pub fn to_bytes(&self) -> [u8; Self::SIZE] {
let size = match self.byte_order {
ByteOrder::Big => self.message_size.to_be_bytes(),
ByteOrder::Little => self.message_size.to_le_bytes(),
};
let m = Self::MAGIC;
[
m[0],
m[1],
m[2],
m[3],
self.version.major,
self.version.minor,
self.flags(),
self.msg_type.to_u8(),
size[0],
size[1],
size[2],
size[3],
]
}
pub fn total_len(&self) -> usize {
Self::SIZE + self.message_size as usize
}
}