Added BinaryQuotedPrintableDecoder

Some mail software will attach pdf files using the quoted-printable
encoding.

On Linux/macOS, because MimeKit saves messages with the Unix line endings,
decoding these pdfs can produce corrupted output when the pdf contains
\r's of significance. These same pdfs typically decode correctly on Windows
because it just so happens that unencoded \r's aren't stripped on that
platform.

BinaryQuotedPrintableDecoder re-inserts the \r's as needed during the
decoding process to overcome this problem.

Note: The current unit test does not properly test this scenario and so
needs some work. Unfortunately, none of the pdfs that I have received that
illustrate this problem can be made public.

Author: jstedfast

MimeKit/Encodings/BinaryQuotedPrintableDecoder.cs

@@ -0,0 +1,269 @@
+//
+// BinaryQuotedPrintableDecoder.cs
+//
+// Author: Jeffrey Stedfast <[email protected]>
+//
+// Copyright (c) 2013-2022 .NET Foundation and Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+using System;
+
+using MimeKit.Utils;
+
+namespace MimeKit.Encodings {
+	/// <summary>
+	/// Incrementally decodes binary content encoded with the quoted-printable encoding.
+	/// </summary>
+	/// <remarks>
+	/// Quoted-Printable is an encoding often used in MIME to textual content outside
+	/// of the ASCII range in order to ensure that the text remains intact when sent
+	/// via 7bit transports such as SMTP.
+	/// </remarks>
+	class BinaryQuotedPrintableDecoder : IMimeDecoder
+	{
+		enum QpDecoderState : byte {
+			PassThrough,
+			EqualSign,
+			SoftBreak,
+			DecodeByte
+		}
+
+		QpDecoderState state;
+		byte saved;
+
+		/// <summary>
+		/// Initialize a new instance of the <see cref="BinaryQuotedPrintableDecoder"/> class.
+		/// </summary>
+		/// <remarks>
+		/// Creates a new quoted-printable decoder.
+		/// </remarks>
+		public BinaryQuotedPrintableDecoder ()
+		{
+		}
+
+		/// <summary>
+		/// Clone the <see cref="BinaryQuotedPrintableDecoder"/> with its current state.
+		/// </summary>
+		/// <remarks>
+		/// Creates a new <see cref="BinaryQuotedPrintableDecoder"/> with exactly the same state as the current decoder.
+		/// </remarks>
+		/// <returns>A new <see cref="BinaryQuotedPrintableDecoder"/> with identical state.</returns>
+		public IMimeDecoder Clone ()
+		{
+			var decoder = new BinaryQuotedPrintableDecoder ();
+
+			decoder.state = state;
+			decoder.saved = saved;
+
+			return decoder;
+		}
+
+		/// <summary>
+		/// Get the encoding.
+		/// </summary>
+		/// <remarks>
+		/// Gets the encoding that the decoder supports.
+		/// </remarks>
+		/// <value>The encoding.</value>
+		public ContentEncoding Encoding {
+			get { return ContentEncoding.QuotedPrintable; }
+		}
+
+		/// <summary>
+		/// Estimate the length of the output.
+		/// </summary>
+		/// <remarks>
+		/// Estimates the number of bytes needed to decode the specified number of input bytes.
+		/// </remarks>
+		/// <returns>The estimated output length.</returns>
+		/// <param name="inputLength">The input length.</param>
+		public int EstimateOutputLength (int inputLength)
+		{
+			int length = inputLength * 2 + (saved == '\r' ? 1 : 0);
+
+			switch (state) {
+			case QpDecoderState.PassThrough: return length;
+			case QpDecoderState.EqualSign: return length + 1; // add an extra byte in case the '=' character is not the start of a valid hex sequence
+			default: return length + 2; // add an extra 2 bytes in case the =X sequence is not the start of a valid hex sequence
+			}
+		}
+
+		void ValidateArguments (byte[] input, int startIndex, int length, byte[] output)
+		{
+			if (input == null)
+				throw new ArgumentNullException (nameof (input));
+
+			if (startIndex < 0 || startIndex > input.Length)
+				throw new ArgumentOutOfRangeException (nameof (startIndex));
+
+			if (length < 0 || length > (input.Length - startIndex))
+				throw new ArgumentOutOfRangeException (nameof (length));
+
+			if (output == null)
+				throw new ArgumentNullException (nameof (output));
+
+			if (output.Length < EstimateOutputLength (length))
+				throw new ArgumentException ("The output buffer is not large enough to contain the decoded input.", nameof (output));
+		}
+
+		/// <summary>
+		/// Decode the specified input into the output buffer.
+		/// </summary>
+		/// <remarks>
+		/// <para>Decodes the specified input into the output buffer.</para>
+		/// <para>The output buffer should be large enough to hold all of the
+		/// decoded input. For estimating the size needed for the output buffer,
+		/// see <see cref="EstimateOutputLength"/>.</para>
+		/// </remarks>
+		/// <returns>The number of bytes written to the output buffer.</returns>
+		/// <param name="input">A pointer to the beginning of the input buffer.</param>
+		/// <param name="length">The length of the input buffer.</param>
+		/// <param name="output">A pointer to the beginning of the output buffer.</param>
+		public unsafe int Decode (byte* input, int length, byte* output)
+		{
+			byte* inend = input + length;
+			byte* outptr = output;
+			byte* inptr = input;
+			byte c;
+
+			while (inptr < inend) {
+				switch (state) {
+				case QpDecoderState.PassThrough:
+					while (inptr < inend) {
+						c = *inptr++;
+
+						if (c == '=') {
+							state = QpDecoderState.EqualSign;
+							break;
+						} else {
+							if (c == (byte) '\n' && saved != (byte) '\r')
+								*outptr++ = (byte) '\r';
+							*outptr++ = c;
+							saved = c;
+						}
+					}
+					break;
+				case QpDecoderState.EqualSign:
+					c = *inptr++;
+
+					if (c.IsXDigit ()) {
+						state = QpDecoderState.DecodeByte;
+						saved = c;
+					} else if (c == '=') {
+						// invalid encoded sequence - pass it through undecoded
+						*outptr++ = (byte) '=';
+					} else if (c == '\r') {
+						state = QpDecoderState.SoftBreak;
+					} else if (c == '\n') {
+						state = QpDecoderState.PassThrough;
+					} else {
+						// invalid encoded sequence - pass it through undecoded
+						state = QpDecoderState.PassThrough;
+						*outptr++ = (byte) '=';
+						*outptr++ = c;
+					}
+					break;
+				case QpDecoderState.SoftBreak:
+					state = QpDecoderState.PassThrough;
+					c = *inptr++;
+
+					if (c != '\n') {
+						// invalid encoded sequence - pass it through undecoded
+						*outptr++ = (byte) '=';
+						*outptr++ = (byte) '\r';
+						*outptr++ = c;
+					}
+					break;
+				case QpDecoderState.DecodeByte:
+					c = *inptr++;
+					if (c.IsXDigit ()) {
+						saved = saved.ToXDigit ();
+						c = c.ToXDigit ();
+
+						saved = *outptr++ = (byte) ((saved << 4) | c);
+					} else {
+						// invalid encoded sequence - pass it through undecoded
+						*outptr++ = (byte) '=';
+						*outptr++ = saved;
+						*outptr++ = c;
+						saved = c;
+					}
+
+					state = QpDecoderState.PassThrough;
+					break;
+				}
+			}
+
+			return (int) (outptr - output);
+		}
+
+		/// <summary>
+		/// Decode the specified input into the output buffer.
+		/// </summary>
+		/// <remarks>
+		/// <para>Decodes the specified input into the output buffer.</para>
+		/// <para>The output buffer should be large enough to hold all of the
+		/// decoded input. For estimating the size needed for the output buffer,
+		/// see <see cref="EstimateOutputLength"/>.</para>
+		/// </remarks>
+		/// <returns>The number of bytes written to the output buffer.</returns>
+		/// <param name="input">The input buffer.</param>
+		/// <param name="startIndex">The starting index of the input buffer.</param>
+		/// <param name="length">The length of the input buffer.</param>
+		/// <param name="output">The output buffer.</param>
+		/// <exception cref="System.ArgumentNullException">
+		/// <para><paramref name="input"/> is <c>null</c>.</para>
+		/// <para>-or-</para>
+		/// <para><paramref name="output"/> is <c>null</c>.</para>
+		/// </exception>
+		/// <exception cref="System.ArgumentOutOfRangeException">
+		/// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
+		/// a valid range in the <paramref name="input"/> byte array.
+		/// </exception>
+		/// <exception cref="System.ArgumentException">
+		/// <para><paramref name="output"/> is not large enough to contain the encoded content.</para>
+		/// <para>Use the <see cref="EstimateOutputLength"/> method to properly determine the
+		/// necessary length of the <paramref name="output"/> byte array.</para>
+		/// </exception>
+		public int Decode (byte[] input, int startIndex, int length, byte[] output)
+		{
+			ValidateArguments (input, startIndex, length, output);
+
+			unsafe {
+				fixed (byte* inptr = input, outptr = output) {
+					return Decode (inptr + startIndex, length, outptr);
+				}
+			}
+		}
+
+		/// <summary>
+		/// Reset the decoder.
+		/// </summary>
+		/// <remarks>
+		/// Resets the state of the decoder.
+		/// </remarks>
+		public void Reset ()
+		{
+			state = QpDecoderState.PassThrough;
+			saved = 0;
+		}
+	}
+}

MimeKit/MimeContent.cs

@@ -30,8 +30,10 @@
 using System.Threading;
 using System.Threading.Tasks;
 
+using MimeKit;
 using MimeKit.IO;
 using MimeKit.IO.Filters;
+using MimeKit.Encodings;
 
 namespace MimeKit {
 	/// <summary>
@@ -126,6 +128,17 @@ public ContentEncoding Encoding {
 		/// <value>The new-line format, if known.</value>
 		public NewLineFormat? NewLineFormat { get; set; }
 
+		/// <summary>
+		/// Get or set whether the content is text-based.
+		/// </summary>
+		/// <remarks>
+		/// <para>This property is typically only set by the <see cref="MimeParser"/> as it parses
+		/// the content of a <see cref="MimePart"/> and is only used as a hint when decoding
+		/// quoted-printable as to whether to canonicalize the content stream to DOS format
+		/// before decoding.</para>
+		/// </remarks>
+		internal bool IsText { get; set; }
+
 		/// <summary>
 		/// Get the content stream.
 		/// </summary>
@@ -137,6 +150,21 @@ public Stream Stream {
 			get; private set;
 		}
 
+		FilteredStream CreateFilteredStream (Stream stream)
+		{
+			var filtered = new FilteredStream (stream);
+			IMimeFilter filter;
+
+			if (!IsText && Encoding == ContentEncoding.QuotedPrintable)
+				filter = new DecoderFilter (new BinaryQuotedPrintableDecoder ());
+			else
+				filter = DecoderFilter.Create (Encoding);
+
+			filtered.Add (filter);
+
+			return filtered;
+		}
+
 		/// <summary>
 		/// Open the decoded content stream.
 		/// </summary>
@@ -154,10 +182,7 @@ public Stream Open ()
 
 			Stream.Seek (0, SeekOrigin.Begin);
 
-			var filtered = new FilteredStream (Stream);
-			filtered.Add (DecoderFilter.Create (Encoding));
-
-			return filtered;
+			return CreateFilteredStream (Stream);
 		}
 
 		/// <summary>
@@ -320,8 +345,7 @@ public void DecodeTo (Stream stream, CancellationToken cancellationToken = defau
 
 			CheckDisposed ();
 
-			using (var filtered = new FilteredStream (stream)) {
-				filtered.Add (DecoderFilter.Create (Encoding));
+			using (var filtered = CreateFilteredStream (stream)) {
 				WriteTo (filtered, cancellationToken);
 				filtered.Flush (cancellationToken);
 			}
@@ -360,8 +384,7 @@ public async Task DecodeToAsync (Stream stream, CancellationToken cancellationTo
 
 			CheckDisposed ();
 
-			using (var filtered = new FilteredStream (stream)) {
-				filtered.Add (DecoderFilter.Create (Encoding));
+			using (var filtered = CreateFilteredStream (stream)) {
 				await WriteToAsync (filtered, cancellationToken).ConfigureAwait (false);
 				await filtered.FlushAsync (cancellationToken).ConfigureAwait (false);
 			}

MimeKit/MimePart.cs

@@ -444,7 +444,7 @@ public string FileName {
 		/// <code language="c#" source="Examples\AttachmentExamples.cs" region="SaveAttachments" />
 		/// </example>
 		/// <value>The MIME content.</value>
-		public IMimeContent Content {
+		public virtual IMimeContent Content {
 			get; set;
 		}
 

MimeKit/TextPart.cs

@@ -204,6 +204,26 @@ void CheckDisposed ()
 			CheckDisposed (nameof (TextPart));
 		}
 
+		/// <summary>
+		/// Get or set the MIME content.
+		/// </summary>
+		/// <remarks>
+		/// Gets or sets the MIME content.
+		/// </remarks>
+		/// <example>
+		/// <code language="c#" source="Examples\AttachmentExamples.cs" region="SaveAttachments" />
+		/// </example>
+		/// <value>The MIME content.</value>
+		public override IMimeContent Content {
+			get { return base.Content; }
+			set {
+				if (value != null && value is MimeContent content)
+					content.IsText = true;
+
+				base.Content = value;
+			}
+		}
+
 		/// <summary>
 		/// Get the text format of the content.
 		/// </summary>