Skip to main content

rustorb_giop/
fragment.rs

1use std::collections::HashMap;
2use std::sync::Arc;
3
4use rustorb_cdr::{ByteOrder, Segment};
5
6use crate::message::decode_segmented;
7use crate::{Error, Message, MessageHeader, MsgType, Result, Version};
8
9/// Joins fragmented GIOP 1.1 and 1.2 messages.
10///
11/// Feed every complete message received on one connection to
12/// [`push`](FragmentAssembler::push). Unfragmented messages are returned
13/// as they are; a fragmented one is returned as a single message, with the
14/// more-fragments flag cleared and the size updated, once its last
15/// fragment arrives.
16///
17/// GIOP 1.1 allows one fragmented message at a time per connection. GIOP
18/// 1.2 interleaves them by request id, which is the first field of every
19/// message that can be fragmented.
20///
21/// The data in each `Fragment` is aligned relative to the start of that
22/// `Fragment` message, as omniORB writes and reads it. In GIOP 1.2 the
23/// data of a fragment starts at offset 16 and every fragment but the last
24/// ends on an 8-byte boundary, so this is the same as aligning the joined
25/// message. In GIOP 1.1 it is not:
26/// omniORB ends each fragment on an 8-byte boundary and continues at
27/// offset 12 of the next, so an 8-byte value after a fragment boundary
28/// would be read 4 bytes off. The joined message therefore carries a
29/// [`Segment`] for each fragment, which [`AssembledMessage::decode`] passes
30/// on to the body decoder.
31#[derive(Debug)]
32pub struct FragmentAssembler {
33    max_message_size: usize,
34    pending_1_1: Option<Pending>,
35    pending_1_2: HashMap<u32, Pending>,
36}
37
38#[derive(Debug)]
39struct Pending {
40    version: Version,
41    byte_order: ByteOrder,
42    data: Vec<u8>,
43    segments: Vec<Segment>,
44}
45
46/// A whole message returned by a [`FragmentAssembler`].
47#[derive(Debug, Clone, PartialEq, Eq)]
48pub struct AssembledMessage {
49    data: Vec<u8>,
50    segments: Vec<Segment>,
51}
52
53impl AssembledMessage {
54    /// The message bytes, header included. For a joined message the
55    /// header has the more-fragments flag cleared and the total size.
56    pub fn as_bytes(&self) -> &[u8] {
57        &self.data
58    }
59
60    /// Consumes the message and returns its bytes.
61    pub fn into_bytes(self) -> Vec<u8> {
62        self.data
63    }
64
65    /// Where each fragment after the first starts in the message, with the
66    /// offset its alignment restarts at. Empty for an unfragmented message.
67    pub fn segments(&self) -> &[Segment] {
68        &self.segments
69    }
70
71    /// Whether the message was joined from fragments.
72    pub fn was_fragmented(&self) -> bool {
73        !self.segments.is_empty()
74    }
75
76    /// Decodes the message, keeping the alignment of each fragment. The
77    /// bodies get a copy of the bytes; [`into_decoded`](Self::into_decoded)
78    /// shares them instead.
79    pub fn decode(&self) -> Result<(MessageHeader, Message)> {
80        decode_segmented(&Arc::new(self.data.clone()), &self.segments)
81    }
82
83    /// Decodes the message like [`decode`](Self::decode), handing its
84    /// bytes to the bodies without copying them.
85    pub fn into_decoded(self) -> Result<(MessageHeader, Message)> {
86        decode_segmented(&Arc::new(self.data), &self.segments)
87    }
88}
89
90impl Default for FragmentAssembler {
91    fn default() -> FragmentAssembler {
92        FragmentAssembler::new(FragmentAssembler::DEFAULT_MAX_MESSAGE_SIZE)
93    }
94}
95
96impl FragmentAssembler {
97    /// Default limit on the size of a reassembled message: 64 MiB.
98    pub const DEFAULT_MAX_MESSAGE_SIZE: usize = 64 * 1024 * 1024;
99
100    /// Creates an assembler that rejects reassembled messages longer than
101    /// `max_message_size` bytes, header included.
102    pub fn new(max_message_size: usize) -> FragmentAssembler {
103        FragmentAssembler {
104            max_message_size,
105            pending_1_1: None,
106            pending_1_2: HashMap::new(),
107        }
108    }
109
110    /// Whether any fragmented message is incomplete.
111    pub fn has_pending(&self) -> bool {
112        self.pending_1_1.is_some() || !self.pending_1_2.is_empty()
113    }
114
115    /// Drops an incomplete GIOP 1.2 message, as on a `CancelRequest`.
116    pub fn cancel(&mut self, request_id: u32) -> bool {
117        self.pending_1_2.remove(&request_id).is_some()
118    }
119
120    /// Takes one complete message and returns a whole message when one is
121    /// ready.
122    pub fn push(&mut self, msg: &[u8]) -> Result<Option<AssembledMessage>> {
123        self.push_message(msg)
124    }
125
126    /// Like [`push`](Self::push), but takes the buffer the message was read
127    /// into: an unfragmented message, and the first fragment of a
128    /// fragmented one, keep it instead of copying it.
129    pub fn push_owned(&mut self, msg: Vec<u8>) -> Result<Option<AssembledMessage>> {
130        self.push_message(msg)
131    }
132
133    fn push_message<M>(&mut self, owned: M) -> Result<Option<AssembledMessage>>
134    where
135        M: AsRef<[u8]> + Into<Vec<u8>>,
136    {
137        let msg = owned.as_ref();
138        let header = MessageHeader::parse(msg)?;
139        let expected = header.total_len();
140        if msg.len() != expected {
141            return Err(if msg.len() < expected {
142                Error::Truncated {
143                    expected,
144                    actual: msg.len(),
145                }
146            } else {
147                Error::TrailingBytes(msg.len() - expected)
148            });
149        }
150        let v12 = header.version >= Version::V1_2;
151
152        if header.msg_type != MsgType::Fragment {
153            if !header.more_fragments {
154                return Ok(Some(AssembledMessage {
155                    data: owned.into(),
156                    segments: Vec::new(),
157                }));
158            }
159            self.check_size(msg.len())?;
160            let id = if v12 {
161                Some(request_id(&header, msg)?)
162            } else {
163                None
164            };
165            let pending = Pending {
166                version: header.version,
167                byte_order: header.byte_order,
168                data: owned.into(),
169                segments: Vec::new(),
170            };
171            if let Some(id) = id {
172                if self.pending_1_2.contains_key(&id) {
173                    return Err(Error::FragmentInProgress);
174                }
175                self.pending_1_2.insert(id, pending);
176            } else {
177                if self.pending_1_1.is_some() {
178                    return Err(Error::FragmentInProgress);
179                }
180                self.pending_1_1 = Some(pending);
181            }
182            return Ok(None);
183        }
184
185        let (mut pending, data_start, id) = if v12 {
186            let id = request_id(&header, msg)?;
187            let pending = self
188                .pending_1_2
189                .remove(&id)
190                .ok_or(Error::UnexpectedFragment)?;
191            (pending, MessageHeader::SIZE + 4, Some(id))
192        } else {
193            let pending = self.pending_1_1.take().ok_or(Error::UnexpectedFragment)?;
194            (pending, MessageHeader::SIZE, None)
195        };
196        if pending.version != header.version || pending.byte_order != header.byte_order {
197            return Err(Error::FragmentMismatch);
198        }
199        let data = &msg[data_start..];
200        self.check_size(pending.data.len() + data.len())?;
201        if !data.is_empty() {
202            pending.segments.push(Segment {
203                start: pending.data.len(),
204                offset: data_start,
205            });
206        }
207        pending.data.extend_from_slice(data);
208
209        if header.more_fragments {
210            match id {
211                Some(id) => {
212                    self.pending_1_2.insert(id, pending);
213                }
214                None => self.pending_1_1 = Some(pending),
215            }
216            return Ok(None);
217        }
218
219        let mut whole = MessageHeader::parse(&pending.data)?;
220        whole.more_fragments = false;
221        whole.message_size = u32::try_from(pending.data.len() - MessageHeader::SIZE)
222            .map_err(|_| Error::MessageTooLarge(pending.data.len()))?;
223        pending.data[..MessageHeader::SIZE].copy_from_slice(&whole.to_bytes());
224        Ok(Some(AssembledMessage {
225            data: pending.data,
226            segments: pending.segments,
227        }))
228    }
229
230    fn check_size(&self, len: usize) -> Result<()> {
231        if len > self.max_message_size {
232            Err(Error::FragmentTooLarge(len))
233        } else {
234            Ok(())
235        }
236    }
237}
238
239/// Reads the request id that starts every fragmentable GIOP 1.2 message.
240fn request_id(header: &MessageHeader, msg: &[u8]) -> Result<u32> {
241    let bytes = msg
242        .get(MessageHeader::SIZE..MessageHeader::SIZE + 4)
243        .ok_or(Error::Truncated {
244            expected: MessageHeader::SIZE + 4,
245            actual: msg.len(),
246        })?;
247    let bytes = [bytes[0], bytes[1], bytes[2], bytes[3]];
248    Ok(match header.byte_order {
249        ByteOrder::Big => u32::from_be_bytes(bytes),
250        ByteOrder::Little => u32::from_le_bytes(bytes),
251    })
252}