Skip to main content

rustorb_giop/
writer.rs

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/// Writes one GIOP message.
11///
12/// A constructor writes the message header and the message-specific
13/// header; [`body`](MessageEncoder::body) gives an encoder for the body,
14/// aligned as the version requires; [`finish`](MessageEncoder::finish)
15/// fills in the message size.
16#[derive(Debug)]
17pub struct MessageEncoder {
18    enc: Encoder,
19    version: Version,
20    align_body: bool,
21    /// Length before body padding, and length after it, once `body` was
22    /// called.
23    body_start: Option<(usize, usize)>,
24}
25
26impl MessageEncoder {
27    /// Starts a message of any type with an empty body.
28    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        // Room for the headers and a small body without growing.
51        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    /// Starts a `Request`.
62    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    /// Starts a `Reply`.
93    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    /// Writes a `CancelRequest`.
114    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    /// Writes a `LocateRequest`.
125    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    /// Starts a `LocateReply`.
142    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    /// Writes a `CloseConnection`.
155    pub fn close_connection(version: Version, order: ByteOrder) -> Result<Vec<u8>> {
156        MessageEncoder::new(version, order, MsgType::CloseConnection, false)?.finish()
157    }
158
159    /// Writes a `MessageError`.
160    pub fn message_error(version: Version, order: ByteOrder) -> Result<Vec<u8>> {
161        MessageEncoder::new(version, order, MsgType::MessageError, false)?.finish()
162    }
163
164    /// Starts a `Fragment`. `request_id` is required for GIOP 1.2 and
165    /// ignored for GIOP 1.1. The caller writes the continuation bytes with
166    /// [`body`](MessageEncoder::body).
167    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    /// The encoder for the message body. In GIOP 1.2 the first call pads
181    /// to an 8-byte boundary for Request, Reply and LocateReply bodies.
182    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                // So that `OutMessage::with_reply_header` can move the
192                // body by 4 bytes.
193                self.enc.track_align8();
194            }
195        }
196        &mut self.enc
197    }
198
199    /// The version of the message.
200    pub fn version(&self) -> Version {
201        self.version
202    }
203
204    /// Fills in the message size and returns the message bytes. Body
205    /// padding is dropped again if no body was written.
206    pub fn finish(self) -> Result<Vec<u8>> {
207        Ok(self.finish_shared()?.into_vec())
208    }
209
210    /// Like [`finish`](MessageEncoder::finish), but large octet sequences
211    /// written with
212    /// [`write_octet_seq_shared`](Encoder::write_octet_seq_shared) stay
213    /// where they are, for a vectored write.
214    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/// A whole message to send: its bytes, with large octet sequences that
245/// were not copied in kept apart.
246#[derive(Debug, Clone, Default, PartialEq, Eq)]
247pub struct OutMessage {
248    bytes: Vec<u8>,
249    /// Each with the length of `bytes` at which it goes.
250    shared: Vec<(usize, Octets)>,
251    len: usize,
252    /// Where the body starts (before its padding): the message header and
253    /// the message-specific header come before it.
254    header_len: usize,
255    /// Before GIOP 1.2, the 8-byte alignment points of the body (indexes
256    /// in `bytes` before the padding, and the padding), if its bytes
257    /// depend on stream offsets only through them.
258    align8: Option<Vec<(usize, usize)>>,
259}
260
261impl OutMessage {
262    /// The length of the message.
263    pub fn len(&self) -> usize {
264        self.len
265    }
266
267    /// Whether the message has no bytes.
268    pub fn is_empty(&self) -> bool {
269        self.len == 0
270    }
271
272    /// The whole message, if it is one piece.
273    pub fn as_single(&self) -> Option<&[u8]> {
274        self.shared.is_empty().then_some(&self.bytes[..])
275    }
276
277    /// The pieces of the message from offset `from` on, in order, for a
278    /// vectored write; at most `max` of them.
279    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    /// The pieces of the message in order.
296    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    /// Splits a GIOP 1.2 `Request`, `Reply` or `LocateReply` longer than
322    /// `size` bytes into a first message and `Fragment` messages of at
323    /// most `size` bytes each (`size` rounded down to a multiple of 8, at
324    /// least 64), returned one after the other in one `OutMessage`. Other
325    /// messages, and messages that fit, are returned as they are.
326    ///
327    /// The first message keeps the whole message-specific header. Every
328    /// message but the last is a multiple of 8 bytes long, so the body
329    /// keeps its alignment whether it is read relative to the start of
330    /// the whole message or of each `Fragment` (16 bytes of headers).
331    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); // Request, Reply, LocateReply
346        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); // Fragment
383            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    /// The same `Reply` (made with [`MessageEncoder::reply`]) with the
392    /// message-specific header `header` instead, for service contexts that
393    /// are known only once the body has been written. The body is kept as
394    /// it is: in GIOP 1.2 it starts on an 8-byte boundary after the
395    /// header, so it does not depend on the header's length. Before GIOP
396    /// 1.2 it follows the header directly and is aligned from the start of
397    /// the message, so a header whose length differs by 4 modulo 8 moves
398    /// it off its alignment. Then the padding before each 8-byte aligned
399    /// item of the body is written again (data aligned to at most 4 bytes
400    /// is unaffected), unless the body holds something else whose bytes
401    /// depend on stream offsets (a valuetype, a `TypeCode` indirection):
402    /// then `Err` returns the message unchanged.
403    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            // Each point grows the body by at most 4 bytes.
432            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    /// The body (from `old_start`) after the new header `bytes`, which
467    /// ends at `new_start`, with the padding at each 8-byte alignment
468    /// point of the body written again for its new offset.
469    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        // Shared octets placed so far: they come between buffer bytes.
481        let mut extra = 0;
482        let mut from = old_start;
483        for (at, old_pad) in self.align8.unwrap_or_default() {
484            // Shared octets written before this point come before its
485            // padding.
486            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    /// The message as one buffer; copies only if octets were kept apart.
517    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}