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        }
191        &mut self.enc
192    }
193
194    /// The version of the message.
195    pub fn version(&self) -> Version {
196        self.version
197    }
198
199    /// Fills in the message size and returns the message bytes. Body
200    /// padding is dropped again if no body was written.
201    pub fn finish(self) -> Result<Vec<u8>> {
202        Ok(self.finish_shared()?.into_vec())
203    }
204
205    /// Like [`finish`](MessageEncoder::finish), but large octet sequences
206    /// written with
207    /// [`write_octet_seq_shared`](Encoder::write_octet_seq_shared) stay
208    /// where they are, for a vectored write.
209    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/// A whole message to send: its bytes, with large octet sequences that
238/// were not copied in kept apart.
239#[derive(Debug, Clone, Default, PartialEq, Eq)]
240pub struct OutMessage {
241    bytes: Vec<u8>,
242    /// Each with the length of `bytes` at which it goes.
243    shared: Vec<(usize, Octets)>,
244    len: usize,
245    /// Where the body starts (before its padding): the message header and
246    /// the message-specific header come before it.
247    header_len: usize,
248}
249
250impl OutMessage {
251    /// The length of the message.
252    pub fn len(&self) -> usize {
253        self.len
254    }
255
256    /// Whether the message has no bytes.
257    pub fn is_empty(&self) -> bool {
258        self.len == 0
259    }
260
261    /// The whole message, if it is one piece.
262    pub fn as_single(&self) -> Option<&[u8]> {
263        self.shared.is_empty().then_some(&self.bytes[..])
264    }
265
266    /// The pieces of the message from offset `from` on, in order, for a
267    /// vectored write; at most `max` of them.
268    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    /// The pieces of the message in order.
285    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    /// Splits a GIOP 1.2 `Request`, `Reply` or `LocateReply` longer than
311    /// `size` bytes into a first message and `Fragment` messages of at
312    /// most `size` bytes each (`size` rounded down to a multiple of 8, at
313    /// least 64), returned one after the other in one `OutMessage`. Other
314    /// messages, and messages that fit, are returned as they are.
315    ///
316    /// The first message keeps the whole message-specific header. Every
317    /// message but the last is a multiple of 8 bytes long, so the body
318    /// keeps its alignment whether it is read relative to the start of
319    /// the whole message or of each `Fragment` (16 bytes of headers).
320    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); // Request, Reply, LocateReply
335        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); // Fragment
372            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    /// The same `Reply` (made with [`MessageEncoder::reply`]) with the
381    /// message-specific header `header` instead, for service contexts that
382    /// are known only once the body has been written. The body is kept as
383    /// it is: in GIOP 1.2 it starts on an 8-byte boundary after the
384    /// header, so it does not depend on the header's length. Before GIOP
385    /// 1.2 it follows the header directly and is aligned from the start of
386    /// the message, so a header whose length differs by other than a
387    /// multiple of 8 would misalign it: then `Err` returns the message
388    /// unchanged.
389    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    /// The message as one buffer; copies only if octets were kept apart.
444    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}