1use std::io::IoSlice;
2
3use rustorb_cdr::{ByteOrder, CdrEncode, Encoder, Octets};
4
5use crate::{
6 CancelRequestHeader, Error, LocateReplyHeader, LocateRequestHeader, MessageHeader, MsgType,
7 ReplyHeader, RequestHeader, Result, Version,
8};
9
10#[derive(Debug)]
17pub struct MessageEncoder {
18 enc: Encoder,
19 version: Version,
20 align_body: bool,
21 body_start: Option<(usize, usize)>,
24}
25
26impl MessageEncoder {
27 pub fn new(
29 version: Version,
30 order: ByteOrder,
31 msg_type: MsgType,
32 more_fragments: bool,
33 ) -> Result<MessageEncoder> {
34 if !version.is_supported() {
35 return Err(Error::UnsupportedVersion(version));
36 }
37 if msg_type == MsgType::Fragment && version == Version::V1_0
38 || more_fragments && version == Version::V1_0
39 {
40 return Err(Error::FragmentNotSupported);
41 }
42 let header = MessageHeader {
43 version,
44 byte_order: order,
45 more_fragments,
46 msg_type,
47 message_size: 0,
48 };
49 let mut enc = Encoder::new(order, version.cdr_version());
50 enc.reserve(256);
52 enc.write_octets(&header.to_bytes());
53 Ok(MessageEncoder {
54 enc,
55 version,
56 align_body: false,
57 body_start: None,
58 })
59 }
60
61 pub fn request(
63 version: Version,
64 order: ByteOrder,
65 header: &RequestHeader,
66 ) -> Result<MessageEncoder> {
67 let mut m = MessageEncoder::new(version, order, MsgType::Request, false)?;
68 let enc = &mut m.enc;
69 if version >= Version::V1_2 {
70 enc.write_u32(header.request_id);
71 enc.write_octet(header.response_flags);
72 enc.write_octets(&[0; 3]);
73 header.target.encode(enc)?;
74 enc.write_string(&header.operation)?;
75 header.service_context.encode(enc)?;
76 m.align_body = true;
77 } else {
78 let key = header.target.object_key().ok_or(Error::TargetNotKey)?;
79 header.service_context.encode(enc)?;
80 enc.write_u32(header.request_id);
81 enc.write_bool(header.response_expected());
82 if version.minor == 1 {
83 enc.write_octets(&[0; 3]);
84 }
85 enc.write_octet_seq(key)?;
86 enc.write_string(&header.operation)?;
87 enc.write_octet_seq(&header.requesting_principal)?;
88 }
89 Ok(m)
90 }
91
92 pub fn reply(
94 version: Version,
95 order: ByteOrder,
96 header: &ReplyHeader,
97 ) -> Result<MessageEncoder> {
98 let mut m = MessageEncoder::new(version, order, MsgType::Reply, false)?;
99 let enc = &mut m.enc;
100 if version >= Version::V1_2 {
101 enc.write_u32(header.request_id);
102 enc.write_u32(header.reply_status.to_u32());
103 header.service_context.encode(enc)?;
104 m.align_body = true;
105 } else {
106 header.service_context.encode(enc)?;
107 enc.write_u32(header.request_id);
108 enc.write_u32(header.reply_status.to_u32());
109 }
110 Ok(m)
111 }
112
113 pub fn cancel_request(
115 version: Version,
116 order: ByteOrder,
117 header: &CancelRequestHeader,
118 ) -> Result<Vec<u8>> {
119 let mut m = MessageEncoder::new(version, order, MsgType::CancelRequest, false)?;
120 m.enc.write_u32(header.request_id);
121 m.finish()
122 }
123
124 pub fn locate_request(
126 version: Version,
127 order: ByteOrder,
128 header: &LocateRequestHeader,
129 ) -> Result<Vec<u8>> {
130 let mut m = MessageEncoder::new(version, order, MsgType::LocateRequest, false)?;
131 m.enc.write_u32(header.request_id);
132 if version >= Version::V1_2 {
133 header.target.encode(&mut m.enc)?;
134 } else {
135 let key = header.target.object_key().ok_or(Error::TargetNotKey)?;
136 m.enc.write_octet_seq(key)?;
137 }
138 m.finish()
139 }
140
141 pub fn locate_reply(
143 version: Version,
144 order: ByteOrder,
145 header: &LocateReplyHeader,
146 ) -> Result<MessageEncoder> {
147 let mut m = MessageEncoder::new(version, order, MsgType::LocateReply, false)?;
148 m.enc.write_u32(header.request_id);
149 m.enc.write_u32(header.locate_status.to_u32());
150 m.align_body = version >= Version::V1_2;
151 Ok(m)
152 }
153
154 pub fn close_connection(version: Version, order: ByteOrder) -> Result<Vec<u8>> {
156 MessageEncoder::new(version, order, MsgType::CloseConnection, false)?.finish()
157 }
158
159 pub fn message_error(version: Version, order: ByteOrder) -> Result<Vec<u8>> {
161 MessageEncoder::new(version, order, MsgType::MessageError, false)?.finish()
162 }
163
164 pub fn fragment(
168 version: Version,
169 order: ByteOrder,
170 request_id: u32,
171 more_fragments: bool,
172 ) -> Result<MessageEncoder> {
173 let mut m = MessageEncoder::new(version, order, MsgType::Fragment, more_fragments)?;
174 if version >= Version::V1_2 {
175 m.enc.write_u32(request_id);
176 }
177 Ok(m)
178 }
179
180 pub fn body(&mut self) -> &mut Encoder {
183 if self.body_start.is_none() {
184 let before = self.enc.len();
185 if self.align_body {
186 self.enc.align(8);
187 }
188 self.body_start = Some((before, self.enc.len()));
189 self.enc.allow_shared(true);
190 }
191 &mut self.enc
192 }
193
194 pub fn version(&self) -> Version {
196 self.version
197 }
198
199 pub fn finish(self) -> Result<Vec<u8>> {
202 Ok(self.finish_shared()?.into_vec())
203 }
204
205 pub fn finish_shared(mut self) -> Result<OutMessage> {
210 if let Some((before, after)) = self.body_start {
211 if self.enc.len() == after {
212 self.enc.truncate(before);
213 }
214 }
215 let len = self.enc.len();
216 let header_len = match self.body_start {
217 Some((before, _)) => before,
218 None => len,
219 };
220 let size =
221 u32::try_from(len - MessageHeader::SIZE).map_err(|_| Error::MessageTooLarge(len))?;
222 let size = match self.enc.byte_order() {
223 ByteOrder::Big => size.to_be_bytes(),
224 ByteOrder::Little => size.to_le_bytes(),
225 };
226 self.enc.as_bytes_mut()[8..12].copy_from_slice(&size);
227 let (bytes, shared) = self.enc.into_parts();
228 Ok(OutMessage {
229 bytes,
230 shared,
231 len,
232 header_len,
233 })
234 }
235}
236
237#[derive(Debug, Clone, Default, PartialEq, Eq)]
240pub struct OutMessage {
241 bytes: Vec<u8>,
242 shared: Vec<(usize, Octets)>,
244 len: usize,
245 header_len: usize,
248}
249
250impl OutMessage {
251 pub fn len(&self) -> usize {
253 self.len
254 }
255
256 pub fn is_empty(&self) -> bool {
258 self.len == 0
259 }
260
261 pub fn as_single(&self) -> Option<&[u8]> {
263 self.shared.is_empty().then_some(&self.bytes[..])
264 }
265
266 pub fn slices_from(&self, from: usize, max: usize) -> Vec<IoSlice<'_>> {
269 let mut out = Vec::new();
270 let mut offset = 0;
271 for piece in self.pieces() {
272 if out.len() == max {
273 break;
274 }
275 let end = offset + piece.len();
276 if end > from {
277 out.push(IoSlice::new(&piece[from.saturating_sub(offset)..]));
278 }
279 offset = end;
280 }
281 out
282 }
283
284 pub fn pieces(&self) -> impl Iterator<Item = &[u8]> {
286 let mut from = 0;
287 let mut shared = self.shared.iter();
288 let mut pending: Option<&[u8]> = None;
289 std::iter::from_fn(move || {
290 if let Some(octets) = pending.take() {
291 return Some(octets);
292 }
293 match shared.next() {
294 Some((at, octets)) => {
295 let piece = &self.bytes[from..*at];
296 from = *at;
297 pending = Some(octets.as_slice());
298 Some(piece)
299 }
300 None if from != usize::MAX => {
301 let piece = &self.bytes[from..];
302 from = usize::MAX;
303 Some(piece)
304 }
305 None => None,
306 }
307 })
308 }
309
310 pub fn fragment(self, size: usize) -> OutMessage {
321 if self.len <= size || self.bytes.len() < MessageHeader::SIZE + 4 {
322 return self;
323 }
324 let size = (size & !7).max(64);
325 if self.len <= size {
326 return self;
327 }
328 let head = &self.bytes[..MessageHeader::SIZE];
329 let version = Version {
330 major: head[4],
331 minor: head[5],
332 };
333 let flags = head[6];
334 let fragmentable = matches!(head[7], 0 | 1 | 4); if version != Version::V1_2 || !fragmentable || flags & 2 != 0 {
336 return self;
337 }
338 let first = size.max((self.header_len + 7) & !7);
339 if first >= self.len {
340 return self;
341 }
342 let order = if flags & 1 != 0 {
343 ByteOrder::Little
344 } else {
345 ByteOrder::Big
346 };
347 let u32_bytes = |v: u32| match order {
348 ByteOrder::Big => v.to_be_bytes(),
349 ByteOrder::Little => v.to_le_bytes(),
350 };
351 let request_id = [
352 self.bytes[12],
353 self.bytes[13],
354 self.bytes[14],
355 self.bytes[15],
356 ];
357 let len = self.len;
358 let whole = self.into_vec();
359 let per = size - MessageHeader::SIZE - 4;
360 let count = 1 + (len - first).div_ceil(per);
361 let mut out = Vec::with_capacity(len + count * (MessageHeader::SIZE + 4));
362 out.extend_from_slice(&whole[..first]);
363 out[6] |= 2;
364 out[8..12].copy_from_slice(&u32_bytes((first - MessageHeader::SIZE) as u32));
365 let mut at = first;
366 while at < len {
367 let end = (at + per).min(len);
368 let more = end < len;
369 out.extend_from_slice(&whole[..6]);
370 out.push(flags & 1 | if more { 2 } else { 0 });
371 out.push(7); out.extend_from_slice(&u32_bytes((end - at + 4) as u32));
373 out.extend_from_slice(&request_id);
374 out.extend_from_slice(&whole[at..end]);
375 at = end;
376 }
377 OutMessage::from(out)
378 }
379
380 pub fn with_reply_header(
390 self,
391 header: &ReplyHeader,
392 ) -> std::result::Result<OutMessage, OutMessage> {
393 if self.bytes.len() < MessageHeader::SIZE || self.bytes[7] != 1 {
394 return Err(self);
395 }
396 let version = Version {
397 major: self.bytes[4],
398 minor: self.bytes[5],
399 };
400 let order = if self.bytes[6] & 1 != 0 {
401 ByteOrder::Little
402 } else {
403 ByteOrder::Big
404 };
405 let Ok(head) = MessageEncoder::reply(version, order, header) else {
406 return Err(self);
407 };
408 let (mut bytes, _) = head.enc.into_parts();
409 let new_header_len = bytes.len();
410 let has_body = self.len > self.header_len;
411 let (old_start, new_start) = if version >= Version::V1_2 && has_body {
412 ((self.header_len + 7) & !7, (new_header_len + 7) & !7)
413 } else {
414 (self.header_len, new_header_len)
415 };
416 if version < Version::V1_2 && (new_start % 8) != (old_start % 8) {
417 return Err(self);
418 }
419 let size = self.len - old_start + new_start;
420 let Ok(message_size) = u32::try_from(size - MessageHeader::SIZE) else {
421 return Err(self);
422 };
423 bytes.resize(new_start, 0);
424 bytes.extend_from_slice(&self.bytes[old_start..]);
425 let size_bytes = match order {
426 ByteOrder::Big => message_size.to_be_bytes(),
427 ByteOrder::Little => message_size.to_le_bytes(),
428 };
429 bytes[8..12].copy_from_slice(&size_bytes);
430 let shared = self
431 .shared
432 .into_iter()
433 .map(|(at, octets)| (at - old_start + new_start, octets))
434 .collect();
435 Ok(OutMessage {
436 bytes,
437 shared,
438 len: size,
439 header_len: new_header_len,
440 })
441 }
442
443 pub fn into_vec(self) -> Vec<u8> {
445 if self.shared.is_empty() {
446 return self.bytes;
447 }
448 let mut out = Vec::with_capacity(self.len);
449 for piece in self.pieces() {
450 out.extend_from_slice(piece);
451 }
452 out
453 }
454}
455
456impl From<Vec<u8>> for OutMessage {
457 fn from(bytes: Vec<u8>) -> OutMessage {
458 let len = bytes.len();
459 OutMessage {
460 bytes,
461 shared: Vec::new(),
462 len,
463 header_len: len,
464 }
465 }
466}