Struct gdb_protocol::packet::CheckedPacket

pub struct CheckedPacket { /* fields omitted */ }

Methods

impl CheckedPacket

pub fn assume_checked(unchecked: UncheckedPacket) -> Self

If you know the packet isn't corrupted, this function bypasses the checksum verification.

pub fn invalidate_check(self) -> UncheckedPacket

If you intend to mutate the packet's internals, you must first convert it to an unchecked packet so it isn't marked as checked.

pub fn empty() -> Self

The empty packet is used when you get a packet which you just don't understand. Replying an empty packet means "I don't support this feature".

let mut encoded = Vec::new();
CheckedPacket::empty().encode(&mut encoded);
assert_eq!(encoded, b"$#00")

pub fn from_data(kind: Kind, data: Vec<u8>) -> Self

Creates a packet from the inputted binary data, and generates the checksum from it.

assert_eq!(
    CheckedPacket::from_data(Kind::Packet, b"Hello, World!".to_vec()).invalidate_check(),
    UncheckedPacket {
        kind: Kind::Packet,
        data: b"Hello, World!".to_vec(),
        checksum: *b"69"
    },
)

Methods from Deref<Target = UncheckedPacket>

pub fn expected_checksum(&self) -> Result<u8, Error>

Return the integer parsed from the hexadecimal expected checksum.

let packet = UncheckedPacket {
    kind: Kind::Packet,
    data: b"Hello, World!".to_vec(),
    checksum: *b"BA",
};
assert_eq!(packet.expected_checksum().unwrap(), 186);

pub fn actual_checksum(&self) -> u8

Return the actual checksum, derived from the data.

let packet = UncheckedPacket {
    kind: Kind::Packet,
    data: b"Hello, World!".to_vec(),
    checksum: *b"BA",
};
assert_eq!(packet.actual_checksum(), 105);

As per the GDB specification, this is currently a sum of all characters, modulo 256. The same result can be compared with

(input.bytes().map(|x| usize::from(x)).sum::<usize>() % 256) as u8

however, this function is more efficient and won't go out of bounds.

pub fn is_valid(&self) -> bool

Returns true if the checksums match.

assert_eq!(UncheckedPacket {
    kind: Kind::Packet,
    data: b"Rust is an amazing programming language".to_vec(),
    checksum: *b"00",
}.is_valid(), false);
assert_eq!(UncheckedPacket {
    kind: Kind::Packet,
    data: b"Rust is an amazing programming language".to_vec(),
    checksum: *b"ZZ",
}.is_valid(), false);
assert_eq!(UncheckedPacket {
    kind: Kind::Packet,
    data: b"Rust is an amazing programming language".to_vec(),
    checksum: *b"C7",
}.is_valid(), true);

pub fn encode<W>(&self, w: &mut W) -> Result<()> where
    W: Write, 

Encode the packet into a long binary string, written to a writer of choice. You can receive a Vec by taking advantage of the fact that they implement io::Write:

let mut encoded = Vec::new();
UncheckedPacket {
    kind: Kind::Packet,
    data: b"these must be escaped: # $ } *".to_vec(),
    checksum: *b"00",
}.encode(&mut encoded);
assert_eq!(
    encoded,
    b"$these must be escaped: }\x03 }\x04 }] }\x0a#00".to_vec()
);

Currently multiple series repeated characters aren't shortened, however, this may change at any time and you should not rely on the output of this function being exactly one of multiple representations.

Trait Implementations

impl Clone for CheckedPacket

fn clone(&self) -> CheckedPacket

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq<CheckedPacket> for CheckedPacket

fn eq(&self, other: &CheckedPacket) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &CheckedPacket) -> bool

This method tests for !=.

impl Eq for CheckedPacket

impl Deref for CheckedPacket

type Target = UncheckedPacket

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Debug for CheckedPacket

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.