Skip to main content

rustorb_giop/
header.rs

1use std::fmt;
2
3use rustorb_cdr::{ByteOrder, Encoding};
4
5use crate::{Error, Result};
6
7/// A GIOP protocol version.
8#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
9pub struct Version {
10    /// Major version, always 1 for supported messages.
11    pub major: u8,
12    /// Minor version.
13    pub minor: u8,
14}
15
16impl Version {
17    /// GIOP 1.0.
18    pub const V1_0: Version = Version { major: 1, minor: 0 };
19    /// GIOP 1.1.
20    pub const V1_1: Version = Version { major: 1, minor: 1 };
21    /// GIOP 1.2.
22    pub const V1_2: Version = Version { major: 1, minor: 2 };
23
24    /// Whether this version can be read and written.
25    pub fn is_supported(self) -> bool {
26        self.major == 1 && self.minor <= 2
27    }
28
29    /// The CDR rules for this version.
30    pub fn cdr_version(self) -> Encoding {
31        match self.minor {
32            0 => Encoding::Giop1_0,
33            1 => Encoding::Giop1_1,
34            _ => Encoding::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/// A GIOP message type.
46#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
47pub enum MsgType {
48    /// `Request` (0).
49    Request,
50    /// `Reply` (1).
51    Reply,
52    /// `CancelRequest` (2).
53    CancelRequest,
54    /// `LocateRequest` (3).
55    LocateRequest,
56    /// `LocateReply` (4).
57    LocateReply,
58    /// `CloseConnection` (5).
59    CloseConnection,
60    /// `MessageError` (6).
61    MessageError,
62    /// `Fragment` (7), GIOP 1.1 and later.
63    Fragment,
64}
65
66impl MsgType {
67    /// The value in the header.
68    pub fn to_u8(self) -> u8 {
69        self as u8
70    }
71
72    /// Converts a header value, rejecting `Fragment` for GIOP 1.0.
73    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/// The 12-byte header that starts every GIOP message.
89#[derive(Debug, Clone, Copy, PartialEq, Eq)]
90pub struct MessageHeader {
91    /// Protocol version.
92    pub version: Version,
93    /// Byte order of the header size and the whole message.
94    pub byte_order: ByteOrder,
95    /// More fragments follow (GIOP 1.1 and later).
96    pub more_fragments: bool,
97    /// Message type.
98    pub msg_type: MsgType,
99    /// Bytes after the header.
100    pub message_size: u32,
101}
102
103impl MessageHeader {
104    /// Size of the header in bytes.
105    pub const SIZE: usize = 12;
106
107    /// The magic bytes.
108    pub const MAGIC: [u8; 4] = *b"GIOP";
109
110    /// Flag bit for little-endian (GIOP 1.1 and later).
111    const FLAG_LITTLE_ENDIAN: u8 = 0x01;
112    /// Flag bit for "more fragments follow" (GIOP 1.1 and later).
113    const FLAG_FRAGMENT: u8 = 0x02;
114
115    /// Parses a header from the first 12 bytes of `buf`.
116    ///
117    /// The message size is not checked against any limit; the caller
118    /// decides how large a message it is willing to buffer.
119    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    /// The flags octet as written in the header.
165    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    /// Writes the header.
178    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    /// Total length of the message including the header.
201    pub fn total_len(&self) -> usize {
202        Self::SIZE + self.message_size as usize
203    }
204}