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#[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#[derive(Debug, Clone, PartialEq, Eq)]
48pub struct AssembledMessage {
49 data: Vec<u8>,
50 segments: Vec<Segment>,
51}
52
53impl AssembledMessage {
54 pub fn as_bytes(&self) -> &[u8] {
57 &self.data
58 }
59
60 pub fn into_bytes(self) -> Vec<u8> {
62 self.data
63 }
64
65 pub fn segments(&self) -> &[Segment] {
68 &self.segments
69 }
70
71 pub fn was_fragmented(&self) -> bool {
73 !self.segments.is_empty()
74 }
75
76 pub fn decode(&self) -> Result<(MessageHeader, Message)> {
80 decode_segmented(&Arc::new(self.data.clone()), &self.segments)
81 }
82
83 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 pub const DEFAULT_MAX_MESSAGE_SIZE: usize = 64 * 1024 * 1024;
99
100 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 pub fn has_pending(&self) -> bool {
112 self.pending_1_1.is_some() || !self.pending_1_2.is_empty()
113 }
114
115 pub fn cancel(&mut self, request_id: u32) -> bool {
117 self.pending_1_2.remove(&request_id).is_some()
118 }
119
120 pub fn push(&mut self, msg: &[u8]) -> Result<Option<AssembledMessage>> {
123 self.push_message(msg)
124 }
125
126 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
239fn 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}