1use std::fmt;
2
3use rustorb_cdr::{ByteOrder, CdrVersion};
4
5use crate::{Error, Result};
6
7#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
9pub struct Version {
10 pub major: u8,
12 pub minor: u8,
14}
15
16impl Version {
17 pub const V1_0: Version = Version { major: 1, minor: 0 };
19 pub const V1_1: Version = Version { major: 1, minor: 1 };
21 pub const V1_2: Version = Version { major: 1, minor: 2 };
23
24 pub fn is_supported(self) -> bool {
26 self.major == 1 && self.minor <= 2
27 }
28
29 pub fn cdr_version(self) -> CdrVersion {
31 match self.minor {
32 0 => CdrVersion::Giop1_0,
33 1 => CdrVersion::Giop1_1,
34 _ => CdrVersion::Giop1_2,
35 }
36 }
37}
38
39impl fmt::Display for Version {
40 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
41 write!(f, "{}.{}", self.major, self.minor)
42 }
43}
44
45#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
47pub enum MsgType {
48 Request,
50 Reply,
52 CancelRequest,
54 LocateRequest,
56 LocateReply,
58 CloseConnection,
60 MessageError,
62 Fragment,
64}
65
66impl MsgType {
67 pub fn to_u8(self) -> u8 {
69 self as u8
70 }
71
72 pub fn from_u8(value: u8, version: Version) -> Result<MsgType> {
74 Ok(match value {
75 0 => MsgType::Request,
76 1 => MsgType::Reply,
77 2 => MsgType::CancelRequest,
78 3 => MsgType::LocateRequest,
79 4 => MsgType::LocateReply,
80 5 => MsgType::CloseConnection,
81 6 => MsgType::MessageError,
82 7 if version.minor >= 1 => MsgType::Fragment,
83 other => return Err(Error::UnknownMessageType(other)),
84 })
85 }
86}
87
88#[derive(Debug, Clone, Copy, PartialEq, Eq)]
90pub struct MessageHeader {
91 pub version: Version,
93 pub byte_order: ByteOrder,
95 pub more_fragments: bool,
97 pub msg_type: MsgType,
99 pub message_size: u32,
101}
102
103impl MessageHeader {
104 pub const SIZE: usize = 12;
106
107 pub const MAGIC: [u8; 4] = *b"GIOP";
109
110 const FLAG_LITTLE_ENDIAN: u8 = 0x01;
112 const FLAG_FRAGMENT: u8 = 0x02;
114
115 pub fn parse(buf: &[u8]) -> Result<MessageHeader> {
120 let Some(bytes) = buf.first_chunk::<{ Self::SIZE }>() else {
121 return Err(Error::Truncated {
122 expected: Self::SIZE,
123 actual: buf.len(),
124 });
125 };
126 let magic = [bytes[0], bytes[1], bytes[2], bytes[3]];
127 if magic != Self::MAGIC {
128 return Err(Error::BadMagic(magic));
129 }
130 let version = Version {
131 major: bytes[4],
132 minor: bytes[5],
133 };
134 if !version.is_supported() {
135 return Err(Error::UnsupportedVersion(version));
136 }
137 let flags = bytes[6];
138 let (byte_order, more_fragments) = if version.minor == 0 {
139 let order = ByteOrder::from_flag(flags).map_err(|_| Error::InvalidFlags(flags))?;
140 (order, false)
141 } else {
142 let order = if flags & Self::FLAG_LITTLE_ENDIAN != 0 {
143 ByteOrder::Little
144 } else {
145 ByteOrder::Big
146 };
147 (order, flags & Self::FLAG_FRAGMENT != 0)
148 };
149 let msg_type = MsgType::from_u8(bytes[7], version)?;
150 let size = [bytes[8], bytes[9], bytes[10], bytes[11]];
151 let message_size = match byte_order {
152 ByteOrder::Big => u32::from_be_bytes(size),
153 ByteOrder::Little => u32::from_le_bytes(size),
154 };
155 Ok(MessageHeader {
156 version,
157 byte_order,
158 more_fragments,
159 msg_type,
160 message_size,
161 })
162 }
163
164 pub fn flags(&self) -> u8 {
166 if self.version.minor == 0 {
167 self.byte_order.flag()
168 } else {
169 let mut flags = self.byte_order.flag();
170 if self.more_fragments {
171 flags |= Self::FLAG_FRAGMENT;
172 }
173 flags
174 }
175 }
176
177 pub fn to_bytes(&self) -> [u8; Self::SIZE] {
179 let size = match self.byte_order {
180 ByteOrder::Big => self.message_size.to_be_bytes(),
181 ByteOrder::Little => self.message_size.to_le_bytes(),
182 };
183 let m = Self::MAGIC;
184 [
185 m[0],
186 m[1],
187 m[2],
188 m[3],
189 self.version.major,
190 self.version.minor,
191 self.flags(),
192 self.msg_type.to_u8(),
193 size[0],
194 size[1],
195 size[2],
196 size[3],
197 ]
198 }
199
200 pub fn total_len(&self) -> usize {
202 Self::SIZE + self.message_size as usize
203 }
204}