summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--internals/src/decoder/mod.rs1679
1 files changed, 1679 insertions, 0 deletions
diff --git a/internals/src/decoder/mod.rs b/internals/src/decoder/mod.rs
new file mode 100644
index 0000000..d2474f4
--- /dev/null
+++ b/internals/src/decoder/mod.rs
@@ -0,0 +1,1679 @@
+//! This module provides the Decoder.
+
+use std::borrow::Cow;
+use std::str;
+
+use failure::Fail;
+use soft_ascii_string::{SoftAsciiStr, SoftAsciiChar};
+
+use grammar::is_atext;
+use ::utils::{
+ is_utf8_continuation_byte,
+ vec_insert_bytes
+};
+use ::MailType;
+use ::error::{
+ DecodingError, DecodingErrorKind,
+ UNKNOWN, UTF_8, US_ASCII
+};
+
+#[cfg_attr(test, macro_use)]
+mod decodable;
+
+pub use self::decodable::*;
+
+/// as specified in RFC 5322 not including CRLF
+pub const LINE_LEN_SOFT_LIMIT: usize = 78;
+/// as specified in RFC 5322 (mail) + RFC 5321 (smtp) not including CRLF
+pub const LINE_LEN_HARD_LIMIT: usize = 998;
+
+pub const NEWLINE: &str = "\r\n";
+pub const NEWLINE_WITH_SPACE: &str = "\r\n ";
+
+/// DecodingBuffer for a Mail providing a buffer for decodable traits.
+pub struct DecodingBuffer {
+ mail_type: MailType,
+ buffer: Vec<u8>,
+}
+
+impl DecodingBuffer {
+
+ /// Create a new buffer only allowing input compatible with a the specified mail type.
+ pub fn new(mail_type: MailType) -> Self {
+ DecodingBuffer { mail_type, buffer: Vec::new() }
+ }
+
+ /// Returns the mail type for which the buffer was created.
+ pub fn mail_type( &self ) -> MailType {
+ self.mail_type
+ }
+
+ /// returns a new DecodingWriter which contains
+ /// a mutable reference to the current string buffer
+ ///
+ pub fn writer(&mut self) -> DecodingWriter {
+ DecodingWriter::new(self.mail_type, &mut self.buffer)
+ }
+
+ /// calls the provided function with a DecodingWriter cleaning up afterwards
+ ///
+ /// After calling `func` with the DecodingWriter following cleanup is performed:
+ /// - if `func` returned an error `handle.undo_header()` is called, this won't
+ /// undo anything before a `finish_header()` call but will discard partial
+ /// writes
+ /// - if `func` succeeded `handle.finish_header()` is called
+ pub fn write_header_line<FN>(&mut self, func: FN) -> Result<(), DecodingError>
+ where FN: FnOnce(&mut DecodingWriter) -> Result<(), DecodingError>
+ {
+ let mut handle = self.writer();
+ match func(&mut handle) {
+ Ok(()) => {
+ handle.finish_header();
+ Ok(())
+ },
+ Err(e) => {
+ handle.undo_header();
+ Err(e)
+ }
+ }
+
+ }
+
+ pub fn write_blank_line(&mut self) {
+ //TODO/BENCH push_str vs. extends(&[u8])
+ self.buffer.extend(NEWLINE.as_bytes());
+ }
+
+ /// writes a body to the internal buffer, without verifying it's correctness
+ pub fn write_body_unchecked(&mut self, body: &impl AsRef<[u8]>) {
+ let slice = body.as_ref();
+ self.buffer.extend(slice);
+ if !slice.ends_with(NEWLINE.as_bytes()) {
+ self.buffer.extend(NEWLINE.as_bytes());
+ }
+ }
+
+ /// # Error
+ ///
+ /// This can fail if a body does not contain valid utf8.
+ pub fn as_str(&self) -> Result<&str, DecodingError> {
+ str::from_utf8(self.buffer.as_slice())
+ .map_err(|err| {
+ DecodingError::from((
+ err.context(DecodingErrorKind::InvalidTextDecoding {
+ expected_encoding: UTF_8,
+ got_encoding: UNKNOWN
+ }),
+ self.mail_type()
+ ))
+ })
+ }
+
+ /// Converts the internal buffer into an utf-8 string if possible.
+ pub fn to_string(&self) -> Result<String, DecodingError> {
+ Ok(self.as_str()?.to_owned())
+ }
+
+ /// Lossy conversion of the internal buffer to an string.
+ pub fn to_string_lossy(&self) -> Cow<str> {
+ String::from_utf8_lossy(self.buffer.as_slice())
+ }
+
+ /// Return a slice view to the underlying buffer.
+ pub fn as_slice(&self) -> &[u8] {
+ &self.buffer
+ }
+
+}
+
+
+impl Into<Vec<u8>> for DecodingBuffer {
+ fn into(self) -> Vec<u8> {
+ self.buffer
+ }
+}
+
+impl Into<(MailType, Vec<u8>)> for DecodingBuffer {
+ fn into(self) -> (MailType, Vec<u8>) {
+ (self.mail_type, self.buffer)
+ }
+}
+
+/// A handle providing method to write to the underlying buffer
+/// keeping track of newlines the current line length and places
+/// where the line can be broken so that the soft line length
+/// limit (78) and the hard length limit (998) can be kept.
+///
+/// It's basically a string buffer which know how to brake
+/// lines at the right place.
+///
+/// Note any act of writing a header through `DecodingWriter`
+/// has to be concluded by either calling `finish_header` or `undo_header`.
+/// If not this handle will panic in _test_ builds when being dropped
+/// (and the thread is not already panicing) as writes through the handle are directly
+/// writes to the underlying buffer which now contains malformed/incomplete
+/// data. (Note that this Handle does not own any Drop types so if
+/// needed `forget`-ing it won't leak any memory)
+///
+///
+pub struct DecodingReader<'a> {
+ buffer: &'a mut Vec<u8>,
+ #[cfg(feature="traceing")]
+ trace: &'a mut Vec<TraceToken>,
+ mail_type: MailType,
+ line_start_idx: usize,
+ last_fws_idx: usize,
+ skipped_cr: bool,
+ /// if there had ben non WS chars since the last FWS
+ /// or last line start, if there had been a line
+ /// start since the last fws.
+ content_since_fws: bool,
+ /// represents if there had ben non WS chars before the last FWS
+ /// on the current line (false if there was no FWS yet on the current
+ /// line).
+ content_before_fws: bool,
+ /// represents if if a FWS was just marked (opt-FWS) or was written out
+ last_fws_has_char: bool,
+ header_start_idx: usize,
+ #[cfg(feature="traceing")]
+ trace_start_idx: usize
+}
+
+impl<'inner> DecodingReader<'inner> {
+
+ fn new(mail_type: MailType, buffer: &'inner mut Vec<u8>) -> Self {
+ let start_idx = buffer.len();
+ DecodingWriter {
+ buffer,
+ mail_type,
+ line_start_idx: start_idx,
+ last_fws_idx: start_idx,
+ skipped_cr: false,
+ content_since_fws: false,
+ content_before_fws: false,
+ header_start_idx: start_idx,
+ last_fws_has_char: false,
+ }
+ }
+
+ fn reinit(&mut self) {
+ let start_idx = self.buffer.len();
+ self.line_start_idx = start_idx;
+ self.last_fws_idx = start_idx;
+ self.skipped_cr = false;
+ self.content_since_fws = false;
+ self.content_before_fws = false;
+ self.header_start_idx = start_idx;
+ }
+
+ /// Returns true if this type thinks we are in the process of writing a header.
+ pub fn has_unfinished_parts(&self) -> bool {
+ self.buffer.len() != self.header_start_idx
+ }
+
+ /// Returns the associated mail type.
+ pub fn mail_type(&self) -> MailType {
+ self.mail_type
+ }
+
+ /// Returns true if the current line has content, i.e. any non WS char.
+ pub fn line_has_content(&self) -> bool {
+ self.content_before_fws | self.content_since_fws
+ }
+
+ /// Returns the length of the current line in bytes.
+ pub fn current_line_byte_length(&self) -> usize {
+ self.buffer.len() - self.line_start_idx
+ }
+
+ /// marks the current position a a place where a soft
+ /// line break (i.e. "\r\n ") can be inserted
+ ///
+ /// # Trace (test build only)
+ /// does push a `MarkFWS` Token
+ pub fn mark_fws_pos(&mut self) {
+ self.content_before_fws |= self.content_since_fws;
+ self.content_since_fws = false;
+ self.last_fws_idx = self.buffer.len();
+ self.last_fws_has_char = false;
+ }
+
+ /// writes a ascii char to the underlying buffer
+ ///
+ /// # Error
+ /// - fails if the hard line length limit is breached and the
+ /// line can not be broken with soft line breaks
+ /// - buffer would contain a orphan '\r' or '\n' after the write
+ ///
+ /// # Trace (test build only)
+ /// does push `NowChar` and then can push `Text`,`CRLF`
+ pub fn write_char(&mut self, ch: SoftAsciiChar) -> Result<(), DecodingError> {
+ let mut buffer = [0xff_u8; 4];
+ let ch: char = ch.into();
+ let slice = ch.encode_utf8(&mut buffer);
+ self.internal_write_char(slice)
+ }
+
+ /// writes a ascii str to the underlying buffer
+ ///
+ /// # Error
+ /// - fails if the hard line length limit is breached and the
+ /// line can not be broken with soft line breaks
+ /// - buffer would contain a orphan '\r' or '\n' after the write
+ ///
+ /// Note that in case of an error part of the content might already
+ /// have been written to the buffer, therefore it is recommended
+ /// to call `undo_header` after an error (especially if the
+ /// handle is doped after this!)
+ ///
+ /// # Trace (test build only)
+ /// does push `NowStr` and then can push `Text`,`CRLF`
+ ///
+ pub fn write_str(&mut self, s: &SoftAsciiStr) -> Result<(), DecodingError> {
+ self.internal_write_str(s.as_str())
+ }
+
+
+ /// writes a utf8 str into a buffer for an internationalized mail
+ ///
+ /// # Error (ConditionalWriteResult)
+ /// - fails with `ConditionFailure` if the underlying MailType
+ /// is not Internationalized
+ /// - fails with `GeneralFailure` if the hard line length limit is reached
+ /// - or if the buffer would contain a orphan '\r' or '\n' after the write
+ ///
+ /// Note that in case of an error part of the content might already
+ /// have been written to the buffer, therefore it is recommended
+ /// to call `undo_header` after an error (especially if the
+ /// handle is droped after this!)
+ ///
+ /// # Trace (test build only)
+ /// does push `NowUtf8` and then can push `Text`,`CRLF`
+ pub fn write_if_utf8<'short>(&'short mut self, s: &str)
+ -> ConditionalWriteResult<'short, 'inner>
+ {
+ if self.mail_type().is_internationalized() {
+ self.internal_write_str(s).into()
+ } else {
+ ConditionalWriteResult::ConditionFailure(self)
+ }
+ }
+
+ pub fn write_utf8(&mut self, s: &str) -> Result<(), DecodingError> {
+ if self.mail_type().is_internationalized() {
+ self.internal_write_str(s)
+ } else {
+ let mut err = DecodingError::from((
+ DecodingErrorKind::InvalidTextDecoding {
+ expected_encoding: US_ASCII,
+ got_encoding: UTF_8
+ },
+ self.mail_type()
+ ));
+ let raw_line = &self.buffer[self.line_start_idx..];
+ let mut line = String::from_utf8_lossy(raw_line).into_owned();
+ line.push_str(s);
+ err.set_str_context(line);
+ Err(err)
+ }
+ }
+
+ /// Writes a str assumed to be atext if it is atext given the mail type
+ ///
+ /// This method is mainly an optimization as the "is atext" and is
+ /// "is ascii if MailType is Ascii" aspects are checked at the same
+ /// time resulting in a str which you know is ascii _if_ the mail
+ /// type is Ascii and which might be non-us-ascii if the mail type
+ /// is Internationalized.
+ ///
+ /// # Error (ConditionalWriteResult)
+ /// - fails with `ConditionFailure` if the text is not valid atext,
+ /// this indirectly also includes the utf8/Internationalization check
+ /// as the `atext` grammar differs between normal and internationalized
+ /// mail.
+ /// - fails with `GeneralFailure` if the hard line length limit is reached and
+ /// the line can't be broken with soft line breaks
+ /// - or if buffer would contain a orphan '\r' or '\n' after the write
+ /// (excluding a tailing `'\r'` as it is still valid if followed by an
+ /// `'\n'`)
+ ///
+ /// Note that in case of an error part of the content might already
+ /// have been written to the buffer, therefore it is recommended
+ /// to call `undo_header` after an error (especially if the
+ /// handle is doped after this!)
+ ///
+ /// # Trace (test build only)
+ /// does push `NowAText` and then can push `Text`
+ ///
+ pub fn write_if_atext<'short>(&'short mut self, s: &str)
+ -> ConditionalWriteResult<'short, 'inner>
+ {
+ if s.chars().all( |ch| is_atext( ch, self.mail_type() ) ) {
+ #[cfg(feature="traceing")]
+ { self.trace.push(TraceToken::NowAText) }
+ // the ascii or not aspect is already converted by `is_atext`
+ self.internal_write_str(s).into()
+ } else {
+ ConditionalWriteResult::ConditionFailure(self)
+ }
+ }
+
+ /// passes the input `s` to the condition evaluation function `cond` and
+ /// then writes it _without additional checks_ to the buffer if `cond` returned
+ /// true
+ ///
+ pub fn write_if<'short, FN>(&'short mut self, s: &str, cond: FN)
+ -> ConditionalWriteResult<'short, 'inner>
+ where FN: FnOnce(&str) -> bool
+ {
+ if cond(s) {
+ #[cfg(feature="traceing")]
+ { self.trace.push(TraceToken::NowCondText) }
+ // the ascii or not aspect is already converted by `is_atext`
+ self.internal_write_str(s).into()
+ } else {
+ ConditionalWriteResult::ConditionFailure(self)
+ }
+ }
+
+ /// writes a string to the encoder without checking if it is compatible
+ /// with the mail type, if not used correctly this can write Utf8 to
+ /// an Ascii Mail, which is incorrect but has to be safe wrt. rust's safety.
+ ///
+ /// Use it as a replacement for cases similar to following:
+ ///
+ /// ```ignore
+ /// check_if_text_if_valid(text)?;
+ /// if mail_type.is_internationalized() {
+ /// handle.write_utf8(text)?;
+ /// } else {
+ /// handle.write_str(SoftAsciiStr::from_unchecked(text))?;
+ /// }
+ /// ```
+ ///
+ /// ==> instead ==>
+ ///
+ /// ```ignore
+ /// check_if_text_if_valid(text)?;
+ /// handle.write_str_unchecked(text)?;
+ /// ```
+ ///
+ /// through is gives a different tracing its roughly equivalent.
+ ///
+ pub fn write_str_unchecked( &mut self, s: &str) -> Result<(), DecodingError> {
+ #[cfg(feature="traceing")]
+ { self.trace.push(TraceToken::NowUnchecked) }
+ self.internal_write_str(s)
+ }
+
+ /// like finish_header, but won't start a new line
+ ///
+ /// This is meant to be used when _miss-using_ the
+ /// writer to write a "think", which is not a full
+ /// header. E.g. for testing if a header component
+ /// is written correctly. So you _normally_ should
+ /// not use it.
+ pub fn commit_partial_header(&mut self) {
+ #[cfg(feature="traceing")]
+ { if let Some(&TraceToken::End) = self.trace.last() {}
+ else { self.trace.push(TraceToken::End) } }
+ self.reinit();
+ }
+
+ /// finishes the writing of a header
+ ///
+ /// It makes sure the header ends in "\r\n".
+ /// If the header ends in a orphan '\r' this
+ /// method will just "use" it for the "\r\n".
+ ///
+ /// If the header ends in a CRLF/start of buffer
+ /// followed by only WS (' ' or '\t' ) the valid
+ /// header ending is reached by truncating away
+ /// the WS padding. This is needed as "blank" lines
+ /// are not allowed.
+ ///
+ /// # Trace (test build only)
+ /// - can push 0-1 of `[CRLF, TruncateToCRLF]`
+ /// - then does push `End`
+ /// - calling `finish_current()` multiple times in a row
+ /// will not generate multiple `End` tokens, just one
+ pub fn finish_header(&mut self) {
+ self.start_new_line();
+ #[cfg(feature="traceing")]
+ { if let Some(&TraceToken::End) = self.trace.last() {}
+ else { self.trace.push(TraceToken::End) } }
+ self.reinit();
+ }
+
+ /// undoes all writes to the internal buffer
+ /// since the last `finish_header` or `undo_header` or
+ /// creation of this handle
+ ///
+ /// # Trace (test build only)
+ /// also removes tokens pushed since the last
+ /// `finish_header` or `undo_header` or creation of
+ /// this handle
+ ///
+ pub fn undo_header(&mut self) {
+ self.buffer.truncate(self.header_start_idx);
+ #[cfg(feature="traceing")]
+ { self.trace.truncate(self.trace_start_idx); }
+ self.reinit();
+ }
+
+
+
+ //---------------------------------------------------------------------------------------------/
+ //-/////////////////////////// methods only using the public iface /////////////////////////-/
+
+ /// calls mark_fws_pos and then writes a space
+ ///
+ /// This method exists for convenience.
+ ///
+ /// Note that it can not fail a you just pushed
+ /// a place to brake the line before writing a space.
+ ///
+ /// Note that currently soft line breaks will not
+ /// collapse whitespace. As such if you use `write_fws`
+ /// and then the line is broken at that position it will
+ /// start with two spaces (one from `\r\n ` and one which
+ /// had been there before).
+ pub fn write_fws(&mut self) {
+ self.mark_fws_pos();
+ self.last_fws_has_char = true;
+ // OK: Can not error as we just marked a fws pos.
+ let _ = self.write_char(SoftAsciiChar::from_unchecked(' '));
+ }
+
+
+
+ //---------------------------------------------------------------------------------------------/
+ //-/////////////////////////// private methods ////////////////////////-/
+
+ /// this might partial write some data and then fail.
+ /// while we could implement a undo option it makes
+ /// little sense for the use case the generally available
+ /// `undo_header` is enough.
+ fn internal_write_str(&mut self, s: &str) -> Result<(), DecodingError> {
+ if s.is_empty() {
+ return Ok(());
+ }
+ //TODO I think I wrote a iterator for this somewhere
+ let mut start = 0;
+ // the first byte is never a continuation byte so we start
+ // scanning at the second byte
+ for (idx_m1, bch) in s.as_bytes()[1..].iter().enumerate() {
+ if !is_utf8_continuation_byte(*bch) {
+ // the idx is 1 smaller then it should so add 1
+ let end = idx_m1 + 1;
+ self.internal_write_char(&s[start..end])?;
+ start = end;
+ }
+ }
+
+ //write last letter
+ self.internal_write_char(&s[start..])?;
+ Ok(())
+ }
+
+ /// if the line has at last one non-WS char a new line
+ /// will be started by adding `\r\n` if the current line
+ /// only consists of WS then a new line will be started by
+ /// removing the blank line (not that WS are only ' ' and '\r')
+ fn start_new_line(&mut self) {
+ if self.line_has_content() {
+ #[cfg(feature="traceing")]
+ { self.trace.push(TraceToken::CRLF) }
+
+ self.buffer.push(b'\r');
+ self.buffer.push(b'\n');
+ } else {
+ #[cfg(feature="traceing")]
+ {
+ if self.buffer.len() > self.line_start_idx {
+ self.trace.push(TraceToken::TruncateToCRLF);
+ }
+ }
+ // e.g. if we "broke" the line on a tailing space => "\r\n "
+ // this would not be valid so we cut awy the trailing white space
+ // be if we have "ab " we do not want to cut away the trailing
+ // whitespace but just add "\r\n"
+ self.buffer.truncate(self.line_start_idx);
+ }
+ self.line_start_idx = self.buffer.len();
+ self.content_since_fws = false;
+ self.content_before_fws = false;
+ self.last_fws_idx = self.line_start_idx;
+
+ }
+
+ fn break_line_on_fws(&mut self) -> bool {
+ if self.content_before_fws && self.last_fws_idx > self.line_start_idx {
+ let newline =
+ if self.last_fws_has_char {
+ debug_assert!([b' ', b'\t'].contains(&self.buffer[self.last_fws_idx]));
+ NEWLINE
+ } else {
+ NEWLINE_WITH_SPACE
+ };
+
+ vec_insert_bytes(&mut self.buffer, self.last_fws_idx, newline.as_bytes());
+ self.line_start_idx = self.last_fws_idx + 2;
+ self.content_before_fws = false;
+ true
+ } else {
+ false
+ }
+ }
+
+ /// # Constraints
+ ///
+ /// `unchecked_utf8_char` is expected to be exactly
+ /// one char, which means it's 1-4 bytes in length.
+ ///
+ /// The reason why a slice is expected instead of a
+ /// char is, that this function will at some point push
+ /// to a byte buffer requiring a `&[u8]` and many function
+ /// calling this function can directly produce a &[u8]/&str.
+ ///
+ /// # Panic
+ ///
+ /// Panics if `unchecked_utf8_char` is empty.
+ /// If debug assertions are enabled it also panics, if
+ /// unchecked_utf8_char is more than just one char.
+ fn internal_write_char(&mut self, unchecked_utf8_char: &str) -> Result<(), DecodingError> {
+ debug_assert_eq!(unchecked_utf8_char.chars().count(), 1);
+
+ let bch = unchecked_utf8_char.as_bytes()[0];
+ if bch == b'\n' {
+ if self.skipped_cr {
+ self.start_new_line()
+ } else {
+ ec_bail!(
+ mail_type: self.mail_type(),
+ kind: Malformed
+ );
+ }
+ self.skipped_cr = false;
+ return Ok(());
+ } else {
+ if self.skipped_cr {
+ ec_bail!(
+ mail_type: self.mail_type(),
+ kind: Malformed
+ );
+ }
+ if bch == b'\r' {
+ self.skipped_cr = true;
+ return Ok(());
+ } else {
+ self.skipped_cr = false;
+ }
+ }
+
+ if self.current_line_byte_length() >= LINE_LEN_SOFT_LIMIT {
+ self.break_line_on_fws();
+
+ if self.current_line_byte_length() >= LINE_LEN_HARD_LIMIT {
+ ec_bail!(
+ mail_type: self.mail_type(),
+ kind: HardLineLengthLimitBreached
+ );
+ }
+ }
+
+ self.buffer.extend(unchecked_utf8_char.as_bytes());
+ #[cfg(feature="traceing")]
+ {
+ //FIXME[rust/nll]: just use a `if let`-`else` with NLL's
+ let need_new =
+ if let Some(&mut TraceToken::Text(ref mut string)) = self.trace.last_mut() {
+ string.push_str(unchecked_utf8_char);
+ false
+ } else {
+ true
+ };
+ if need_new {
+ let mut string = String::new();
+ string.push_str(unchecked_utf8_char);
+ self.trace.push(TraceToken::Text(string))
+ }
+
+ }
+
+ // we can't allow "blank" lines
+ if bch != b' ' && bch != b'\t' {
+ // if there is no fws this is equiv to line_has_content
+ // else line_has_content = self.content_before_fws|self.content_since_fws
+ self.content_since_fws = true;
+ }
+ Ok(())
+ }
+}
+
+pub enum ConditionalWriteResult<'a, 'b: 'a> {
+ Ok,
+ ConditionFailure(&'a mut DecodingWriter<'b>),
+ GeneralFailure(DecodingError)
+}
+
+impl<'a, 'b: 'a> From<Result<(), DecodingError>> for ConditionalWriteResult<'a, 'b> {
+ fn from(v: Result<(), DecodingError>) -> Self {
+ match v {
+ Ok(()) => ConditionalWriteResult::Ok,
+ Err(e) => ConditionalWriteResult::GeneralFailure(e)
+ }
+ }
+}
+
+impl<'a, 'b: 'a> ConditionalWriteResult<'a, 'b> {
+
+ #[inline]
+ pub fn handle_condition_failure<FN>(self, func: FN) -> Result<(), DecodingError>
+ where FN: FnOnce(&mut DecodingWriter) -> Result<(), DecodingError>
+ {
+ use self::ConditionalWriteResult as CWR;
+
+ match self {
+ CWR::Ok => Ok(()),
+ CWR::ConditionFailure(handle) => {
+ func(handle)
+ },
+ CWR::GeneralFailure(err) => Err(err)
+ }
+ }
+}
+
+
+
+
+
+#[cfg(test)]
+mod test {
+
+ use soft_ascii_string::{ SoftAsciiChar, SoftAsciiStr};
+ use ::MailType;
+ use ::error::DecodingErrorKind;
+
+ use super::TraceToken::*;
+ use super::{DecodingBuffer as _Decoder};
+
+ mod test_test_utilities {
+ use encoder::TraceToken::*;
+ use super::super::simplify_trace_tokens;
+
+ #[test]
+ fn does_simplify_tokens_strip_nows() {
+ let inp = vec![
+ NowChar,
+ Text("h".into()),
+ CRLF,
+ NowStr,
+ Text("y yo".into()),
+ CRLF,
+ NowUtf8,
+ Text(", what's".into()),
+ CRLF,
+ NowUnchecked,
+ Text("up!".into()),
+ CRLF,
+ NowAText,
+ Text("abc".into())
+ ];
+ let out = simplify_trace_tokens(inp);
+ assert_eq!(out, vec![
+ Text("h".into()),
+ CRLF,
+ Text("y yo".into()),
+ CRLF,
+ Text(", what's".into()),
+ CRLF,
+ Text("up!".into()),
+ CRLF,
+ Text("abc".into())
+ ])
+
+ }
+
+ #[test]
+ fn simplify_does_collapse_text() {
+ let inp = vec![
+ NowChar,
+ Text("h".into()),
+ NowStr,
+ Text("y yo".into()),
+ NowUtf8,
+ Text(", what's".into()),
+ NowUnchecked,
+ Text(" up! ".into()),
+ NowAText,
+ Text("abc".into())
+ ];
+ let out = simplify_trace_tokens(inp);
+ assert_eq!(out, vec![
+ Text("hy yo, what's up! abc".into())
+ ]);
+ }
+
+ #[test]
+ fn simplify_works_with_empty_text() {
+ let inp = vec![
+ NowStr,
+ Text("".into()),
+ CRLF,
+ ];
+ assert_eq!(simplify_trace_tokens(inp), vec![
+ Text("".into()),
+ CRLF
+ ])
+ }
+
+ #[test]
+ fn simplify_works_with_trailing_empty_text() {
+ let inp = vec![
+ Text("a".into()),
+ CRLF,
+ Text("".into()),
+ ];
+ assert_eq!(simplify_trace_tokens(inp), vec![
+ Text("a".into()),
+ CRLF,
+ Text("".into())
+ ])
+ }
+
+ }
+
+ mod DecodableInHeader {
+ #![allow(non_snake_case)]
+ use super::super::*;
+ use self::TraceToken::*;
+
+ #[test]
+ fn is_implemented_for_closures() {
+ let closure = enc_func!(|handle: &mut DecodingWriter| {
+ handle.write_utf8("hy ho")
+ });
+
+ let mut encoder = DecodingBuffer::new(MailType::Internationalized);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(closure.encode(&mut handle));
+ handle.finish_header();
+ }
+ assert_eq!(encoder.trace.as_slice(), &[
+ NowUtf8,
+ Text("hy ho".into()),
+ CRLF,
+ End
+ ])
+ }
+ }
+
+
+ mod DecodingBuffer {
+ #![allow(non_snake_case)]
+ use super::*;
+ use super::{ _Decoder as DecodingBuffer };
+
+ #[test]
+ fn new_encoder() {
+ let encoder = DecodingBuffer::new(MailType::Internationalized);
+ assert_eq!(encoder.mail_type(), MailType::Internationalized);
+ }
+
+ #[test]
+ fn write_body_unchecked() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ let body1 = "una body\r\n";
+ let body2 = "another body";
+
+ encoder.write_body_unchecked(&body1);
+ encoder.write_blank_line();
+ encoder.write_body_unchecked(&body2);
+
+ assert_eq!(
+ encoder.as_slice(),
+ concat!(
+ "una body\r\n",
+ "\r\n",
+ "another body\r\n"
+ ).as_bytes()
+ )
+ }
+ }
+
+
+ mod DecodingWriter {
+ #![allow(non_snake_case)]
+ use std::mem;
+ use std::str;
+
+ use super::*;
+ use super::{ _Decoder as DecodingBuffer };
+
+ #[test]
+ fn commit_partial_and_drop_does_not_panic() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_unchecked("12")));
+ handle.commit_partial_header();
+ }
+ assert_eq!(encoder.as_slice(), b"12");
+ }
+
+ #[test]
+ fn undo_does_undo() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(
+ handle.write_str(SoftAsciiStr::from_unchecked("Header-One: 12")));
+ handle.undo_header();
+ }
+ assert_eq!(encoder.as_slice(), b"");
+ }
+
+ #[test]
+ fn undo_does_not_undo_to_much() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_str("Header-One: 12").unwrap()));
+ handle.finish_header();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_str("ups: sa").unwrap()));
+ handle.undo_header();
+ }
+ assert_eq!(encoder.as_slice(), b"Header-One: 12\r\n");
+ }
+
+ #[test]
+ fn finish_adds_crlf_if_needed() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_str("Header-One: 12").unwrap()));
+ handle.finish_header();
+ }
+ assert_eq!(encoder.as_slice(), b"Header-One: 12\r\n");
+ }
+
+ #[test]
+ fn finish_does_not_add_crlf_if_not_needed() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_str("Header-One: 12\r\n").unwrap()));
+ handle.finish_header();
+ }
+ assert_eq!(encoder.as_slice(), b"Header-One: 12\r\n");
+ }
+
+ #[test]
+ fn finish_does_truncat_if_needed() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_str("Header-One: 12\r\n ").unwrap()));
+ handle.finish_header();
+ }
+ assert_eq!(encoder.as_slice(), b"Header-One: 12\r\n");
+ }
+
+
+ #[test]
+ fn finish_can_handle_fws() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_str("Header-One: 12 +\r\n 4").unwrap()));
+ handle.finish_header();
+ }
+ assert_eq!(encoder.as_slice(), b"Header-One: 12 +\r\n 4\r\n");
+ }
+
+ #[test]
+ fn finish_only_truncats_if_needed() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(handle.write_str(
+ SoftAsciiStr::from_str("Header-One: 12 +\r\n 4 ").unwrap()));
+ handle.finish_header();
+ }
+ assert_eq!(encoder.as_slice(), b"Header-One: 12 +\r\n 4 \r\n");
+ }
+
+
+ #[test]
+ fn orphan_lf_error() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_err!(handle.write_str(SoftAsciiStr::from_str("H: \na").unwrap()));
+ handle.undo_header()
+ }
+ }
+ #[test]
+ fn orphan_cr_error() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_err!(handle.write_str(SoftAsciiStr::from_str("H: \ra").unwrap()));
+ handle.undo_header()
+ }
+ }
+
+ #[test]
+ fn orphan_trailing_lf() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_err!(handle.write_str(SoftAsciiStr::from_str("H: a\n").unwrap()));
+ handle.undo_header();
+ }
+ }
+
+ #[test]
+ fn orphan_trailing_cr() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_str("H: a\r").unwrap()));
+ //it's fine not to error in the trailing \r case as we want to write
+ //a \r\n anyway
+ handle.finish_header();
+ }
+ assert_eq!(encoder.as_slice(), b"H: a\r\n");
+ }
+
+ #[test]
+ fn soft_line_limit_can_be_breached() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ for _ in 0u32..500 {
+ assert_ok!(handle.internal_write_char("a"));
+ }
+ handle.finish_header();
+ }
+ }
+
+ #[test]
+ fn hard_line_limit_can_not_be_breached() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ for _ in 0u32..998 {
+ assert_ok!(handle.internal_write_char("a"));
+ }
+
+ assert_err!(handle.internal_write_char("b"));
+ handle.finish_header();
+ }
+ }
+
+ #[test]
+ fn break_line_on_fws() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);
+ {
+ let mut handle = encoder.writer();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_str("A23456789:").unwrap()));
+ handle.mark_fws_pos();
+ assert_ok!(handle.write_str(SoftAsciiStr::from_str(concat!(
+ "20_3456789",
+ "30_3456789",
+ "40_3456789",
+ "50_3456789",
+ "60_3456789",
+ "70_3456789",
+ "12345678XX"
+ )).unwrap()));
+ handle.finish_header();
+ }
+ assert_eq!(
+ encoder.as_str().unwrap(),
+ concat!(
+ "A23456789:\r\n ",
+ "20_3456789",
+ "30_3456789",
+ "40_3456789",
+ "50_3456789",
+ "60_3456789",
+ "70_3456789",
+ "12345678XX\r\n"
+ )
+ );
+ }
+
+ #[test]
+ fn break_line_on_fws_does_not_insert_unessesary_space() {
+ let mut encoder = DecodingBuffer::new(MailType::Ascii);