Add project
Basic formatting applied. Unnecessary comments have been removed. Suspicious code is covered by TODO.
This commit is contained in:
374
Hcs.Client/ClientApi/FileStoreServiceApi/RFC2047.cs
Normal file
374
Hcs.Client/ClientApi/FileStoreServiceApi/RFC2047.cs
Normal file
@ -0,0 +1,374 @@
|
||||
//===============================================================================
|
||||
// RFC2047 (Encoded Word) Decoder
|
||||
// https://github.com/grumpydev/RFC2047-Encoded-Word-Encoder-Decoder/blob/master/EncodedWord/RFC2047.cs
|
||||
// http://tools.ietf.org/html/rfc2047
|
||||
//===============================================================================
|
||||
// Copyright © Steven Robbins. All rights reserved.
|
||||
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
|
||||
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
|
||||
// LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
// FITNESS FOR A PARTICULAR PURPOSE.
|
||||
//===============================================================================
|
||||
|
||||
namespace EncodedWord
|
||||
{
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Text.RegularExpressions;
|
||||
|
||||
/// <summary>
|
||||
/// Provides support for decoding RFC2047 (Encoded Word) encoded text
|
||||
/// </summary>
|
||||
public static class RFC2047
|
||||
{
|
||||
/// <summary>
|
||||
/// Regex for parsing encoded word sections
|
||||
/// From http://tools.ietf.org/html/rfc2047#section-3
|
||||
/// encoded-word = "=?" charset "?" encoding "?" encoded-text "?="
|
||||
/// </summary>
|
||||
private static readonly Regex EncodedWordFormatRegEx = new Regex(@"=\?(?<charset>.*?)\?(?<encoding>[qQbB])\?(?<encodedtext>.*?)\?=", RegexOptions.Singleline | RegexOptions.Compiled);
|
||||
|
||||
/// <summary>
|
||||
/// Regex for removing CRLF SPACE separators from between encoded words
|
||||
/// </summary>
|
||||
private static readonly Regex EncodedWordSeparatorRegEx = new Regex(@"\?=\r\n =\?", RegexOptions.Compiled);
|
||||
|
||||
/// <summary>
|
||||
/// Replacement string for removing CRLF SPACE separators
|
||||
/// </summary>
|
||||
private const string SeparatorReplacement = @"?==?";
|
||||
|
||||
/// <summary>
|
||||
/// The maximum line length allowed
|
||||
/// </summary>
|
||||
private const int MaxLineLength = 75;
|
||||
|
||||
/// <summary>
|
||||
/// Regex for "Q-Encoding" hex bytes from http://tools.ietf.org/html/rfc2047#section-4.2
|
||||
/// </summary>
|
||||
private static readonly Regex QEncodingHexCodeRegEx = new Regex(@"(=(?<hexcode>[0-9a-fA-F][0-9a-fA-F]))", RegexOptions.Compiled);
|
||||
|
||||
/// <summary>
|
||||
/// Regex for replacing _ with space as declared in http://tools.ietf.org/html/rfc2047#section-4.2
|
||||
/// </summary>
|
||||
private static readonly Regex QEncodingSpaceRegEx = new Regex("_", RegexOptions.Compiled);
|
||||
|
||||
/// <summary>
|
||||
/// Format for an encoded string
|
||||
/// </summary>
|
||||
private const string EncodedStringFormat = @"=?{0}?{1}?{2}?=";
|
||||
|
||||
/// <summary>
|
||||
/// Special characters, as defined by RFC2047
|
||||
/// </summary>
|
||||
private static readonly char[] SpecialCharacters = { '(', ')', '<', '>', '@', ',', ';', ':', '<', '>', '/', '[', ']', '?', '.', '=', '\t' };
|
||||
|
||||
/// <summary>
|
||||
/// Represents a content encoding type defined in RFC2047
|
||||
/// </summary>
|
||||
public enum ContentEncoding
|
||||
{
|
||||
/// <summary>
|
||||
/// Unknown / invalid encoding
|
||||
/// </summary>
|
||||
Unknown,
|
||||
|
||||
/// <summary>
|
||||
/// "Q Encoding" (reduced character set) encoding
|
||||
/// http://tools.ietf.org/html/rfc2047#section-4.2
|
||||
/// </summary>
|
||||
QEncoding,
|
||||
|
||||
/// <summary>
|
||||
/// Base 64 encoding
|
||||
/// http://tools.ietf.org/html/rfc2047#section-4.1
|
||||
/// </summary>
|
||||
Base64
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encode a string into RFC2047
|
||||
/// </summary>
|
||||
/// <param name="plainString">Plain string to encode</param>
|
||||
/// <param name="contentEncoding">Content encoding to use</param>
|
||||
/// <param name="characterSet">Character set used by plainString</param>
|
||||
/// <returns>Encoded string</returns>
|
||||
public static string Encode(string plainString, ContentEncoding contentEncoding = ContentEncoding.QEncoding, string characterSet = "iso-8859-1")
|
||||
{
|
||||
if (String.IsNullOrEmpty(plainString))
|
||||
{
|
||||
return String.Empty;
|
||||
}
|
||||
|
||||
if (contentEncoding == ContentEncoding.Unknown)
|
||||
{
|
||||
throw new ArgumentException("contentEncoding cannot be unknown for encoding.", "contentEncoding");
|
||||
}
|
||||
|
||||
if (!IsSupportedCharacterSet(characterSet))
|
||||
{
|
||||
throw new ArgumentException("characterSet is not supported", "characterSet");
|
||||
}
|
||||
|
||||
var textEncoding = Encoding.GetEncoding(characterSet);
|
||||
|
||||
var encoder = GetContentEncoder(contentEncoding);
|
||||
|
||||
var encodedContent = encoder.Invoke(plainString, textEncoding);
|
||||
|
||||
return BuildEncodedString(characterSet, contentEncoding, encodedContent);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decode a string containing RFC2047 encoded sections
|
||||
/// </summary>
|
||||
/// <param name="encodedString">String contaning encoded sections</param>
|
||||
/// <returns>Decoded string</returns>
|
||||
public static string Decode(string encodedString)
|
||||
{
|
||||
// Remove separators
|
||||
var decodedString = EncodedWordSeparatorRegEx.Replace(encodedString, SeparatorReplacement);
|
||||
|
||||
return EncodedWordFormatRegEx.Replace(
|
||||
decodedString,
|
||||
m =>
|
||||
{
|
||||
var contentEncoding = GetContentEncodingType(m.Groups["encoding"].Value);
|
||||
if (contentEncoding == ContentEncoding.Unknown)
|
||||
{
|
||||
// Regex should never match, but return anyway
|
||||
return string.Empty;
|
||||
}
|
||||
|
||||
var characterSet = m.Groups["charset"].Value;
|
||||
if (!IsSupportedCharacterSet(characterSet))
|
||||
{
|
||||
// Fall back to iso-8859-1 if invalid/unsupported character set found
|
||||
characterSet = @"iso-8859-1";
|
||||
}
|
||||
|
||||
var textEncoding = Encoding.GetEncoding(characterSet);
|
||||
var contentDecoder = GetContentDecoder(contentEncoding);
|
||||
var encodedText = m.Groups["encodedtext"].Value;
|
||||
|
||||
return contentDecoder.Invoke(encodedText, textEncoding);
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Determines if a character set is supported
|
||||
/// </summary>
|
||||
/// <param name="characterSet">Character set name</param>
|
||||
/// <returns>Bool representing whether the character set is supported</returns>
|
||||
private static bool IsSupportedCharacterSet(string characterSet)
|
||||
{
|
||||
return Encoding.GetEncodings()
|
||||
.Where(e => String.Equals(e.Name, characterSet, StringComparison.InvariantCultureIgnoreCase))
|
||||
.Any();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the content encoding type from the encoding character
|
||||
/// </summary>
|
||||
/// <param name="contentEncodingCharacter">Content contentEncodingCharacter character</param>
|
||||
/// <returns>ContentEncoding type</returns>
|
||||
private static ContentEncoding GetContentEncodingType(string contentEncodingCharacter)
|
||||
{
|
||||
switch (contentEncodingCharacter)
|
||||
{
|
||||
case "Q":
|
||||
case "q":
|
||||
return ContentEncoding.QEncoding;
|
||||
case "B":
|
||||
case "b":
|
||||
return ContentEncoding.Base64;
|
||||
default:
|
||||
return ContentEncoding.Unknown;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the content decoder delegate for the given content encoding type
|
||||
/// </summary>
|
||||
/// <param name="contentEncoding">Content encoding type</param>
|
||||
/// <returns>Decoding delegate</returns>
|
||||
private static Func<string, Encoding, string> GetContentDecoder(ContentEncoding contentEncoding)
|
||||
{
|
||||
switch (contentEncoding)
|
||||
{
|
||||
case ContentEncoding.Base64:
|
||||
return DecodeBase64;
|
||||
case ContentEncoding.QEncoding:
|
||||
return DecodeQEncoding;
|
||||
default:
|
||||
// Will never get here, but return a "null" delegate anyway
|
||||
return (s, e) => String.Empty;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the content encoder delegate for the given content encoding type
|
||||
/// </summary>
|
||||
/// <param name="contentEncoding">Content encoding type</param>
|
||||
/// <returns>Encoding delegate</returns>
|
||||
private static Func<string, Encoding, string> GetContentEncoder(ContentEncoding contentEncoding)
|
||||
{
|
||||
switch (contentEncoding)
|
||||
{
|
||||
case ContentEncoding.Base64:
|
||||
return EncodeBase64;
|
||||
case ContentEncoding.QEncoding:
|
||||
return EncodeQEncoding;
|
||||
default:
|
||||
// Will never get here, but return a "null" delegate anyway
|
||||
return (s, e) => String.Empty;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a base64 encoded string
|
||||
/// </summary>
|
||||
/// <param name="encodedText">Encoded text</param>
|
||||
/// <param name="textEncoder">Encoding instance for the code page required</param>
|
||||
/// <returns>Decoded string</returns>
|
||||
private static string DecodeBase64(string encodedText, Encoding textEncoder)
|
||||
{
|
||||
var encodedBytes = Convert.FromBase64String(encodedText);
|
||||
|
||||
return textEncoder.GetString(encodedBytes);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encodes a base64 encoded string
|
||||
/// </summary>
|
||||
/// <param name="plainText">Plain text</param>
|
||||
/// <param name="textEncoder">Encoding instance for the code page required</param>
|
||||
/// <returns>Encoded string</returns>
|
||||
private static string EncodeBase64(string plainText, Encoding textEncoder)
|
||||
{
|
||||
var plainTextBytes = textEncoder.GetBytes(plainText);
|
||||
|
||||
return Convert.ToBase64String(plainTextBytes);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a "Q encoded" string
|
||||
/// </summary>
|
||||
/// <param name="encodedText">Encoded text</param>
|
||||
/// <param name="textEncoder">Encoding instance for the code page required</param>
|
||||
/// <returns>Decoded string</returns>
|
||||
private static string DecodeQEncoding(string encodedText, Encoding textEncoder)
|
||||
{
|
||||
var decodedText = QEncodingSpaceRegEx.Replace(encodedText, " ");
|
||||
|
||||
decodedText = QEncodingHexCodeRegEx.Replace(
|
||||
decodedText,
|
||||
m =>
|
||||
{
|
||||
var hexString = m.Groups["hexcode"].Value;
|
||||
|
||||
int characterValue;
|
||||
if (!int.TryParse(hexString, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out characterValue))
|
||||
{
|
||||
return String.Empty;
|
||||
}
|
||||
|
||||
return textEncoder.GetString(new[] { (byte)characterValue });
|
||||
});
|
||||
|
||||
return decodedText;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encodes a "Q encoded" string
|
||||
/// </summary>
|
||||
/// <param name="plainText">Plain text</param>
|
||||
/// <param name="textEncoder">Encoding instance for the code page required</param>
|
||||
/// <returns>Encoded string</returns>
|
||||
private static string EncodeQEncoding(string plainText, Encoding textEncoder)
|
||||
{
|
||||
if (textEncoder.GetByteCount(plainText) != plainText.Length)
|
||||
{
|
||||
throw new ArgumentException("Q encoding only supports single byte encodings", "textEncoder");
|
||||
}
|
||||
|
||||
var specialBytes = textEncoder.GetBytes(SpecialCharacters);
|
||||
|
||||
var sb = new StringBuilder(plainText.Length);
|
||||
|
||||
var plainBytes = textEncoder.GetBytes(plainText);
|
||||
|
||||
// Replace "high" values
|
||||
for (int i = 0; i < plainBytes.Length; i++)
|
||||
{
|
||||
if (plainBytes[i] <= 127 && !specialBytes.Contains(plainBytes[i]))
|
||||
{
|
||||
sb.Append(Convert.ToChar(plainBytes[i]));
|
||||
}
|
||||
else
|
||||
{
|
||||
sb.Append("=");
|
||||
sb.Append(Convert.ToString(plainBytes[i], 16).ToUpper());
|
||||
}
|
||||
}
|
||||
|
||||
return sb.ToString().Replace(" ", "_");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Builds the full encoded string representation
|
||||
/// </summary>
|
||||
/// <param name="characterSet">Characterset to use</param>
|
||||
/// <param name="contentEncoding">Content encoding to use</param>
|
||||
/// <param name="encodedContent">Content, encoded to the above parameters</param>
|
||||
/// <returns>Valid RFC2047 string</returns>
|
||||
private static string BuildEncodedString(string characterSet, ContentEncoding contentEncoding, string encodedContent)
|
||||
{
|
||||
var encodingCharacter = String.Empty;
|
||||
|
||||
switch (contentEncoding)
|
||||
{
|
||||
case ContentEncoding.Base64:
|
||||
encodingCharacter = "B";
|
||||
break;
|
||||
case ContentEncoding.QEncoding:
|
||||
encodingCharacter = "Q";
|
||||
break;
|
||||
}
|
||||
|
||||
var wrapperLength = string.Format(EncodedStringFormat, characterSet, encodingCharacter, String.Empty).Length;
|
||||
var chunkLength = MaxLineLength - wrapperLength;
|
||||
|
||||
if (encodedContent.Length <= chunkLength)
|
||||
{
|
||||
return string.Format(EncodedStringFormat, characterSet, encodingCharacter, encodedContent);
|
||||
}
|
||||
|
||||
var sb = new StringBuilder();
|
||||
foreach (var chunk in SplitStringByLength(encodedContent, chunkLength))
|
||||
{
|
||||
sb.AppendFormat(EncodedStringFormat, characterSet, encodingCharacter, chunk);
|
||||
sb.Append("\r\n ");
|
||||
}
|
||||
|
||||
return sb.ToString();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Splits a string into chunks
|
||||
/// </summary>
|
||||
/// <param name="inputString">Input string</param>
|
||||
/// <param name="chunkSize">Size of each chunk</param>
|
||||
/// <returns>String collection of chunked strings</returns>
|
||||
public static IEnumerable<string> SplitStringByLength(this string inputString, int chunkSize)
|
||||
{
|
||||
for (int index = 0; index < inputString.Length; index += chunkSize)
|
||||
{
|
||||
yield return inputString.Substring(index, Math.Min(chunkSize, inputString.Length - index));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user