Add owned variants of reply packet bodies (#5)

All owned packet bodies are currently crate-internal, but `ArgumentOwned` is publicly exposed.

Author: Zane Othman

src/protocol.rs

@@ -13,6 +13,9 @@ pub use packet::{Packet, PacketFlags, PacketType};
 mod arguments;
 pub use arguments::{Argument, Arguments, InvalidArgument};
 
+#[cfg(feature = "std")]
+pub use arguments::ArgumentOwned;
+
 mod fields;
 pub use fields::*;
 
@@ -268,3 +271,16 @@ trait Serialize: sealed::Sealed {
     /// Serializes data into a buffer, returning the resulting length on success.
     fn serialize_into_buffer(&self, buffer: &mut [u8]) -> Result<usize, SerializeError>;
 }
+
+/// Converts a reference-based packet to a packet that owns its fields.
+///
+/// A [`Borrow`](std::borrow::Borrow) impl for the different packet types would be nontrivial, if even possible,
+/// which is why the [`ToOwned`](std::borrow::ToOwned) trait isn't used.
+#[cfg(feature = "std")]
+pub(crate) trait ToOwnedBody: PacketBody {
+    /// The resulting owned packet type.
+    type Owned;
+
+    /// Converts the packet type with references to its data to one that owns its field data.
+    fn to_owned(&self) -> Self::Owned;
+}

src/protocol/accounting.rs

@@ -14,6 +14,9 @@ use crate::FieldText;
 #[cfg(test)]
 mod tests;
 
+#[cfg(feature = "std")]
+pub(crate) mod owned;
+
 bitflags! {
     /// Raw bitflags for accounting request packet.
     struct RawFlags: u8 {
@@ -204,7 +207,7 @@ pub struct Reply<'packet> {
 
     /// Gets the administrative/log data received from the server.
     #[getset(get_copy = "pub")]
-    data: &'packet [u8],
+    data: FieldText<'packet>,
 }
 
 /// Field lengths of a reply packet as well as the total length.
@@ -284,7 +287,10 @@ impl<'raw> TryFrom<&'raw [u8]> for Reply<'raw> {
             let server_message =
                 FieldText::try_from(&buffer[Self::SERVER_MESSAGE_OFFSET..data_offset])
                     .map_err(|_| DeserializeError::BadText)?;
-            let data = &buffer[data_offset..data_offset + extracted_lengths.data_length as usize];
+            let data = FieldText::try_from(
+                &buffer[data_offset..data_offset + extracted_lengths.data_length as usize],
+            )
+            .map_err(|_| DeserializeError::BadText)?;
 
             Ok(Self {
                 status,

src/protocol/accounting/owned.rs

@@ -0,0 +1,32 @@
+use std::borrow::ToOwned;
+use std::string::String;
+
+use super::{Reply, Status};
+use crate::protocol::ToOwnedBody;
+
+/// An owned version of a [`Reply`](super::Reply).
+// TODO: stop ignoring dead_code lint when fields are actually used in client
+#[allow(dead_code)]
+pub(crate) struct ReplyOwned {
+    /// The status returned by the server.
+    pub(crate) status: Status,
+
+    // TODO: string or separate FieldTextOwned (?) type?
+    /// The message to display to the user.
+    pub(crate) server_message: String,
+
+    /// The console/administrative message from the server.
+    pub(crate) data: String,
+}
+
+impl ToOwnedBody for Reply<'_> {
+    type Owned = ReplyOwned;
+
+    fn to_owned(&self) -> Self::Owned {
+        ReplyOwned {
+            status: self.status,
+            server_message: self.server_message.as_ref().to_owned(),
+            data: self.data.as_ref().to_owned(),
+        }
+    }
+}

src/protocol/accounting/tests.rs

@@ -152,25 +152,25 @@ fn serialize_full_request_packet() {
 
 #[test]
 fn deserialize_reply_all_fields() {
-    let mut body_raw = array_vec!([u8; 60]);
+    let mut body_raw = array_vec!([u8; 70]);
 
     body_raw.extend_from_slice(&[
         0, 47, // server message length
-        0, 2,    // data length,
+        0, 9,    // data length,
         0x02, // status: error
     ]);
 
     let server_message = [b'A'; 47];
     body_raw.extend_from_slice(&server_message);
 
     // data
-    body_raw.extend_from_slice(&[0xa4, 0x42]);
+    body_raw.extend_from_slice(b"some data");
 
     assert_eq!(
         Ok(Reply {
             status: Status::Error,
             server_message: FieldText::try_from(server_message.as_slice()).unwrap(),
-            data: &[0xa4, 0x42]
+            data: FieldText::assert("some data")
         }),
         body_raw.as_slice().try_into()
     );
@@ -212,7 +212,7 @@ fn deserialize_full_reply_packet() {
     let expected_body = Reply {
         status: Status::Error,
         server_message: FieldText::assert("hello"),
-        data: b"fifteen letters",
+        data: FieldText::assert("fifteen letters"),
     };
 
     let expected_packet = Packet::new(expected_header, expected_body);

src/protocol/arguments.rs

@@ -9,6 +9,12 @@ use crate::FieldText;
 #[cfg(test)]
 mod tests;
 
+#[cfg(feature = "std")]
+mod owned;
+
+#[cfg(feature = "std")]
+pub use owned::ArgumentOwned;
+
 /// An argument in the TACACS+ protocol, which exists for extensibility.
 #[derive(Clone, Copy, Default, PartialEq, Eq, Debug, CopyGetters)]
 pub struct Argument<'data> {

src/protocol/arguments/owned.rs

@@ -0,0 +1,28 @@
+use std::borrow::ToOwned;
+use std::string::String;
+
+use super::Argument;
+
+/// An argument that owns its name and value.
+#[derive(Debug, PartialEq, Eq)]
+pub struct ArgumentOwned {
+    /// The name of the argument.
+    pub name: String,
+
+    /// The value of the argument.
+    pub value: String,
+
+    /// Whether this argument is required.
+    pub required: bool,
+}
+
+impl Argument<'_> {
+    /// Converts this `Argument` to one which owns its fields.
+    pub fn to_owned(&self) -> ArgumentOwned {
+        ArgumentOwned {
+            name: self.name.as_ref().to_owned(),
+            value: self.value.as_ref().to_owned(),
+            required: self.required,
+        }
+    }
+}

src/protocol/arguments/tests.rs

@@ -157,3 +157,22 @@ fn deserialize_both_delims_star_first() {
         })
     );
 }
+
+#[cfg(feature = "std")]
+#[test]
+fn argument_to_owned_impl() {
+    use std::string::String;
+
+    let argument_unowned =
+        Argument::new(FieldText::assert("name"), FieldText::assert("value"), true)
+            .expect("argument should have been valid");
+
+    assert_eq!(
+        argument_unowned.to_owned(),
+        ArgumentOwned {
+            name: String::from("name"),
+            value: String::from("value"),
+            required: true
+        }
+    );
+}

src/protocol/authentication.rs

@@ -16,6 +16,9 @@ use crate::FieldText;
 #[cfg(test)]
 mod tests;
 
+#[cfg(feature = "std")]
+pub(crate) mod owned;
+
 /// The authentication action, as indicated upon initiation of an authentication session.
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -256,7 +259,7 @@ impl Serialize for Start<'_> {
 
 /// Flags received in an authentication reply packet.
 #[repr(transparent)]
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub struct ReplyFlags(u8);
 
 impl ReplyFlags {

src/protocol/authentication/owned.rs

@@ -0,0 +1,38 @@
+use std::borrow::ToOwned;
+use std::string::String;
+use std::vec::Vec;
+
+use crate::protocol::ToOwnedBody;
+
+use super::Reply;
+use super::{ReplyFlags, Status};
+
+/// An authentication reply packet with owned fields.
+// TODO: stop ignoring dead_code lint when fields are actually used
+#[allow(dead_code)]
+pub(crate) struct ReplyOwned {
+    /// The status, as returned by the server.
+    pub(crate) status: Status,
+
+    /// The flags set in the server response.
+    pub(crate) flags: ReplyFlags,
+
+    /// The message to be displayed to the user.
+    pub(crate) server_message: String,
+
+    /// The domain-specific data included in the reply.
+    pub(crate) data: Vec<u8>,
+}
+
+impl ToOwnedBody for Reply<'_> {
+    type Owned = ReplyOwned;
+
+    fn to_owned(&self) -> Self::Owned {
+        ReplyOwned {
+            status: self.status,
+            flags: self.flags,
+            server_message: self.server_message.as_ref().to_owned(),
+            data: self.data.to_owned(),
+        }
+    }
+}

src/protocol/authorization.rs

@@ -13,6 +13,9 @@ use crate::FieldText;
 #[cfg(test)]
 mod tests;
 
+#[cfg(feature = "std")]
+pub(crate) mod owned;
+
 /// An authorization request packet body, including arguments.
 pub struct Request<'packet> {
     /// Method used to authenticate to TACACS+ client.
@@ -159,9 +162,9 @@ pub struct Reply<'packet> {
     #[getset(get_copy = "pub")]
     server_message: FieldText<'packet>,
 
-    /// Gets the administrative/log data returned from the server.
+    /// Gets the administrative log message returned from the server.
     #[getset(get_copy = "pub")]
-    data: &'packet [u8],
+    data: FieldText<'packet>,
 
     // this field not publicly exposed on purpose
     // (used for iterating over arguments)
@@ -323,7 +326,8 @@ impl<'raw> TryFrom<&'raw [u8]> for Reply<'raw> {
 
             let server_message = FieldText::try_from(&buffer[body_start..data_start])
                 .map_err(|_| DeserializeError::BadText)?;
-            let data = &buffer[data_start..arguments_start];
+            let data = FieldText::try_from(&buffer[data_start..arguments_start])
+                .map_err(|_| DeserializeError::BadText)?;
 
             // arguments occupy the rest of the buffer
             let argument_lengths = &buffer[Self::ARGUMENT_LENGTHS_START..body_start];