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 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#[derive(Debug, Clone, Default, PartialEq, Eq)]
231pub struct OutMessage {
232 bytes: Vec<u8>,
233 shared: Vec<(usize, Octets)>,
235 len: usize,
236}
237
238impl OutMessage {
239 pub fn len(&self) -> usize {
241 self.len
242 }
243
244 pub fn is_empty(&self) -> bool {
246 self.len == 0
247 }
248
249 pub fn as_single(&self) -> Option<&[u8]> {
251 self.shared.is_empty().then_some(&self.bytes[..])
252 }
253
254 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 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 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}