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 size =
217            u32::try_from(len - MessageHeader::SIZE).map_err(|_| Error::MessageTooLarge(len))?;
218        let size = match self.enc.byte_order() {
219            ByteOrder::Big => size.to_be_bytes(),
220            ByteOrder::Little => size.to_le_bytes(),
221        };
222        self.enc.as_bytes_mut()[8..12].copy_from_slice(&size);
223        let (bytes, shared) = self.enc.into_parts();
224        Ok(OutMessage { bytes, shared, len })
225    }
226}
227
228/// A whole message to send: its bytes, with large octet sequences that
229/// were not copied in kept apart.
230#[derive(Debug, Clone, Default, PartialEq, Eq)]
231pub struct OutMessage {
232    bytes: Vec<u8>,
233    /// Each with the length of `bytes` at which it goes.
234    shared: Vec<(usize, Octets)>,
235    len: usize,
236}
237
238impl OutMessage {
239    /// The length of the message.
240    pub fn len(&self) -> usize {
241        self.len
242    }
243
244    /// Whether the message has no bytes.
245    pub fn is_empty(&self) -> bool {
246        self.len == 0
247    }
248
249    /// The whole message, if it is one piece.
250    pub fn as_single(&self) -> Option<&[u8]> {
251        self.shared.is_empty().then_some(&self.bytes[..])
252    }
253
254    /// The pieces of the message from offset `from` on, in order, for a
255    /// vectored write; at most `max` of them.
256    pub fn slices_from(&self, from: usize, max: usize) -> Vec<IoSlice<'_>> {
257        let mut out = Vec::new();
258        let mut offset = 0;
259        for piece in self.pieces() {
260            if out.len() == max {
261                break;
262            }
263            let end = offset + piece.len();
264            if end > from {
265                out.push(IoSlice::new(&piece[from.saturating_sub(offset)..]));
266            }
267            offset = end;
268        }
269        out
270    }
271
272    /// The pieces of the message in order.
273    pub fn pieces(&self) -> impl Iterator<Item = &[u8]> {
274        let mut from = 0;
275        let mut shared = self.shared.iter();
276        let mut pending: Option<&[u8]> = None;
277        std::iter::from_fn(move || {
278            if let Some(octets) = pending.take() {
279                return Some(octets);
280            }
281            match shared.next() {
282                Some((at, octets)) => {
283                    let piece = &self.bytes[from..*at];
284                    from = *at;
285                    pending = Some(octets.as_slice());
286                    Some(piece)
287                }
288                None if from != usize::MAX => {
289                    let piece = &self.bytes[from..];
290                    from = usize::MAX;
291                    Some(piece)
292                }
293                None => None,
294            }
295        })
296    }
297
298    /// The message as one buffer; copies only if octets were kept apart.
299    pub fn into_vec(self) -> Vec<u8> {
300        if self.shared.is_empty() {
301            return self.bytes;
302        }
303        let mut out = Vec::with_capacity(self.len);
304        for piece in self.pieces() {
305            out.extend_from_slice(piece);
306        }
307        out
308    }
309}
310
311impl From<Vec<u8>> for OutMessage {
312    fn from(bytes: Vec<u8>) -> OutMessage {
313        let len = bytes.len();
314        OutMessage {
315            bytes,
316            shared: Vec::new(),
317            len,
318        }
319    }
320}