use std::io::IoSlice;
use rustorb_cdr::{ByteOrder, CdrEncode, Encoder, Octets};
use crate::{
CancelRequestHeader, Error, LocateReplyHeader, LocateRequestHeader, MessageHeader, MsgType,
ReplyHeader, RequestHeader, Result, Version,
};
#[derive(Debug)]
pub struct MessageEncoder {
enc: Encoder,
version: Version,
align_body: bool,
body_start: Option<(usize, usize)>,
}
impl MessageEncoder {
pub fn new(
version: Version,
order: ByteOrder,
msg_type: MsgType,
more_fragments: bool,
) -> Result<MessageEncoder> {
if !version.is_supported() {
return Err(Error::UnsupportedVersion(version));
}
if msg_type == MsgType::Fragment && version == Version::V1_0
|| more_fragments && version == Version::V1_0
{
return Err(Error::FragmentNotSupported);
}
let header = MessageHeader {
version,
byte_order: order,
more_fragments,
msg_type,
message_size: 0,
};
let mut enc = Encoder::new(order, version.cdr_version());
enc.reserve(256);
enc.write_octets(&header.to_bytes());
Ok(MessageEncoder {
enc,
version,
align_body: false,
body_start: None,
})
}
pub fn request(
version: Version,
order: ByteOrder,
header: &RequestHeader,
) -> Result<MessageEncoder> {
let mut m = MessageEncoder::new(version, order, MsgType::Request, false)?;
let enc = &mut m.enc;
if version >= Version::V1_2 {
enc.write_u32(header.request_id);
enc.write_octet(header.response_flags);
enc.write_octets(&[0; 3]);
header.target.encode(enc)?;
enc.write_string(&header.operation)?;
header.service_context.encode(enc)?;
m.align_body = true;
} else {
let key = header.target.object_key().ok_or(Error::TargetNotKey)?;
header.service_context.encode(enc)?;
enc.write_u32(header.request_id);
enc.write_bool(header.response_expected());
if version.minor == 1 {
enc.write_octets(&[0; 3]);
}
enc.write_octet_seq(key)?;
enc.write_string(&header.operation)?;
enc.write_octet_seq(&header.requesting_principal)?;
}
Ok(m)
}
pub fn reply(
version: Version,
order: ByteOrder,
header: &ReplyHeader,
) -> Result<MessageEncoder> {
let mut m = MessageEncoder::new(version, order, MsgType::Reply, false)?;
let enc = &mut m.enc;
if version >= Version::V1_2 {
enc.write_u32(header.request_id);
enc.write_u32(header.reply_status.to_u32());
header.service_context.encode(enc)?;
m.align_body = true;
} else {
header.service_context.encode(enc)?;
enc.write_u32(header.request_id);
enc.write_u32(header.reply_status.to_u32());
}
Ok(m)
}
pub fn cancel_request(
version: Version,
order: ByteOrder,
header: &CancelRequestHeader,
) -> Result<Vec<u8>> {
let mut m = MessageEncoder::new(version, order, MsgType::CancelRequest, false)?;
m.enc.write_u32(header.request_id);
m.finish()
}
pub fn locate_request(
version: Version,
order: ByteOrder,
header: &LocateRequestHeader,
) -> Result<Vec<u8>> {
let mut m = MessageEncoder::new(version, order, MsgType::LocateRequest, false)?;
m.enc.write_u32(header.request_id);
if version >= Version::V1_2 {
header.target.encode(&mut m.enc)?;
} else {
let key = header.target.object_key().ok_or(Error::TargetNotKey)?;
m.enc.write_octet_seq(key)?;
}
m.finish()
}
pub fn locate_reply(
version: Version,
order: ByteOrder,
header: &LocateReplyHeader,
) -> Result<MessageEncoder> {
let mut m = MessageEncoder::new(version, order, MsgType::LocateReply, false)?;
m.enc.write_u32(header.request_id);
m.enc.write_u32(header.locate_status.to_u32());
m.align_body = version >= Version::V1_2;
Ok(m)
}
pub fn close_connection(version: Version, order: ByteOrder) -> Result<Vec<u8>> {
MessageEncoder::new(version, order, MsgType::CloseConnection, false)?.finish()
}
pub fn message_error(version: Version, order: ByteOrder) -> Result<Vec<u8>> {
MessageEncoder::new(version, order, MsgType::MessageError, false)?.finish()
}
pub fn fragment(
version: Version,
order: ByteOrder,
request_id: u32,
more_fragments: bool,
) -> Result<MessageEncoder> {
let mut m = MessageEncoder::new(version, order, MsgType::Fragment, more_fragments)?;
if version >= Version::V1_2 {
m.enc.write_u32(request_id);
}
Ok(m)
}
pub fn body(&mut self) -> &mut Encoder {
if self.body_start.is_none() {
let before = self.enc.len();
if self.align_body {
self.enc.align(8);
}
self.body_start = Some((before, self.enc.len()));
self.enc.allow_shared(true);
if self.version < Version::V1_2 {
self.enc.track_align8();
}
}
&mut self.enc
}
pub fn version(&self) -> Version {
self.version
}
pub fn finish(self) -> Result<Vec<u8>> {
Ok(self.finish_shared()?.into_vec())
}
pub fn finish_shared(mut self) -> Result<OutMessage> {
let align8 = self.enc.take_align8();
if let Some((before, after)) = self.body_start {
if self.enc.len() == after {
self.enc.truncate(before);
}
}
let len = self.enc.len();
let header_len = match self.body_start {
Some((before, _)) => before,
None => len,
};
let size =
u32::try_from(len - MessageHeader::SIZE).map_err(|_| Error::MessageTooLarge(len))?;
let size = match self.enc.byte_order() {
ByteOrder::Big => size.to_be_bytes(),
ByteOrder::Little => size.to_le_bytes(),
};
self.enc.as_bytes_mut()[8..12].copy_from_slice(&size);
let (bytes, shared) = self.enc.into_parts();
Ok(OutMessage {
bytes,
shared,
len,
header_len,
align8,
})
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct OutMessage {
bytes: Vec<u8>,
shared: Vec<(usize, Octets)>,
len: usize,
header_len: usize,
align8: Option<Vec<(usize, usize)>>,
}
impl OutMessage {
pub fn len(&self) -> usize {
self.len
}
pub fn is_empty(&self) -> bool {
self.len == 0
}
pub fn as_single(&self) -> Option<&[u8]> {
self.shared.is_empty().then_some(&self.bytes[..])
}
pub fn slices_from(&self, from: usize, max: usize) -> Vec<IoSlice<'_>> {
let mut out = Vec::new();
let mut offset = 0;
for piece in self.pieces() {
if out.len() == max {
break;
}
let end = offset + piece.len();
if end > from {
out.push(IoSlice::new(&piece[from.saturating_sub(offset)..]));
}
offset = end;
}
out
}
pub fn pieces(&self) -> impl Iterator<Item = &[u8]> {
let mut from = 0;
let mut shared = self.shared.iter();
let mut pending: Option<&[u8]> = None;
std::iter::from_fn(move || {
if let Some(octets) = pending.take() {
return Some(octets);
}
match shared.next() {
Some((at, octets)) => {
let piece = &self.bytes[from..*at];
from = *at;
pending = Some(octets.as_slice());
Some(piece)
}
None if from != usize::MAX => {
let piece = &self.bytes[from..];
from = usize::MAX;
Some(piece)
}
None => None,
}
})
}
pub fn fragment(self, size: usize) -> OutMessage {
if self.len <= size || self.bytes.len() < MessageHeader::SIZE + 4 {
return self;
}
let size = (size & !7).max(64);
if self.len <= size {
return self;
}
let head = &self.bytes[..MessageHeader::SIZE];
let version = Version {
major: head[4],
minor: head[5],
};
let flags = head[6];
let fragmentable = matches!(head[7], 0 | 1 | 4); if version != Version::V1_2 || !fragmentable || flags & 2 != 0 {
return self;
}
let first = size.max((self.header_len + 7) & !7);
if first >= self.len {
return self;
}
let order = if flags & 1 != 0 {
ByteOrder::Little
} else {
ByteOrder::Big
};
let u32_bytes = |v: u32| match order {
ByteOrder::Big => v.to_be_bytes(),
ByteOrder::Little => v.to_le_bytes(),
};
let request_id = [
self.bytes[12],
self.bytes[13],
self.bytes[14],
self.bytes[15],
];
let len = self.len;
let whole = self.into_vec();
let per = size - MessageHeader::SIZE - 4;
let count = 1 + (len - first).div_ceil(per);
let mut out = Vec::with_capacity(len + count * (MessageHeader::SIZE + 4));
out.extend_from_slice(&whole[..first]);
out[6] |= 2;
out[8..12].copy_from_slice(&u32_bytes((first - MessageHeader::SIZE) as u32));
let mut at = first;
while at < len {
let end = (at + per).min(len);
let more = end < len;
out.extend_from_slice(&whole[..6]);
out.push(flags & 1 | if more { 2 } else { 0 });
out.push(7); out.extend_from_slice(&u32_bytes((end - at + 4) as u32));
out.extend_from_slice(&request_id);
out.extend_from_slice(&whole[at..end]);
at = end;
}
OutMessage::from(out)
}
pub fn with_reply_header(
self,
header: &ReplyHeader,
) -> std::result::Result<OutMessage, OutMessage> {
if self.bytes.len() < MessageHeader::SIZE || self.bytes[7] != 1 {
return Err(self);
}
let version = Version {
major: self.bytes[4],
minor: self.bytes[5],
};
let order = if self.bytes[6] & 1 != 0 {
ByteOrder::Little
} else {
ByteOrder::Big
};
let Ok(head) = MessageEncoder::reply(version, order, header) else {
return Err(self);
};
let (mut bytes, _) = head.enc.into_parts();
let new_header_len = bytes.len();
let has_body = self.len > self.header_len;
let (old_start, new_start) = if version >= Version::V1_2 && has_body {
((self.header_len + 7) & !7, (new_header_len + 7) & !7)
} else {
(self.header_len, new_header_len)
};
if version < Version::V1_2 && (new_start % 8) != (old_start % 8) {
let grown =
|points: &Vec<(usize, usize)>| self.len - old_start + new_start + 4 * points.len();
return match &self.align8 {
Some(points) if u32::try_from(grown(points)).is_ok() => {
Ok(self.realigned(bytes, old_start, new_start, order))
}
_ => Err(self),
};
}
let size = self.len - old_start + new_start;
let Ok(message_size) = u32::try_from(size - MessageHeader::SIZE) else {
return Err(self);
};
bytes.resize(new_start, 0);
bytes.extend_from_slice(&self.bytes[old_start..]);
let size_bytes = match order {
ByteOrder::Big => message_size.to_be_bytes(),
ByteOrder::Little => message_size.to_le_bytes(),
};
bytes[8..12].copy_from_slice(&size_bytes);
let shared = self
.shared
.into_iter()
.map(|(at, octets)| (at - old_start + new_start, octets))
.collect();
Ok(OutMessage {
bytes,
shared,
len: size,
header_len: new_header_len,
align8: None,
})
}
fn realigned(
self,
mut bytes: Vec<u8>,
old_start: usize,
new_start: usize,
order: ByteOrder,
) -> OutMessage {
bytes.resize(new_start, 0);
let header_len = new_start;
let mut shared = Vec::with_capacity(self.shared.len());
let mut pending = self.shared.into_iter().peekable();
let mut extra = 0;
let mut from = old_start;
for (at, old_pad) in self.align8.unwrap_or_default() {
while let Some((j, octets)) = pending.next_if(|(j, _)| *j <= at) {
extra += octets.len();
shared.push((bytes.len() + j - from, octets));
}
bytes.extend_from_slice(&self.bytes[from..at]);
let pad = (8 - (bytes.len() + extra) % 8) % 8;
bytes.resize(bytes.len() + pad, 0);
from = at + old_pad;
}
for (j, octets) in pending {
extra += octets.len();
shared.push((bytes.len() + j - from, octets));
}
bytes.extend_from_slice(&self.bytes[from..]);
let len = bytes.len() + extra;
let message_size = (len - MessageHeader::SIZE) as u32;
let size_bytes = match order {
ByteOrder::Big => message_size.to_be_bytes(),
ByteOrder::Little => message_size.to_le_bytes(),
};
bytes[8..12].copy_from_slice(&size_bytes);
OutMessage {
bytes,
shared,
len,
header_len,
align8: None,
}
}
pub fn into_vec(self) -> Vec<u8> {
if self.shared.is_empty() {
return self.bytes;
}
let mut out = Vec::with_capacity(self.len);
for piece in self.pieces() {
out.extend_from_slice(piece);
}
out
}
}
impl From<Vec<u8>> for OutMessage {
fn from(bytes: Vec<u8>) -> OutMessage {
let len = bytes.len();
OutMessage {
bytes,
shared: Vec::new(),
len,
header_len: len,
align8: None,
}
}
}