Struct Message

pub struct Message { /* private fields */ }

A message.

An OpenPGP message is a structured sequence of OpenPGP packets. Basically, it’s an optionally encrypted, optionally signed literal data packet. The exact structure is defined in Section 10.3 of RFC 9580.

ASCII Armored Messages are wrapped in -----BEGIN PGP MESSAGE----- header and -----END PGP MESSAGE----- tail lines:

-----BEGIN PGP MESSAGE-----

xA0DAAoW5saJekzviSQByxBiAAAAAADYtdiv2KfZgtipwnUEABYKACcFglwJHYoW
IQRnpIdTo4Cms7fffcXmxol6TO+JJAkQ5saJekzviSQAAIJ6APwK6FxtHXn8txDl
tBFsIXlOSLOs4BvArlZzZSMomIyFLAEAwCLJUChMICDxWXRlHxORqU5x6hlO3DdW
sl/1DAbnRgI=
=AqoO
-----END PGP MESSAGE-----

Examples

Creating a Message encrypted with a password.

use std::io::Write;
use openpgp::serialize::stream::{Message, Encryptor, LiteralWriter};

let mut sink = vec![];
let message = Encryptor::with_passwords(
    Message::new(&mut sink), Some("ściśle tajne")).build()?;
let mut w = LiteralWriter::new(message).build()?;
w.write_all(b"Hello world.")?;
w.finalize()?;

Implementations

impl Message

pub fn body(&self) -> Option<&Literal>

Returns the body of the message.

Returns None if no literal data packet is found. This happens if a SEIP container has not been decrypted.

Examples

use std::io;
use std::io::Read;
use openpgp::Message;
use openpgp::armor::{Reader, ReaderMode};
use openpgp::parse::Parse;

let data = "yxJiAAAAAABIZWxsbyB3b3JsZCE="; // base64 over literal data packet

let mut cursor = io::Cursor::new(&data);
let mut reader = Reader::from_reader(&mut cursor, ReaderMode::VeryTolerant);

let mut buf = Vec::new();
reader.read_to_end(&mut buf)?;

let message = Message::from_bytes(&buf)?;
assert_eq!(message.body().unwrap().body(), b"Hello world!");

pub fn packets(&self) -> &PacketPile

Returns a reference to the message’s packets.

Trait Implementations

impl Debug for Message

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

Formats the value using the given formatter.

impl From<Message> for PacketPile

fn from(m: Message) -> Self

Converts to this type from the input type.

impl FromStr for Message

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Marshal for Message

fn serialize(&self, o: &mut dyn Write) -> Result<()>

Writes a serialized version of the specified Message to o.

fn export(&self, o: &mut dyn Write) -> Result<()>

Exports a serialized version of the object to o.

impl MarshalInto for Message

fn serialized_len(&self) -> usize

Computes the maximal length of the serialized representation.

fn serialize_into(&self, buf: &mut [u8]) -> Result<usize>

Serializes into the given buffer.

fn export_into(&self, buf: &mut [u8]) -> Result<usize>

Exports into the given buffer.

fn to_vec(&self) -> Result<Vec<u8>>

Serializes the packet to a vector.

fn export_to_vec(&self) -> Result<Vec<u8>>

Exports to a vector.

impl<'a> Parse<'a, Message> for Message

fn from_buffered_reader<R>(reader: R) -> Result<Message>

where R: BufferedReader<Cookie> + 'a,

Reads a Message from the specified reader.

See Message::try_from for more details.

fn from_reader<R: 'a + Read + Send + Sync>(reader: R) -> Result<T>

Reads from the given reader.

fn from_file<P: AsRef<Path>>(path: P) -> Result<T>

Reads from the given file.

fn from_bytes<D: AsRef<[u8]> + ?Sized + Send + Sync>(data: &'a D) -> Result<T>

Reads from the given slice.

impl PartialEq for Message

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Message

fn serialize(&self, o: &mut dyn Write) -> Result<()>

Writes a serialized version of the object to o.

fn export(&self, o: &mut dyn Write) -> Result<()>

Exports a serialized version of the object to o.

impl SerializeInto for Message

fn serialized_len(&self) -> usize

Computes the maximal length of the serialized representation.

fn serialize_into(&self, buf: &mut [u8]) -> Result<usize>

Serializes into the given buffer.

fn to_vec(&self) -> Result<Vec<u8>>

Serializes the packet to a vector.

fn export_into(&self, buf: &mut [u8]) -> Result<usize>

Exports into the given buffer.

fn export_to_vec(&self) -> Result<Vec<u8>>

Exports to a vector.

impl TryFrom<PacketPile> for Message

fn try_from(pile: PacketPile) -> Result<Self>

Converts the PacketPile to a Message.

Converting a PacketPile to a Message doesn’t change the packets; it asserts that the packet sequence is an optionally encrypted, optionally signed, optionally compressed literal data packet. The exact grammar is defined in Section 10.3 of RFC 9580.

Caveats: this function assumes that any still encrypted parts or still compressed parts are valid messages.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Vec<Packet>> for Message

fn try_from(packets: Vec<Packet>) -> Result<Self>

Converts the vector of Packets to a Message.

See Message::try_from for more details.

type Error = Error

The type returned in the event of a conversion error.

impl StructuralPartialEq for Message