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>

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())]);

Trait Implementations§

source§

impl BufferedReader<Cookie> for Reader<'_>

source§

fn buffer(&self) -> &[u8]

Returns a reference to the internal buffer. Read more
source§

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

Ensures that the internal buffer has at least amount bytes of data, and returns it. Read more
source§

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

Like BufferedReader::data, but returns an error if there is not at least amount bytes available. Read more
source§

fn consume(&mut self, amount: usize) -> &[u8]

Consumes some of the data. Read more
source§

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

A convenience function that combines BufferedReader::data and BufferedReader::consume. Read more
source§

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

A convenience function that effectively combines BufferedReader::data_hard and BufferedReader::consume. Read more
source§

fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<Cookie>>

Returns a mutable reference to the inner BufferedReader, if any. Read more
source§

fn get_ref(&self) -> Option<&dyn BufferedReader<Cookie>>

Returns a reference to the inner BufferedReader, if any.
source§

fn into_inner<'b>( self: Box<Self>, ) -> Option<Box<dyn BufferedReader<Cookie> + 'b>>
where Self: 'b,

Returns the underlying reader, if any. Read more
source§

fn cookie_set(&mut self, cookie: Cookie) -> Cookie

Sets the BufferedReader’s cookie and returns the old value.
source§

fn cookie_ref(&self) -> &Cookie

Returns a reference to the BufferedReader’s cookie.
source§

fn cookie_mut(&mut self) -> &mut Cookie

Returns a mutable reference to the BufferedReader’s cookie.
source§

fn data_eof(&mut self) -> Result<&[u8], Error>

Returns all of the data until EOF. Like BufferedReader::data, this does not actually consume the data that is read. Read more
source§

fn eof(&mut self) -> bool

Checks whether the end of the stream is reached.
source§

fn consummated(&mut self) -> bool

Checks whether this reader is consummated. Read more
source§

fn read_be_u16(&mut self) -> Result<u16, Error>

A convenience function for reading a 16-bit unsigned integer in big endian format.
source§

fn read_be_u32(&mut self) -> Result<u32, Error>

A convenience function for reading a 32-bit unsigned integer in big endian format.
source§

fn read_to(&mut self, terminal: u8) -> Result<&[u8], Error>

Reads until either terminal is encountered or EOF. Read more
source§

fn drop_until(&mut self, terminals: &[u8]) -> Result<usize, Error>

Discards the input until one of the bytes in terminals is encountered. Read more
source§

fn drop_through( &mut self, terminals: &[u8], match_eof: bool, ) -> Result<(Option<u8>, usize), Error>

Discards the input until one of the bytes in terminals is encountered. Read more
source§

fn steal(&mut self, amount: usize) -> Result<Vec<u8>, Error>

Like BufferedReader::data_consume_hard, but returns the data in a caller-owned buffer. Read more
source§

fn steal_eof(&mut self) -> Result<Vec<u8>, Error>

Like BufferedReader::steal, but instead of stealing a fixed number of bytes, steals all of the data until the end of file.
source§

fn drop_eof(&mut self) -> Result<bool, Error>

Like BufferedReader::steal_eof, but instead of returning the data, the data is discarded. Read more
source§

fn copy(&mut self, sink: &mut dyn Write) -> Result<u64, Error>

Copies data to the given writer returning the copied amount. Read more
source§

fn dump(&self, sink: &mut dyn Write) -> Result<(), Error>
where Self: Sized,

A helpful debugging aid to pretty print a Buffered Reader stack. Read more
source§

fn into_boxed<'a>(self) -> Box<dyn BufferedReader<C> + 'a>
where Self: Sized + 'a,

Boxes the reader.
source§

fn as_boxed<'a>(self) -> Box<dyn BufferedReader<C> + 'a>
where Self: Sized + 'a,

👎Deprecated: Use into_boxed
Boxes the reader.
source§

impl<'a> Debug for Reader<'a>

source§

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

Formats the value using the given formatter. Read more
source§

impl<'a> Display for Reader<'a>

source§

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

Formats the value using the given formatter. Read more
source§

impl Read for Reader<'_>

source§

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read. Read more
1.36.0 · source§

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers. Read more
source§

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)
Determines if this Reader has an efficient read_vectored implementation. Read more
1.0.0 · source§

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf. Read more
1.0.0 · source§

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf. Read more
1.6.0 · source§

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

Read the exact number of bytes required to fill buf. Read more
source§

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)
Pull some bytes from this source into the specified buffer. Read more
source§

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)
Read the exact number of bytes required to fill cursor. Read more
1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Creates a “by reference” adaptor for this instance of Read. Read more
1.0.0 · source§

fn bytes(self) -> Bytes<Self>
where Self: Sized,

Transforms this Read instance to an Iterator over its bytes. Read more
1.0.0 · source§

fn chain<R>(self, next: R) -> Chain<Self, R>
where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another. Read more
1.0.0 · source§

fn take(self, limit: u64) -> Take<Self>
where Self: Sized,

Creates an adapter which will read at most limit bytes from it. Read more

Auto Trait Implementations§

§

impl<'a> Freeze for Reader<'a>

§

impl<'a> !RefUnwindSafe for Reader<'a>

§

impl<'a> Send for Reader<'a>

§

impl<'a> Sync for Reader<'a>

§

impl<'a> Unpin for Reader<'a>

§

impl<'a> !UnwindSafe for Reader<'a>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> ErasedDestructor for T
where T: 'static,

source§

impl<T> MaybeSendSync for T