Struct sequoia_openpgp::armor::Reader

source ·

pub struct Reader<'a> { /* private fields */ }

Expand description

A filter that strips ASCII Armor from a stream of data.

Implementations§

source §

impl<'a> Reader<'a>

source

pub fn new<R, M>(inner: R, mode: M) -> Self
where R: 'a + Read + Send + Sync, M: Into<Option<ReaderMode>>,

👎Deprecated: Use Reader::from_reader. new will be removed in version 2.0

Constructs a new filter for the given type of data.

This function is deprecated and will be removed in version 2.0. Please use Reader::from_reader.

source

pub fn from_buffered_reader<R, M>(reader: R, mode: M) -> Result<Self>
where R: BufferedReader<Cookie> + 'a, M: Into<Option<ReaderMode>>,

Constructs a new Reader from the given BufferedReader.

source

pub fn from_reader<R, M>(reader: R, mode: M) -> Self
where R: 'a + Read + Send + Sync, M: Into<Option<ReaderMode>>,

Constructs a new Reader from the given io::Reader.

ASCII Armor, designed to protect OpenPGP data in transit, has been a source of problems if the armor structure is damaged. For example, copying data manually from one program to another might introduce or drop newlines.

By default, the reader operates in tolerant mode. It will ignore common formatting errors but the header and footer lines must be intact.

To select stricter mode, specify the kind argument for tolerant mode. In this mode only ASCII Armor blocks with the appropriate header are recognized.

There is also very tolerant mode that is appropriate when reading text that the user cut and pasted into a text area. This mode of operation is CPU intense, particularly on large text files.

§Examples

use std::io::{self, Read};
use sequoia_openpgp as openpgp;
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!");

Or, in strict mode:

use std::io::{self, Result, Read};
use sequoia_openpgp as openpgp;
use openpgp::armor::{Reader, ReaderMode, Kind};

let data =
    "-----BEGIN PGP ARMORED FILE-----

     SGVsbG8gd29ybGQh
     =s4Gu
     -----END PGP ARMORED FILE-----";

let mut cursor = io::Cursor::new(&data);
let mut reader = Reader::from_reader(&mut cursor, ReaderMode::Tolerant(Some(Kind::File)));

let mut content = String::new();
reader.read_to_string(&mut content)?;
assert_eq!(content, "Hello world!");
assert_eq!(reader.kind(), Some(Kind::File));

source

pub fn from_file<P, M>(path: P, mode: M) -> Result<Self>
where P: AsRef<Path>, M: Into<Option<ReaderMode>>,

Creates a Reader from a file.

source

pub fn from_bytes<M>(bytes: &'a [u8], mode: M) -> Self
where M: Into<Option<ReaderMode>>,

Creates a Reader from a buffer.

source

pub fn kind(&self) -> Option<Kind>

Returns the kind of data this reader is for.

Useful if the kind of data is not known in advance. If the header has not been encountered yet (try reading some data first!), this function returns None.

source

pub fn headers(&mut self) -> Result<&[(String, String)]>

Returns the armored headers.

The tuples contain a key and a value.

Note: if a key occurs multiple times, then there are multiple entries in the vector with the same key; values with the same key are not combined.

§Examples

use std::io::{self, Read};
use sequoia_openpgp as openpgp;
use openpgp::armor::{Reader, ReaderMode, Kind};

let data =
    "-----BEGIN PGP ARMORED FILE-----
     First: value
     Header: value

     SGVsbG8gd29ybGQh
     =s4Gu
     -----END PGP ARMORED FILE-----";

let mut cursor = io::Cursor::new(&data);
let mut reader = Reader::from_reader(&mut cursor, ReaderMode::Tolerant(Some(Kind::File)));

let mut content = String::new();
reader.read_to_string(&mut content)?;
assert_eq!(reader.headers()?,
   &[("First".into(), "value".into()),
     ("Header".into(), "value".into())]);