use std::sync::Arc;
use rustorb_cdr::{ByteOrder, CdrDecode, CdrEncode, CdrVersion, Decoder, Encoder, Segment};
use crate::{Error, Ior, MessageHeader, MsgType, Result, ServiceContext, TaggedProfile, Version};
pub mod response_flags {
pub const NONE: u8 = 0x00;
pub const SYNC_WITH_SERVER: u8 = 0x01;
pub const SYNC_WITH_TARGET: u8 = 0x03;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AddressingDisposition {
Key,
Profile,
Reference,
}
impl AddressingDisposition {
pub fn to_i16(self) -> i16 {
self as i16
}
pub fn from_i16(value: i16) -> Result<AddressingDisposition> {
match value {
0 => Ok(AddressingDisposition::Key),
1 => Ok(AddressingDisposition::Profile),
2 => Ok(AddressingDisposition::Reference),
other => Err(Error::InvalidAddressingDisposition(other)),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TargetAddress {
Key(Vec<u8>),
Profile(TaggedProfile),
Reference {
selected_profile_index: u32,
ior: Ior,
},
}
impl TargetAddress {
pub fn disposition(&self) -> AddressingDisposition {
match self {
TargetAddress::Key(_) => AddressingDisposition::Key,
TargetAddress::Profile(_) => AddressingDisposition::Profile,
TargetAddress::Reference { .. } => AddressingDisposition::Reference,
}
}
pub fn object_key(&self) -> Option<&[u8]> {
match self {
TargetAddress::Key(key) => Some(key),
_ => None,
}
}
pub(crate) fn encode(&self, enc: &mut Encoder) -> Result<()> {
enc.write_i16(self.disposition().to_i16());
match self {
TargetAddress::Key(key) => enc.write_octet_seq(key)?,
TargetAddress::Profile(profile) => profile.encode(enc)?,
TargetAddress::Reference {
selected_profile_index,
ior,
} => {
enc.write_u32(*selected_profile_index);
ior.encode(enc)?;
}
}
Ok(())
}
pub(crate) fn decode(dec: &mut Decoder<'_>) -> Result<TargetAddress> {
Ok(match AddressingDisposition::from_i16(dec.read_i16()?)? {
AddressingDisposition::Key => TargetAddress::Key(dec.read_octet_seq()?.to_vec()),
AddressingDisposition::Profile => TargetAddress::Profile(TaggedProfile::decode(dec)?),
AddressingDisposition::Reference => TargetAddress::Reference {
selected_profile_index: dec.read_u32()?,
ior: Ior::decode(dec)?,
},
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RequestHeader {
pub request_id: u32,
pub response_flags: u8,
pub target: TargetAddress,
pub operation: String,
pub service_context: Vec<ServiceContext>,
pub requesting_principal: Vec<u8>,
}
impl RequestHeader {
pub fn response_expected(&self) -> bool {
self.response_flags & 0x01 != 0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ReplyStatus {
NoException,
UserException,
SystemException,
LocationForward,
LocationForwardPerm,
NeedsAddressingMode,
}
impl ReplyStatus {
pub fn to_u32(self) -> u32 {
self as u32
}
pub fn from_u32(value: u32) -> Result<ReplyStatus> {
Ok(match value {
0 => ReplyStatus::NoException,
1 => ReplyStatus::UserException,
2 => ReplyStatus::SystemException,
3 => ReplyStatus::LocationForward,
4 => ReplyStatus::LocationForwardPerm,
5 => ReplyStatus::NeedsAddressingMode,
other => return Err(Error::InvalidReplyStatus(other)),
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ReplyHeader {
pub request_id: u32,
pub reply_status: ReplyStatus,
pub service_context: Vec<ServiceContext>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CancelRequestHeader {
pub request_id: u32,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LocateRequestHeader {
pub request_id: u32,
pub target: TargetAddress,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum LocateStatus {
UnknownObject,
ObjectHere,
ObjectForward,
ObjectForwardPerm,
LocSystemException,
LocNeedsAddressingMode,
}
impl LocateStatus {
pub fn to_u32(self) -> u32 {
self as u32
}
pub fn from_u32(value: u32) -> Result<LocateStatus> {
Ok(match value {
0 => LocateStatus::UnknownObject,
1 => LocateStatus::ObjectHere,
2 => LocateStatus::ObjectForward,
3 => LocateStatus::ObjectForwardPerm,
4 => LocateStatus::LocSystemException,
5 => LocateStatus::LocNeedsAddressingMode,
other => return Err(Error::InvalidLocateStatus(other)),
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LocateReplyHeader {
pub request_id: u32,
pub locate_status: LocateStatus,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FragmentHeader {
pub request_id: Option<u32>,
}
#[derive(Debug, Clone)]
pub struct Body {
buf: Arc<Vec<u8>>,
start: usize,
offset: usize,
segments: Vec<Segment>,
byte_order: ByteOrder,
version: CdrVersion,
}
impl PartialEq for Body {
fn eq(&self, other: &Body) -> bool {
self.as_bytes() == other.as_bytes()
&& self.offset == other.offset
&& self.segments == other.segments
&& self.byte_order == other.byte_order
&& self.version == other.version
}
}
impl Eq for Body {}
impl Body {
fn new(dec: &Decoder<'_>, src: &Source<'_>) -> Body {
let start = src.buf.len() - dec.remaining();
Body {
buf: Arc::clone(src.buf),
start,
offset: dec.position(),
segments: src
.segments
.iter()
.filter(|s| s.start > start)
.map(|s| Segment {
start: s.start - start,
offset: s.offset,
})
.collect(),
byte_order: dec.byte_order(),
version: dec.version(),
}
}
pub fn as_bytes(&self) -> &[u8] {
&self.buf[self.start..]
}
pub fn offset(&self) -> usize {
self.offset
}
pub fn byte_order(&self) -> ByteOrder {
self.byte_order
}
pub fn is_empty(&self) -> bool {
self.as_bytes().is_empty()
}
pub fn segments(&self) -> &[Segment] {
&self.segments
}
pub fn decoder(&self) -> Decoder<'_> {
let mut dec =
Decoder::with_offset(self.as_bytes(), self.byte_order, self.version, self.offset);
dec.set_segments(&self.segments);
dec.set_shared(&self.buf);
dec
}
}
struct Source<'a> {
buf: &'a Arc<Vec<u8>>,
segments: &'a [Segment],
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Message {
Request {
header: RequestHeader,
body: Body,
},
Reply {
header: ReplyHeader,
body: Body,
},
CancelRequest(CancelRequestHeader),
LocateRequest(LocateRequestHeader),
LocateReply {
header: LocateReplyHeader,
body: Body,
},
CloseConnection,
MessageError,
Fragment {
header: FragmentHeader,
body: Body,
},
}
impl Message {
pub fn msg_type(&self) -> MsgType {
match self {
Message::Request { .. } => MsgType::Request,
Message::Reply { .. } => MsgType::Reply,
Message::CancelRequest(_) => MsgType::CancelRequest,
Message::LocateRequest(_) => MsgType::LocateRequest,
Message::LocateReply { .. } => MsgType::LocateReply,
Message::CloseConnection => MsgType::CloseConnection,
Message::MessageError => MsgType::MessageError,
Message::Fragment { .. } => MsgType::Fragment,
}
}
}
pub fn decode_message(buf: &[u8]) -> Result<(MessageHeader, Message)> {
decode_segmented(&Arc::new(buf.to_vec()), &[])
}
pub(crate) fn decode_segmented(
buf: &Arc<Vec<u8>>,
segments: &[Segment],
) -> Result<(MessageHeader, Message)> {
let header = MessageHeader::parse(buf)?;
let expected = header.total_len();
if buf.len() < expected {
return Err(Error::Truncated {
expected,
actual: buf.len(),
});
}
if buf.len() > expected {
return Err(Error::TrailingBytes(buf.len() - expected));
}
let mut dec = Decoder::new(buf, header.byte_order, header.version.cdr_version());
dec.set_segments(segments);
dec.skip(MessageHeader::SIZE)?;
let src = Source { buf, segments };
let message = decode_body(&header, &mut dec, &src)?;
Ok((header, message))
}
fn decode_body(header: &MessageHeader, dec: &mut Decoder<'_>, src: &Source<'_>) -> Result<Message> {
let v12 = header.version >= Version::V1_2;
Ok(match header.msg_type {
MsgType::Request => {
let header = if v12 {
let request_id = dec.read_u32()?;
let response_flags = dec.read_octet()?;
dec.skip(3)?;
let target = TargetAddress::decode(dec)?;
let operation = dec.read_string()?;
let service_context = Vec::decode(dec)?;
RequestHeader {
request_id,
response_flags,
target,
operation,
service_context,
requesting_principal: Vec::new(),
}
} else {
let service_context = Vec::decode(dec)?;
let request_id = dec.read_u32()?;
let response_expected = dec.read_bool()?;
if header.version.minor == 1 {
dec.skip(3)?;
}
let object_key = dec.read_octet_seq()?.to_vec();
let operation = dec.read_string()?;
let requesting_principal = dec.read_octet_seq()?.to_vec();
RequestHeader {
request_id,
response_flags: if response_expected {
response_flags::SYNC_WITH_TARGET
} else {
response_flags::NONE
},
target: TargetAddress::Key(object_key),
operation,
service_context,
requesting_principal,
}
};
Message::Request {
header,
body: body_after_header(dec, src, v12),
}
}
MsgType::Reply => {
let header = if v12 {
let request_id = dec.read_u32()?;
let reply_status = ReplyStatus::from_u32(dec.read_u32()?)?;
let service_context = Vec::decode(dec)?;
ReplyHeader {
request_id,
reply_status,
service_context,
}
} else {
let service_context = Vec::decode(dec)?;
let request_id = dec.read_u32()?;
let reply_status = ReplyStatus::from_u32(dec.read_u32()?)?;
ReplyHeader {
request_id,
reply_status,
service_context,
}
};
Message::Reply {
header,
body: body_after_header(dec, src, v12),
}
}
MsgType::CancelRequest => Message::CancelRequest(CancelRequestHeader {
request_id: dec.read_u32()?,
}),
MsgType::LocateRequest => {
let request_id = dec.read_u32()?;
let target = if v12 {
TargetAddress::decode(dec)?
} else {
TargetAddress::Key(dec.read_octet_seq()?.to_vec())
};
Message::LocateRequest(LocateRequestHeader { request_id, target })
}
MsgType::LocateReply => {
let header = LocateReplyHeader {
request_id: dec.read_u32()?,
locate_status: LocateStatus::from_u32(dec.read_u32()?)?,
};
Message::LocateReply {
header,
body: body_after_header(dec, src, v12),
}
}
MsgType::CloseConnection => Message::CloseConnection,
MsgType::MessageError => Message::MessageError,
MsgType::Fragment => {
let request_id = if v12 { Some(dec.read_u32()?) } else { None };
Message::Fragment {
header: FragmentHeader { request_id },
body: Body::new(dec, src),
}
}
})
}
fn body_after_header(dec: &mut Decoder<'_>, src: &Source<'_>, v12: bool) -> Body {
if v12 {
let pad = (8 - dec.position() % 8) % 8;
if dec.remaining() > pad {
dec.skip(pad).expect("checked remaining");
} else {
dec.skip(dec.remaining()).expect("checked remaining");
}
}
Body::new(dec, src)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CompletionStatus {
Yes,
No,
Maybe,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SystemExceptionBody {
pub exception_id: String,
pub minor_code_value: u32,
pub completion_status: CompletionStatus,
}
impl CdrEncode for SystemExceptionBody {
fn encode(&self, enc: &mut Encoder) -> rustorb_cdr::Result<()> {
enc.write_string(&self.exception_id)?;
enc.write_u32(self.minor_code_value);
enc.write_u32(self.completion_status as u32);
Ok(())
}
}
impl CdrDecode for SystemExceptionBody {
fn decode(dec: &mut Decoder<'_>) -> rustorb_cdr::Result<Self> {
let exception_id = dec.read_string()?;
let minor_code_value = dec.read_u32()?;
let completion_status = match dec.read_u32()? {
0 => CompletionStatus::Yes,
1 => CompletionStatus::No,
2 => CompletionStatus::Maybe,
other => return Err(rustorb_cdr::Error::InvalidEnumValue(other)),
};
Ok(SystemExceptionBody {
exception_id,
minor_code_value,
completion_status,
})
}
}