internal static string DecodeHeaderValue(string value)
{
int num;
if ((value == null) || (value.Length == 0))
{
return(string.Empty);
}
string[] strArray = value.Split(new char[] { '?' });
if (((strArray.Length != 5) || (strArray[0] != "=")) || (strArray[4] != "="))
{
return(value);
}
string name = strArray[1];
bool flag = strArray[2] == "B";
byte[] bytes = Encoding.ASCII.GetBytes(strArray[3]);
if (flag)
{
num = new Base64Stream().DecodeBytes(bytes, 0, bytes.Length);
}
else
{
num = new QuotedPrintableStream().DecodeBytes(bytes, 0, bytes.Length);
}
return(Encoding.GetEncoding(name).GetString(bytes, 0, num));
}
internal WriteAsyncResult(Base64Stream parent, byte[] buffer, int offset, int count, AsyncCallback?callback, object?state) : base(null, state, callback)
{
_parent = parent;
_buffer = buffer;
_offset = offset;
_count = count;
}
/// <summary>
/// Sets body data from the specified stream.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <param name="transferEncoding">Specifies content-transfer-encoding to use to encode data.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> or <b>transferEncoding</b> is null reference.</exception>
public void SetData(Stream stream, string transferEncoding)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (transferEncoding == null)
{
throw new ArgumentNullException("transferEncoding");
}
if (transferEncoding == MIME_TransferEncodings.QuotedPrintable)
{
using (MemoryStream mem_stream = new MemoryStream())
{
QuotedPrintableStream encoder = new QuotedPrintableStream(new SmartStream(mem_stream, false),
FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, Workaround.Definitions.MaxStreamLineLength);
encoder.Flush();
mem_stream.Position = 0;
SetEncodedData(transferEncoding, mem_stream);
}
}
else if (transferEncoding == MIME_TransferEncodings.Base64)
{
using (MemoryStream mem_stream = new MemoryStream())
{
Base64Stream encoder = new Base64Stream(mem_stream, false, true, FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, Workaround.Definitions.MaxStreamLineLength);
encoder.Finish();
mem_stream.Position = 0;
SetEncodedData(transferEncoding, mem_stream);
}
}
else if (transferEncoding == MIME_TransferEncodings.Binary)
{
SetEncodedData(transferEncoding, stream);
}
else if (transferEncoding == MIME_TransferEncodings.EightBit)
{
SetEncodedData(transferEncoding, stream);
}
else if (transferEncoding == MIME_TransferEncodings.SevenBit)
{
SetEncodedData(transferEncoding, stream);
}
else
{
throw new NotSupportedException("Not supported Content-Transfer-Encoding '" + transferEncoding +
"'.");
}
}
public void Base64Stream_EncodeString_WithVeryLongString_ShouldEncodeProperly()
{
var writeStateInfo = new Base64WriteStateInfo(10, new byte[0], new byte[0], 70, 0);
var s = new Base64Stream(writeStateInfo);
s.EncodeString(LongString, Encoding.UTF8);
string encodedString = s.GetEncodedString();
byte[] stringToDecode = Encoding.ASCII.GetBytes(encodedString);
int result = s.DecodeBytes(stringToDecode, 0, encodedString.Length);
Assert.Equal(LongString, Encoding.UTF8.GetString(stringToDecode, 0, result));
}
public void Base64Stream_WithVeryLongString_ShouldEncodeProperly()
{
var writeStateInfo = new Base64WriteStateInfo(10, new byte[0], new byte[0], 70, 0);
var s = new Base64Stream(writeStateInfo);
byte[] buffer = Encoding.UTF8.GetBytes(LongString);
s.EncodeBytes(buffer, 0, buffer.Length);
string encodedString = s.GetEncodedString();
byte[] stringToDecode = Encoding.ASCII.GetBytes(encodedString);
int result = s.DecodeBytes(stringToDecode, 0, encodedString.Length);
Assert.Equal(LongString, Encoding.UTF8.GetString(stringToDecode, 0, result));
}
/// <summary>
/// Sets body data from the specified stream.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <param name="transferEncoding">Specifies content-transfer-encoding to use to encode data.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> or <b>transferEncoding</b> is null reference.</exception>
/// <exception cref="InvalidOperationException">Is raised when this method is accessed and this body is not bounded to any entity.</exception>
public void SetData(Stream stream, string transferEncoding)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (transferEncoding == null)
{
throw new ArgumentNullException("transferEncoding");
}
if (String2.Equals(transferEncoding, MIME_TransferEncodings.QuotedPrintable, StringComparison2.InvariantCultureIgnoreCase))
{
using (MemoryStreamEx fs = new MemoryStreamEx())
{
QuotedPrintableStream encoder = new QuotedPrintableStream(new SmartStream(fs, false), FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, 84000);
encoder.Flush();
fs.Position = 0;
SetEncodedData(transferEncoding, fs);
}
}
else if (String2.Equals(transferEncoding, MIME_TransferEncodings.Base64, StringComparison2.InvariantCultureIgnoreCase))
{
using (MemoryStreamEx fs = new MemoryStreamEx())
{
Base64Stream encoder = new Base64Stream(fs, false, true, FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, 84000);
encoder.Finish();
fs.Position = 0;
SetEncodedData(transferEncoding, fs);
}
}
else if (String2.Equals(transferEncoding, MIME_TransferEncodings.Binary, StringComparison2.InvariantCultureIgnoreCase))
{
SetEncodedData(transferEncoding, stream);
}
else if (String2.Equals(transferEncoding, MIME_TransferEncodings.EightBit, StringComparison2.InvariantCultureIgnoreCase))
{
SetEncodedData(transferEncoding, stream);
}
else if (String2.Equals(transferEncoding, MIME_TransferEncodings.SevenBit, StringComparison2.InvariantCultureIgnoreCase))
{
SetEncodedData(transferEncoding, stream);
}
else
{
throw new NotSupportedException("Not supported Content-Transfer-Encoding '" + transferEncoding + "'.");
}
}
public void TestBase64StreamRead()
{
string encoded = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/9w==";
byte[] data = Convert.FromBase64String(encoded);
byte[] test;
using (Stream io = new Base64Stream(new MemoryStream(Encoding.ASCII.GetBytes(encoded)), CryptoStreamMode.Read))
test = IOStream.Read(io, data.Length);
Assert.AreEqual(data, test);
using (Stream io = new Base64Stream(new MemoryStream(Encoding.ASCII.GetBytes(encoded.TrimEnd('='))), CryptoStreamMode.Read))
test = IOStream.Read(io, data.Length);
Assert.AreEqual(data, test);
}
/// <summary>
/// Sets body data from the specified stream.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <param name="transferEncoding">Specifies content-transfer-encoding to use to encode data.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> or <b>transferEncoding</b> is null reference.</exception>
public void SetData(Stream stream, string transferEncoding)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (transferEncoding == null)
{
throw new ArgumentNullException("transferEncoding");
}
if (transferEncoding == MIME_TransferEncodings.QuotedPrintable)
{
using (FileStream fs = File.Create(Path.GetTempFileName())){
QuotedPrintableStream encoder = new QuotedPrintableStream(new SmartStream(fs, false), FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, 32000);
encoder.Flush();
fs.Position = 0;
SetEncodedData(transferEncoding, fs);
}
}
else if (transferEncoding == MIME_TransferEncodings.Base64)
{
using (FileStream fs = File.Create(Path.GetTempFileName())){
Base64Stream encoder = new Base64Stream(fs, false, true, FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, 32000);
encoder.Finish();
fs.Position = 0;
SetEncodedData(transferEncoding, fs);
}
}
else if (transferEncoding == MIME_TransferEncodings.Binary)
{
SetEncodedData(transferEncoding, stream);
}
else if (transferEncoding == MIME_TransferEncodings.EightBit)
{
SetEncodedData(transferEncoding, stream);
}
else if (transferEncoding == MIME_TransferEncodings.SevenBit)
{
SetEncodedData(transferEncoding, stream);
}
else
{
throw new NotSupportedException("Not supported Content-Transfer-Encoding '" + transferEncoding + "'.");
}
}
public void Base64Stream_EncodeString_WithVerySmallBuffer_ShouldTriggerBufferResize_AndShouldEncodeProperly()
{
var s = new Base64Stream(new Base64WriteStateInfo(10, new byte[0], new byte[0], 70, 0));
const string TestString = "0123456789abcdef";
s.EncodeString(TestString, Encoding.UTF8);
string encodedString = s.GetEncodedString();
Assert.Equal("MDEyMzQ1Njc4OWFiY2RlZg==", encodedString);
byte[] stringToDecode = Encoding.ASCII.GetBytes(encodedString);
int result = s.DecodeBytes(stringToDecode, 0, encodedString.Length);
Assert.Equal(TestString, Encoding.UTF8.GetString(stringToDecode, 0, result));
}
public void Base64Stream_WithBasicAsciiString_ShouldEncodeAndDecode(string testHeader)
{
var s = new Base64Stream(new Base64WriteStateInfo());
var testHeaderBytes = Encoding.UTF8.GetBytes(testHeader);
s.EncodeBytes(testHeaderBytes, 0, testHeaderBytes.Length);
string encodedString = s.GetEncodedString();
for (int i = 0; i < encodedString.Length; i++)
{
Assert.InRange((byte)encodedString[i], 0, 127);
}
byte[] stringToDecode = Encoding.ASCII.GetBytes(encodedString);
int result = s.DecodeBytes(stringToDecode, 0, encodedString.Length);
Assert.Equal(testHeader, Encoding.UTF8.GetString(stringToDecode, 0, result));
}
/// <summary>
/// Gets body decoded data stream.
/// </summary>
/// <returns>Returns body decoded data stream.</returns>
/// <exception cref="InvalidOperationException">Is raised when this method is accessed and this body is not bounded to any entity.</exception>
/// <exception cref="NotSupportedException">Is raised when body contains not supported Content-Transfer-Encoding.</exception>
/// <remarks>The returned stream should be closed/disposed as soon as it's not needed any more.</remarks>
public Stream GetDataStream()
{
if (this.Entity == null)
{
throw new InvalidOperationException("Body must be bounded to some entity first.");
}
/* RFC 2045 6.1.
* This is the default value -- that is, "Content-Transfer-Encoding: 7BIT" is assumed if the
* Content-Transfer-Encoding header field is not present.
*/
string transferEncoding = MIME_TransferEncodings.SevenBit;
if (this.Entity.ContentTransferEncoding != null)
{
transferEncoding = this.Entity.ContentTransferEncoding.ToLowerInvariant();
}
m_pEncodedDataStream.Position = 0;
if (transferEncoding == MIME_TransferEncodings.QuotedPrintable)
{
return(new QuotedPrintableStream(new SmartStream(m_pEncodedDataStream, false), FileAccess.Read));
}
else if (transferEncoding == MIME_TransferEncodings.Base64)
{
Base64Stream retVal = new Base64Stream(m_pEncodedDataStream, false, true, FileAccess.Read);
retVal.IgnoreInvalidPadding = true;
return(retVal);
}
else if (transferEncoding == MIME_TransferEncodings.Binary)
{
return(new ReadWriteControlledStream(m_pEncodedDataStream, FileAccess.Read));
}
else if (transferEncoding == MIME_TransferEncodings.EightBit)
{
return(new ReadWriteControlledStream(m_pEncodedDataStream, FileAccess.Read));
}
else if (transferEncoding == MIME_TransferEncodings.SevenBit)
{
return(new ReadWriteControlledStream(m_pEncodedDataStream, FileAccess.Read));
}
else
{
throw new NotSupportedException("Not supported Content-Transfer-Encoding '" + this.Entity.ContentTransferEncoding + "'.");
}
}
public void Base64Stream_WithVerySmallBuffer_ShouldTriggerBufferResize_AndShouldEncodeProperly()
{
var s = new Base64Stream(new Base64WriteStateInfo(10, new byte[0], new byte[0], 70, 0));
const string TestString = "0123456789abcdef";
byte[] buffer = Encoding.UTF8.GetBytes(TestString);
s.EncodeBytes(buffer, 0, buffer.Length);
string encodedString = s.GetEncodedString();
Assert.Equal("MDEyMzQ1Njc4OWFiY2RlZg==", encodedString);
byte[] stringToDecode = Encoding.ASCII.GetBytes(encodedString);
int result = s.DecodeBytes(stringToDecode, 0, encodedString.Length);
Assert.Equal(TestString, Encoding.UTF8.GetString(stringToDecode, 0, result));
}
public void Base64Stream_EncodeString_WithBasicAsciiString_ShouldEncodeAndDecode(string testHeader)
{
var s = new Base64Stream(new Base64WriteStateInfo());
s.EncodeString(testHeader, Encoding.UTF8);
string encodedString = s.GetEncodedString();
for (int i = 0; i < encodedString.Length; i++)
{
Assert.InRange((byte)encodedString[i], 0, 127);
}
byte[] stringToDecode = Encoding.ASCII.GetBytes(encodedString);
int result = s.DecodeBytes(stringToDecode, 0, encodedString.Length);
Assert.Equal(testHeader, Encoding.UTF8.GetString(stringToDecode, 0, result));
}
internal Stream GetEncodedStream(Stream stream)
{
Stream outputStream = stream;
if (TransferEncoding == TransferEncoding.Base64)
{
outputStream = new Base64Stream(outputStream, new Base64WriteStateInfo());
}
else if (TransferEncoding == TransferEncoding.QuotedPrintable)
{
outputStream = new QuotedPrintableStream(outputStream, true);
}
else if (TransferEncoding == TransferEncoding.SevenBit || TransferEncoding == TransferEncoding.EightBit)
{
outputStream = new EightBitStream(outputStream);
}
return(outputStream);
}
public void TestBase64StreamWrite()
{
byte[] data = new byte[256];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)i;
}
using (Stream mem = new MemoryStream())
{
using (Stream io = new Base64Stream(new NonClosingStream(mem), CryptoStreamMode.Write))
io.Write(data, 0, data.Length);
Assert.AreEqual(((data.Length + 2) / 3 * 4), mem.Position);
mem.Position = 0;
string test = new StreamReader(mem).ReadToEnd();
Assert.AreEqual(Convert.ToBase64String(data), test);
}
}
internal static string EncodeHeaderValue(string value, Encoding encoding, bool base64Encoding)
{
StringBuilder builder = new StringBuilder();
if ((encoding == null) && IsAscii(value, false))
{
return(value);
}
if (encoding == null)
{
encoding = Encoding.GetEncoding("utf-8");
}
string bodyName = encoding.BodyName();
if (encoding == Encoding.BigEndianUnicode)
{
bodyName = "utf-16be";
}
builder.Append("=?");
builder.Append(bodyName);
builder.Append("?");
builder.Append(base64Encoding ? "B" : "Q");
builder.Append("?");
byte[] bytes = encoding.GetBytes(value);
if (base64Encoding)
{
Base64Stream stream = new Base64Stream(-1);
stream.EncodeBytes(bytes, 0, bytes.Length, true);
builder.Append(Encoding.ASCII.GetString(stream.WriteState.Buffer, 0, stream.WriteState.Length));
}
else
{
QuotedPrintableStream stream2 = new QuotedPrintableStream(-1);
stream2.EncodeBytes(bytes, 0, bytes.Length);
builder.Append(Encoding.ASCII.GetString(stream2.WriteState.Buffer, 0, stream2.WriteState.Length));
}
builder.Append("?=");
return(builder.ToString());
}
/// <summary>
/// Sets body data from the specified stream.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <param name="transferEncoding">Specifies content-transfer-encoding to use to encode data.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> or <b>transferEncoding</b> is null reference.</exception>
public void SetData(Stream stream, string transferEncoding)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (transferEncoding == null)
{
throw new ArgumentNullException("transferEncoding");
}
if (transferEncoding == MIME_TransferEncodings.QuotedPrintable)
{
using (MemoryStream mem_stream = new MemoryStream())
{
QuotedPrintableStream encoder = new QuotedPrintableStream(new SmartStream(mem_stream, false),
FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, Workaround.Definitions.MaxStreamLineLength);
encoder.Flush();
mem_stream.Position = 0;
SetEncodedData(transferEncoding, mem_stream);
}
}
else if (transferEncoding == MIME_TransferEncodings.Base64)
{
using (MemoryStream mem_stream = new MemoryStream())
{
Base64Stream encoder = new Base64Stream(mem_stream, false, true, FileAccess.ReadWrite);
Net_Utils.StreamCopy(stream, encoder, Workaround.Definitions.MaxStreamLineLength);
encoder.Finish();
mem_stream.Position = 0;
SetEncodedData(transferEncoding, mem_stream);
}
}
else if (transferEncoding == MIME_TransferEncodings.Binary)
{
SetEncodedData(transferEncoding, stream);
}
else if (transferEncoding == MIME_TransferEncodings.EightBit)
{
SetEncodedData(transferEncoding, stream);
}
else if (transferEncoding == MIME_TransferEncodings.SevenBit)
{
SetEncodedData(transferEncoding, stream);
}
else
{
throw new NotSupportedException("Not supported Content-Transfer-Encoding '" + transferEncoding +
"'.");
}
}
internal Stream GetEncodedStream(Stream stream){
Stream outputStream = stream;
if (TransferEncoding == TransferEncoding.Base64) {
outputStream = new Base64Stream(outputStream, new Base64WriteStateInfo());
}
else if (TransferEncoding == TransferEncoding.QuotedPrintable) {
outputStream = new QuotedPrintableStream(outputStream,true);
}
else if (TransferEncoding == TransferEncoding.SevenBit || TransferEncoding == TransferEncoding.EightBit) {
outputStream = new EightBitStream(outputStream);
}
return outputStream;
}
