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 if self.version < Version::V1_2 {
191 self.enc.track_align8();
194 }
195 }
196 &mut self.enc
197 }
198
199 pub fn version(&self) -> Version {
201 self.version
202 }
203
204 pub fn finish(self) -> Result<Vec<u8>> {
207 Ok(self.finish_shared()?.into_vec())
208 }
209
210 pub fn finish_shared(mut self) -> Result<OutMessage> {
215 let align8 = self.enc.take_align8();
216 if let Some((before, after)) = self.body_start {
217 if self.enc.len() == after {
218 self.enc.truncate(before);
219 }
220 }
221 let len = self.enc.len();
222 let header_len = match self.body_start {
223 Some((before, _)) => before,
224 None => len,
225 };
226 let size =
227 u32::try_from(len - MessageHeader::SIZE).map_err(|_| Error::MessageTooLarge(len))?;
228 let size = match self.enc.byte_order() {
229 ByteOrder::Big => size.to_be_bytes(),
230 ByteOrder::Little => size.to_le_bytes(),
231 };
232 self.enc.as_bytes_mut()[8..12].copy_from_slice(&size);
233 let (bytes, shared) = self.enc.into_parts();
234 Ok(OutMessage {
235 bytes,
236 shared,
237 len,
238 header_len,
239 align8,
240 })
241 }
242}
243
244#[derive(Debug, Clone, Default, PartialEq, Eq)]
247pub struct OutMessage {
248 bytes: Vec<u8>,
249 shared: Vec<(usize, Octets)>,
251 len: usize,
252 header_len: usize,
255 align8: Option<Vec<(usize, usize)>>,
259}
260
261impl OutMessage {
262 pub fn len(&self) -> usize {
264 self.len
265 }
266
267 pub fn is_empty(&self) -> bool {
269 self.len == 0
270 }
271
272 pub fn as_single(&self) -> Option<&[u8]> {
274 self.shared.is_empty().then_some(&self.bytes[..])
275 }
276
277 pub fn slices_from(&self, from: usize, max: usize) -> Vec<IoSlice<'_>> {
280 let mut out = Vec::new();
281 let mut offset = 0;
282 for piece in self.pieces() {
283 if out.len() == max {
284 break;
285 }
286 let end = offset + piece.len();
287 if end > from {
288 out.push(IoSlice::new(&piece[from.saturating_sub(offset)..]));
289 }
290 offset = end;
291 }
292 out
293 }
294
295 pub fn pieces(&self) -> impl Iterator<Item = &[u8]> {
297 let mut from = 0;
298 let mut shared = self.shared.iter();
299 let mut pending: Option<&[u8]> = None;
300 std::iter::from_fn(move || {
301 if let Some(octets) = pending.take() {
302 return Some(octets);
303 }
304 match shared.next() {
305 Some((at, octets)) => {
306 let piece = &self.bytes[from..*at];
307 from = *at;
308 pending = Some(octets.as_slice());
309 Some(piece)
310 }
311 None if from != usize::MAX => {
312 let piece = &self.bytes[from..];
313 from = usize::MAX;
314 Some(piece)
315 }
316 None => None,
317 }
318 })
319 }
320
321 pub fn fragment(self, size: usize) -> OutMessage {
332 if self.len <= size || self.bytes.len() < MessageHeader::SIZE + 4 {
333 return self;
334 }
335 let size = (size & !7).max(64);
336 if self.len <= size {
337 return self;
338 }
339 let head = &self.bytes[..MessageHeader::SIZE];
340 let version = Version {
341 major: head[4],
342 minor: head[5],
343 };
344 let flags = head[6];
345 let fragmentable = matches!(head[7], 0 | 1 | 4); if version != Version::V1_2 || !fragmentable || flags & 2 != 0 {
347 return self;
348 }
349 let first = size.max((self.header_len + 7) & !7);
350 if first >= self.len {
351 return self;
352 }
353 let order = if flags & 1 != 0 {
354 ByteOrder::Little
355 } else {
356 ByteOrder::Big
357 };
358 let u32_bytes = |v: u32| match order {
359 ByteOrder::Big => v.to_be_bytes(),
360 ByteOrder::Little => v.to_le_bytes(),
361 };
362 let request_id = [
363 self.bytes[12],
364 self.bytes[13],
365 self.bytes[14],
366 self.bytes[15],
367 ];
368 let len = self.len;
369 let whole = self.into_vec();
370 let per = size - MessageHeader::SIZE - 4;
371 let count = 1 + (len - first).div_ceil(per);
372 let mut out = Vec::with_capacity(len + count * (MessageHeader::SIZE + 4));
373 out.extend_from_slice(&whole[..first]);
374 out[6] |= 2;
375 out[8..12].copy_from_slice(&u32_bytes((first - MessageHeader::SIZE) as u32));
376 let mut at = first;
377 while at < len {
378 let end = (at + per).min(len);
379 let more = end < len;
380 out.extend_from_slice(&whole[..6]);
381 out.push(flags & 1 | if more { 2 } else { 0 });
382 out.push(7); out.extend_from_slice(&u32_bytes((end - at + 4) as u32));
384 out.extend_from_slice(&request_id);
385 out.extend_from_slice(&whole[at..end]);
386 at = end;
387 }
388 OutMessage::from(out)
389 }
390
391 pub fn with_reply_header(
404 self,
405 header: &ReplyHeader,
406 ) -> std::result::Result<OutMessage, OutMessage> {
407 if self.bytes.len() < MessageHeader::SIZE || self.bytes[7] != 1 {
408 return Err(self);
409 }
410 let version = Version {
411 major: self.bytes[4],
412 minor: self.bytes[5],
413 };
414 let order = if self.bytes[6] & 1 != 0 {
415 ByteOrder::Little
416 } else {
417 ByteOrder::Big
418 };
419 let Ok(head) = MessageEncoder::reply(version, order, header) else {
420 return Err(self);
421 };
422 let (mut bytes, _) = head.enc.into_parts();
423 let new_header_len = bytes.len();
424 let has_body = self.len > self.header_len;
425 let (old_start, new_start) = if version >= Version::V1_2 && has_body {
426 ((self.header_len + 7) & !7, (new_header_len + 7) & !7)
427 } else {
428 (self.header_len, new_header_len)
429 };
430 if version < Version::V1_2 && (new_start % 8) != (old_start % 8) {
431 let grown =
433 |points: &Vec<(usize, usize)>| self.len - old_start + new_start + 4 * points.len();
434 return match &self.align8 {
435 Some(points) if u32::try_from(grown(points)).is_ok() => {
436 Ok(self.realigned(bytes, old_start, new_start, order))
437 }
438 _ => Err(self),
439 };
440 }
441 let size = self.len - old_start + new_start;
442 let Ok(message_size) = u32::try_from(size - MessageHeader::SIZE) else {
443 return Err(self);
444 };
445 bytes.resize(new_start, 0);
446 bytes.extend_from_slice(&self.bytes[old_start..]);
447 let size_bytes = match order {
448 ByteOrder::Big => message_size.to_be_bytes(),
449 ByteOrder::Little => message_size.to_le_bytes(),
450 };
451 bytes[8..12].copy_from_slice(&size_bytes);
452 let shared = self
453 .shared
454 .into_iter()
455 .map(|(at, octets)| (at - old_start + new_start, octets))
456 .collect();
457 Ok(OutMessage {
458 bytes,
459 shared,
460 len: size,
461 header_len: new_header_len,
462 align8: None,
463 })
464 }
465
466 fn realigned(
470 self,
471 mut bytes: Vec<u8>,
472 old_start: usize,
473 new_start: usize,
474 order: ByteOrder,
475 ) -> OutMessage {
476 bytes.resize(new_start, 0);
477 let header_len = new_start;
478 let mut shared = Vec::with_capacity(self.shared.len());
479 let mut pending = self.shared.into_iter().peekable();
480 let mut extra = 0;
482 let mut from = old_start;
483 for (at, old_pad) in self.align8.unwrap_or_default() {
484 while let Some((j, octets)) = pending.next_if(|(j, _)| *j <= at) {
487 extra += octets.len();
488 shared.push((bytes.len() + j - from, octets));
489 }
490 bytes.extend_from_slice(&self.bytes[from..at]);
491 let pad = (8 - (bytes.len() + extra) % 8) % 8;
492 bytes.resize(bytes.len() + pad, 0);
493 from = at + old_pad;
494 }
495 for (j, octets) in pending {
496 extra += octets.len();
497 shared.push((bytes.len() + j - from, octets));
498 }
499 bytes.extend_from_slice(&self.bytes[from..]);
500 let len = bytes.len() + extra;
501 let message_size = (len - MessageHeader::SIZE) as u32;
502 let size_bytes = match order {
503 ByteOrder::Big => message_size.to_be_bytes(),
504 ByteOrder::Little => message_size.to_le_bytes(),
505 };
506 bytes[8..12].copy_from_slice(&size_bytes);
507 OutMessage {
508 bytes,
509 shared,
510 len,
511 header_len,
512 align8: None,
513 }
514 }
515
516 pub fn into_vec(self) -> Vec<u8> {
518 if self.shared.is_empty() {
519 return self.bytes;
520 }
521 let mut out = Vec::with_capacity(self.len);
522 for piece in self.pieces() {
523 out.extend_from_slice(piece);
524 }
525 out
526 }
527}
528
529impl From<Vec<u8>> for OutMessage {
530 fn from(bytes: Vec<u8>) -> OutMessage {
531 let len = bytes.len();
532 OutMessage {
533 bytes,
534 shared: Vec::new(),
535 len,
536 header_len: len,
537 align8: None,
538 }
539 }
540}