internal async Task<string> ReadFieldValue(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var memStream = new MemoryStream();
while ((TypOfEnd == EndType.None) && (nextByte == (byte)SpecialByte.Space || nextByte == (byte)SpecialByte.CarriageReturn))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
await ProcessEol(reader);
break;
case (byte)SpecialByte.Space:
break;
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
default: // alle andere gevallen
break;
}
if (TypOfEnd == EndType.None) nextByte = await reader.ReadByteAsync();
}
while (MimeCheckByte(nextByte))
{
memStream.WriteByte(nextByte);
nextByte = await reader.ReadByteAsync();
}
if (nextByte == (byte)SpecialByte.CarriageReturn) await ProcessEol(reader);
var bytes = memStream.ToArray();
memStream.Dispose();
return Encoding.ASCII.GetString(bytes);
}
public async Task<List<Body>> GetBodies(IByteStreamReader streamReader, ContentTypeFieldValue contentType, string transportEncoding)
{
var reader = new BufferedByteReader(streamReader);
switch (contentType.Type)
{
case "multipart":
var bodyPartReader = new BodyReader(ContentType, Header.ContentTransferEncoding);
var bodies = await bodyPartReader.ReadBody(reader);
break;
case "text":
var textString = "";
using (var memstream = await streamReader.GetMemoryStreamAsync())
{
using (var unEncoded = await MailMethods.UnEncode(memstream, Header.ContentTransferEncoding))
{
using (var textReader = new StreamReader(unEncoded, Encoding.GetEncoding(Header.ContentType.Charset)))
{
textString = await textReader.ReadToEndAsync();
}
}
}
var textBody = new Body();
textBody.Content = (new MemoryStream(Encoding.Unicode.GetBytes(textString)));
break;
case "image":
case "audio":
case "video":
case "application":
var binaryBody = new Body();
binaryBody.Content = await streamReader.GetMemoryStreamAsync());
break;
}
}
internal async Task<EndType> ReadFieldValue(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var endType = EndType.None;
while ((endType == EndType.None))
{
if (nextByte == (byte)SpecialByte.CarriageReturn)
{
endType = await ProcessEol(reader);
if (endType == EndType.None) nextByte = await reader.ReadByteAsync();
continue;
}
switch (nextByte)
{
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
case (byte)SpecialByte.LeftAngledBracket: // "<": begin id
Identifiers.Add(await ReadOneId(reader));
break;
default: // alle andere gevallen
break;
}
nextByte = await reader.ReadByteAsync();
}
return endType;
}
/// <summary>
/// Processes an end of line to determine wether it is part of a folding white space,
/// an end of field or an end of header.
/// assumes a Carriage return (x0D) has just been read from the "reader".
/// </summary>
/// <param name="reader">BufferdByteReader to acces the underlying stream</param>
/// <returns>Enum EndType</returns>
internal async Task<FieldValue.EndType> ProcessEol(BufferedByteReader reader)
{
var rs = await reader.ReadByteAsync();
if (rs != (byte)FieldValue.SpecialByte.Linefeed)
{
throw new FormatException("carriagereturn must be followed by linefeed");
}
_endType = FieldValue.EndType.EndOfField; // unless folowed by a space ( a folding white space = FWS)
rs = await reader.ReadByteAhead();
if (rs == (byte)FieldValue.SpecialByte.Space)
{
rs = await reader.ReadByteAhead();
while (rs == (byte)FieldValue.SpecialByte.Space)
{
rs = await reader.ReadByteAhead();
}
_endType = FieldValue.EndType.None; // unless folowed by a crlf (End of header)
// leave 1 space and the not space character on the buffer
if (reader.BufferSize > 2) reader.RemoveFirst(reader.BufferSize - 2);
}
// Two crlf's with or without spaces in between signify te end of the Header
if (rs != (byte)FieldValue.SpecialByte.CarriageReturn) return _endType;
reader.Clear();
rs = await reader.ReadByteAsync();
if (rs != (byte)FieldValue.SpecialByte.Linefeed)
{
throw new FormatException("carriagereturn must be followed by linefeed");
}
_endType = EndType.EndOfHeader;
return _endType;
}
internal async Task<EndType> ReadFieldValue(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var valueBuilder = new StringBuilder();
var endType = EndType.None;
while ((endType == EndType.None))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
endType = await ProcessEol(reader);
break;
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
case (byte)SpecialByte.Space:
if
(
(valueBuilder.Length == 0) ||
(valueBuilder[valueBuilder.Length - 1] != ' ')
) valueBuilder.Append(' ');
break;
default: // alle andere gevallen
valueBuilder.Append(Convert.ToChar(nextByte));
break;
}
if (endType == EndType.None) nextByte = await reader.ReadByteAsync();
}
_stringRepresentation = valueBuilder.ToString();
Value = Convert.ToDateTime(_stringRepresentation, CultureInfo.InvariantCulture);
return endType;
}
private static async Task <byte[]> ReadHashAsync(Stream hashStream, CancellationToken cancellationToken)
{
using (var reader = new BufferedByteReader(hashStream))
{
for (; ;)
{
int b = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
if (b == -1 || b == '\r' || b == '\n')
{
throw new InvalidDataException("Hash value is missing.");
}
if (b == '=')
{
break;
}
}
byte[] bytes = ArrayPool <byte> .Shared.Rent(1024 / 8);
try
{
for (int i = 0; ; ++i)
{
int hexDigit = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
if (hexDigit == -1 || hexDigit == '\r' || hexDigit == '\n')
{
return(bytes.AsSpan(0, i).ToArray());
}
byte upperNibble = HexDigitToNibble(hexDigit);
if (i == bytes.Length)
{
throw new InvalidDataException("Hash value is too long.");
}
hexDigit = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
if (hexDigit == -1 || hexDigit == '\r' || hexDigit == '\n')
{
throw new InvalidDataException("Hash value has an odd number of hexadecimal digits.");
}
byte lowerNibble = HexDigitToNibble(hexDigit);
bytes[i] = (byte)((upperNibble << 4) | lowerNibble);
}
}
finally
{
ArrayPool <byte> .Shared.Return(bytes);
}
}
}
private async Task ReadToStart(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
while (!(await CheckBytes(reader, nextByte, null)))
{
await reader.ReadByteAsync();
}
}
private async Task<bool> CheckBytes(BufferedByteReader reader)
{
var i = 1;
while (i < _boundary.Length)
{
if (await reader.ReadByteAsync() != _boundary[i]) return false;
i += 1;
}
return true;
}
private async Task ReadSinglePart(BufferedByteReader reader)
{
byte nextByte;
while (!_completed && !reader.MessageEnd)
{
nextByte = await reader.ReadByteAsync();
if nextByte
}
}
internal async Task <EndType> ReadFieldValue(BufferedByteReader reader)
{
var valueBuilder = new StringBuilder();
var nextByte = await reader.ReadByteAsync();
var endType = EndType.None;
MimeState = PreviousMimeQuoted.NotMime;
while ((endType == EndType.None))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
endType = await ProcessEol(reader);
break;
case (byte)SpecialByte.Equals:
var mimeResult = await MimeQuotedString(reader);
if (mimeResult == "=")
{
MimeState = PreviousMimeQuoted.NotMime;
}
else
{
if (MimeState == PreviousMimeQuoted.MimeQuoted)
{
while (valueBuilder.Length > 0 && valueBuilder[valueBuilder.Length - 1] == ' ')
{
valueBuilder.Remove(valueBuilder.Length - 1, 1);
}
}
MimeState = PreviousMimeQuoted.MimeQuoted;
}
valueBuilder.Append(mimeResult);
break;
case (byte)SpecialByte.Space:
valueBuilder.Append(Convert.ToChar(nextByte));
break;
default:
valueBuilder.Append(Convert.ToChar(nextByte));
MimeState = PreviousMimeQuoted.NotMime;
break;
}
if (endType == EndType.None)
{
nextByte = await reader.ReadByteAsync();
}
}
Value = valueBuilder.ToString().Trim();
return(endType);
}
private async Task<MemoryStream> GetQuotedParameterValue(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var memStream = new MemoryStream();
while (nextByte != (byte)SpecialByte.Quote)
{
memStream.WriteByte(nextByte);
nextByte = await reader.ReadByteAsync();
}
return memStream;
}
private async Task ReadSinglePart(BufferedByteReader reader)
{
byte nextByte;
while (!_completed && !reader.MessageEnd)
{
nextByte = await reader.ReadByteAsync();
if nextByte
}
}
new internal async Task <EndType> ReadFieldValue(BufferedByteReader reader)
{
var value = await base.ReadFieldValue(reader);
var result = value.Split('/');
Type = result[0];
SubType = result[1];
// and now the parameters
string key = null;
var valueBuilder = new StringBuilder();
var nextByte = await reader.ReadByteAsync();
while (base.TypOfEnd == EndType.None)
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
await ProcessEol(reader);
break;
case (byte)SpecialByte.Equals:
key = valueBuilder.ToString().Trim();
await ReadParameter(key, reader);
valueBuilder = new StringBuilder();
break;
case (byte)SpecialByte.Space:
break;
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
case (byte)SpecialByte.SemiColon: // ";" End of parameter
break;
default: // alle andere gevallen
valueBuilder.Append(Convert.ToChar(nextByte));
MimeState = PreviousMimeQuoted.NotMime;
break;
}
if (base.TypOfEnd == EndType.None)
{
nextByte = await reader.ReadByteAsync();
}
}
return(base.TypOfEnd);
}
internal async Task<string> ReadFieldName(BufferedByteReader reader)
{
var nameBuilder = new StringBuilder();
var buffer = await reader.ReadByteAsync();
while (buffer != (byte)FieldValue.SpecialByte.Colon)
{
nameBuilder.Append(Convert.ToChar(buffer));
buffer = await reader.ReadByteAsync();
}
return nameBuilder.ToString().Trim();
}
internal async Task <string> ReadFieldName(BufferedByteReader reader)
{
var nameBuilder = new StringBuilder();
var buffer = await reader.ReadByteAsync();
while (buffer != (byte)FieldValue.SpecialByte.Colon)
{
nameBuilder.Append(Convert.ToChar(buffer));
buffer = await reader.ReadByteAsync();
}
return(nameBuilder.ToString().Trim());
}
public async Task ReadDate()
{
const string fileName = "TestCFWSP.txt";
var reader = new BufferedByteReader(new FileByteReader());
await reader.GetReaderAsync(fileName);
var header = new Header();
await header.ReadHeader(reader);
reader.Dispose(false);
Assert.AreEqual(Convert.ToDateTime("14-02-1969 4:02", CultureInfo.CurrentCulture), header.OrigDate, "This message has the wrong Date");
}
public async Task ReadContentType()
{
const string fileName = "RFC2046-1.txt";
var reader = new BufferedByteReader(new FileByteReader());
await reader.GetReaderAsync(fileName);
var header = new Header();
await header.ReadHeader(reader);
reader.Dispose(false);
Assert.AreEqual(1, header.ContentType.Boundary.Length, 15);
Assert.AreEqual("multipart", header.ContentType.Type, "Type should be multipart");
}
private async Task <MemoryStream> GetQuotedParameterValue(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var memStream = new MemoryStream();
while (nextByte != (byte)SpecialByte.Quote)
{
memStream.WriteByte(nextByte);
nextByte = await reader.ReadByteAsync();
}
return(memStream);
}
private async Task <bool> CheckForEnd(BufferedByteReader reader)
{
if ((await reader.ReadByteAhead()) == 45)
{
if ((await reader.ReadByteAhead()) == 45)
{
reader.Clear();
Complete();
return(true);
}
}
return(false);
}
public async Task ReadAddressCommentsFws()
{
const string fileName = "TestCFWSP.txt";
var reader = new BufferedByteReader(new FileByteReader());
await reader.GetReaderAsync(fileName);
var header = new Header();
await header.ReadHeader(reader);
reader.Dispose(false);
Assert.AreEqual("Pete", header.From.Adresses[0].Name, "This message is not from Pete");
Assert.AreEqual("A Group", header.To.Groups[0].Name, "This message is not to 'A Group'");
Assert.AreEqual("Chris Jones", header.To.Groups[0].Members[0].Name, "A Group does not include 'Chris Jones'");
}
public async Task ReadMessageIDs()
{
const string fileName = "testReferences.txt";
var reader = new BufferedByteReader(new FileByteReader());
await reader.GetReaderAsync(fileName);
var header = new Header();
await header.ReadHeader(reader);
reader.Dispose(false);
Assert.AreEqual("*****@*****.**", header.MessageId, "This message has thet wrong ID");
Assert.AreEqual("*****@*****.**", header.InReplyTo.Identifiers[0], "This message replies to the wrong message");
Assert.AreEqual(2, header.References.Identifiers.Count, "This message does not reference 2 messages");
}
private async Task ReadMultiPart(BufferedByteReader reader)
{
if (ContentType.Boundary.Length > _maxBoundaryLength) _maxBoundaryLength = ContentType.Boundary.Length;
await ReadToStart(reader);
while (!_completed)
{
var body = new Body(this, _maxBoundaryLength);
await body.Header.ReadHeader(reader);
await body.ReadBody(reader, Header.ContentTransferEncoding);
Bodies.Add(body);
}
if (!_completed) Complete();
return;
}
public async Task ReadMime2047_1()
{
const string fileName = "RFC2047-1.txt";
var reader = new BufferedByteReader(new FileByteReader());
await reader.GetReaderAsync(fileName);
var header = new Header();
await header.ReadHeader(reader);
reader.Dispose(false);
Assert.AreEqual("Keith Moore", header.From.Adresses[0].Name, "This message is not from Keith Moore (2047-1)");
Assert.AreEqual("Keld Jørn Simonsen", header.To.Adresses[0].Name, "This message is not to Keld Jørn Simonsen (2047-1)");
Assert.AreEqual("André Pirard", header.Cc.Adresses[0].Name, "This message is not Cced to André Pirard");
Assert.AreEqual("If you can read this you understand the example.", header.Subject, "Subject not correct");
}
internal async Task <string> ReadFieldValue(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var memStream = new MemoryStream();
while ((TypOfEnd == EndType.None) && (nextByte == (byte)SpecialByte.Space || nextByte == (byte)SpecialByte.CarriageReturn))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
await ProcessEol(reader);
break;
case (byte)SpecialByte.Space:
break;
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
default: // alle andere gevallen
break;
}
if (TypOfEnd == EndType.None)
{
nextByte = await reader.ReadByteAsync();
}
}
while (MimeCheckByte(nextByte))
{
memStream.WriteByte(nextByte);
nextByte = await reader.ReadByteAsync();
}
if (nextByte == (byte)SpecialByte.CarriageReturn)
{
await ProcessEol(reader);
}
var bytes = memStream.ToArray();
memStream.Dispose();
return(Encoding.ASCII.GetString(bytes));
}
internal async Task <EndType> ReadFieldValue(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var valueBuilder = new StringBuilder();
var endType = EndType.None;
while ((endType == EndType.None))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
endType = await ProcessEol(reader);
break;
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
case (byte)SpecialByte.Space:
if
(
(valueBuilder.Length == 0) ||
(valueBuilder[valueBuilder.Length - 1] != ' ')
)
{
valueBuilder.Append(' ');
}
break;
default: // alle andere gevallen
valueBuilder.Append(Convert.ToChar(nextByte));
break;
}
if (endType == EndType.None)
{
nextByte = await reader.ReadByteAsync();
}
}
_stringRepresentation = valueBuilder.ToString();
Value = Convert.ToDateTime(_stringRepresentation, CultureInfo.InvariantCulture);
return(endType);
}
internal async Task ReadBody(BufferedByteReader reader, string transferEncoding)
{
switch (Header.ContentType.Type)
{
case "multipart":
await ReadMultiPart(reader);
break;
case "text":
Content = (new MemoryStream(Encoding.Unicode.GetBytes(textString)));
break;
case "image":
case "audio":
case "video":
case "application":
break;
}
}
internal async Task<Body> ReadBody( BufferedByteReader reader)
{
var body = new Body();
var nextByte = await reader.ReadByteAsync();
{
if (nextByte == _boundary[0])
{
if (await CheckBytes(reader))
{
var bodyPart = new Body();
await bodyPart.Header.ReadHeader(reader);
}
}
nextByte = await reader.ReadByteAsync();
}
return body;
}
internal async Task ReadToStart(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var boundaryeByteIndex = 0;
while (boundaryeByteIndex < _boundary.Length)
{
if (nextByte == _boundary[0])
{
nextByte = await reader.ReadByteAsync();
boundaryeByteIndex = 1;
while (boundaryeByteIndex < _boundary.Length && nextByte == _boundary[boundaryeByteIndex])
{
nextByte = await reader.ReadByteAsync();
boundaryeByteIndex += 1;
}
}
else nextByte = await reader.ReadByteAsync();
}
}
internal async Task<byte[]> ReadBytesParameter(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var memStream = new MemoryStream();
if (nextByte == (byte)SpecialByte.Quote)
memStream = await GetQuotedParameterValue(reader);
else
{
while (MimeCheckByte(nextByte))
{
memStream.WriteByte(nextByte);
nextByte = await reader.ReadByteAsync();
}
if (nextByte == (byte)SpecialByte.CarriageReturn) await ProcessEol(reader);
}
var bytes = memStream.ToArray();
memStream.Dispose();
return bytes;
}
internal async Task<EndType> ReadFieldValue (BufferedByteReader reader)
{
var valueBuilder = new StringBuilder();
var nextByte = await reader.ReadByteAsync();
var endType = EndType.None;
MimeState = PreviousMimeQuoted.NotMime;
while ((endType == EndType.None))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
endType = await ProcessEol(reader);
break;
case (byte)SpecialByte.Equals:
var mimeResult = await MimeQuotedString(reader);
if (mimeResult == "=") MimeState = PreviousMimeQuoted.NotMime;
else
{
if (MimeState == PreviousMimeQuoted.MimeQuoted)
{
while (valueBuilder.Length > 0 && valueBuilder[valueBuilder.Length - 1] == ' ')
{
valueBuilder.Remove(valueBuilder.Length - 1, 1);
}
}
MimeState = PreviousMimeQuoted.MimeQuoted;
}
valueBuilder.Append(mimeResult);
break;
case (byte)SpecialByte.Space:
valueBuilder.Append(Convert.ToChar(nextByte));
break;
default:
valueBuilder.Append(Convert.ToChar(nextByte));
MimeState= PreviousMimeQuoted.NotMime;
break;
}
if (endType == EndType.None) nextByte = await reader.ReadByteAsync();
}
Value = valueBuilder.ToString().Trim();
return endType;
}
/// <summary>
/// Processes an end of line to determine wether it is part of a folding white space,
/// an end of field or an end of header.
/// assumes a Carriage return (x0D) has just been read from the "reader".
/// </summary>
/// <param name="reader">BufferdByteReader to acces the underlying stream</param>
/// <returns>Enum EndType</returns>
internal async Task <FieldValue.EndType> ProcessEol(BufferedByteReader reader)
{
var rs = await reader.ReadByteAsync();
if (rs != (byte)FieldValue.SpecialByte.Linefeed)
{
throw new FormatException("carriagereturn must be followed by linefeed");
}
_endType = FieldValue.EndType.EndOfField; // unless folowed by a space ( a folding white space = FWS)
rs = await reader.ReadByteAhead();
if (rs == (byte)FieldValue.SpecialByte.Space)
{
rs = await reader.ReadByteAhead();
while (rs == (byte)FieldValue.SpecialByte.Space)
{
rs = await reader.ReadByteAhead();
}
_endType = FieldValue.EndType.None; // unless folowed by a crlf (End of header)
// leave 1 space and the not space character on the buffer
if (reader.BufferSize > 2)
{
reader.RemoveFirst(reader.BufferSize - 2);
}
}
// Two crlf's with or without spaces in between signify te end of the Header
if (rs != (byte)FieldValue.SpecialByte.CarriageReturn)
{
return(_endType);
}
reader.Clear();
rs = await reader.ReadByteAsync();
if (rs != (byte)FieldValue.SpecialByte.Linefeed)
{
throw new FormatException("carriagereturn must be followed by linefeed");
}
_endType = EndType.EndOfHeader;
return(_endType);
}
new internal async Task<EndType> ReadFieldValue(BufferedByteReader reader)
{
var value = await base.ReadFieldValue(reader);
var result = value.Split('/');
Type = result[0];
SubType = result[1];
// and now the parameters
string key = null;
var valueBuilder = new StringBuilder();
var nextByte = await reader.ReadByteAsync();
while (base.TypOfEnd == EndType.None)
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
await ProcessEol(reader);
break;
case (byte)SpecialByte.Equals:
key = valueBuilder.ToString().Trim();
await ReadParameter(key, reader);
valueBuilder = new StringBuilder();
break;
case (byte)SpecialByte.Space:
break;
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
case (byte)SpecialByte.SemiColon: // ";" End of parameter
break;
default: // alle andere gevallen
valueBuilder.Append(Convert.ToChar(nextByte));
MimeState = PreviousMimeQuoted.NotMime;
break;
}
if (base.TypOfEnd == EndType.None) nextByte = await reader.ReadByteAsync();
}
return base.TypOfEnd;
}
private async Task <string> WordFromBase64(BufferedByteReader reader, Encoding charset)
{
string decoded;
var nextByte = await reader.ReadByteAhead();
if (nextByte != (byte)SpecialByte.QuestionMark)
{
return("=");
}
nextByte = await reader.ReadByteAhead();
var valueBuilder = new StringBuilder();
while (valueBuilder.Length < 800 && nextByte != (byte)SpecialByte.QuestionMark)
{
valueBuilder.Append(Convert.ToChar(nextByte));
nextByte = await reader.ReadByteAhead();
}
if (nextByte != (byte)SpecialByte.QuestionMark)
{
return("=");
}
nextByte = await reader.ReadByteAhead();
if (nextByte != (byte)SpecialByte.Equals)
{
return("=");
}
var base64String = valueBuilder.ToString();
try
{
var base64DecodedBytes = Convert.FromBase64String(base64String);
decoded = charset.GetString(base64DecodedBytes);
}
catch (Exception)
{
return("=");
}
return(decoded);
}
internal async Task ReadBody(BufferedByteReader reader, string transferEncoding)
{
switch (Header.ContentType.Type)
{
case "multipart":
await ReadMultiPart(reader);
break;
case "text":
Content = (new MemoryStream(Encoding.Unicode.GetBytes(textString)));
break;
case "image":
case "audio":
case "video":
case "application":
break;
}
}
internal async Task<EndType> ReadFieldValue(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var endType = EndType.None;
while ((endType == EndType.None))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
endType = await ProcessEol(reader);
break;
case (byte)SpecialByte.BackSlash:
nextByte = await reader.ReadByteAsync();
break;
}
if (endType == EndType.None) nextByte = await reader.ReadByteAsync();
}
return endType;
}
/// <summary>
/// Processes a quoted string
/// assumes a quote has just been read from the "reader".
/// </summary>
/// <param name="reader">BufferdByteReader to acces the underlying stream</param>
/// <returns>QuotedStringResult (quoted string value & EbdType</returns>
internal async Task <QuotedStringResult> ReadQuotedString(BufferedByteReader reader)
{
var valueBuilder = new StringBuilder();
var nextByte = await reader.ReadByteAsync();
var endType = EndType.None;
while ((endType == EndType.None) && (nextByte != (byte)SpecialByte.Quote))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
endType = await ProcessEol(reader);
break;
case (byte)SpecialByte.BackSlash:
nextByte = await reader.ReadByteAsync();
valueBuilder.Append(Convert.ToChar(nextByte));
break;
default:
valueBuilder.Append(Convert.ToChar(nextByte));
break;
}
if (endType == EndType.None)
{
nextByte = await reader.ReadByteAsync();
}
}
var thisResult = new QuotedStringResult()
{
End = endType,
QuotedStringValue = valueBuilder.ToString()
};
return(thisResult);
}
private async Task ReadMultiPart(BufferedByteReader reader)
{
if (ContentType.Boundary.Length > _maxBoundaryLength)
{
_maxBoundaryLength = ContentType.Boundary.Length;
}
await ReadToStart(reader);
while (!_completed)
{
var body = new Body(this, _maxBoundaryLength);
await body.Header.ReadHeader(reader);
await body.ReadBody(reader, Header.ContentTransferEncoding);
Bodies.Add(body);
}
if (!_completed)
{
Complete();
}
return;
}
internal async Task <EndType> ReadFieldValue(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
var endType = EndType.None;
while ((endType == EndType.None))
{
if (nextByte == (byte)SpecialByte.CarriageReturn)
{
endType = await ProcessEol(reader);
if (endType == EndType.None)
{
nextByte = await reader.ReadByteAsync();
}
continue;
}
switch (nextByte)
{
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
case (byte)SpecialByte.LeftAngledBracket: // "<": begin id
Identifiers.Add(await ReadOneId(reader));
break;
default: // alle andere gevallen
break;
}
nextByte = await reader.ReadByteAsync();
}
return(endType);
}
internal async Task <EndType> ReadFieldValue(BufferedByteReader reader)
{
var valueBuilder = new StringBuilder();
var nextByte = await reader.ReadByteAsync();
var address = new AddressListFieldValue.Adress();
Group group = new Group();
var endType = EndType.None;
while ((endType == EndType.None))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
endType = await ProcessEol(reader);
break;
case (byte)SpecialByte.Equals:
var resultString = await MimeQuotedString(reader);
if (resultString == "=")
{
MimeState = PreviousMimeQuoted.NotMime;
valueBuilder.Append('=');
}
else
{
if (MimeState == PreviousMimeQuoted.MimeQuoted)
{
if (valueBuilder.Length > 0 && valueBuilder[valueBuilder.Length - 1] == ' ')
{
valueBuilder.Remove(valueBuilder.Length - 1, 1);
}
}
MimeState = PreviousMimeQuoted.MimeQuoted;
valueBuilder.Append(resultString).Append(' ');
}
break;
case (byte)SpecialByte.Space:
if (valueBuilder.Length > 0 && valueBuilder[valueBuilder.Length - 1] != ' ')
{
valueBuilder.Append(' ');
}
break;
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
case (byte)SpecialByte.BackSlash: // "\": begin "quoted character"
valueBuilder.Append(Convert.ToChar(nextByte));
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.Quote: // """: begin quoted string
valueBuilder.Append(await ReadQuotedString(reader));
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.Colon: // ":": = end of group name
group.Name = valueBuilder.ToString().Trim();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.LeftAngledBracket: // "<": begin email address (mailbox)
address.Name = valueBuilder.ToString().Trim();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.RightAngledBracket: // ">" : end of email address (mailbox)
address.MailBox = valueBuilder.ToString().Trim();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.Comma: // "," : end of name-adress spec
AddressAdd
(
((group.Name == null) ? this.Adresses : group.Members),
address,
valueBuilder
);
address = new Adress();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.SemiColon: // ";" End of group
GroupAdd(group, address, valueBuilder);
group = new Group();
address = new Adress();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
default: // alle andere gevallen
valueBuilder.Append(Convert.ToChar(nextByte));
MimeState = PreviousMimeQuoted.NotMime;
break;
}
if (endType == EndType.None)
{
nextByte = await reader.ReadByteAsync();
}
}
if (group.Name == null)
{
AddressAdd(this.Adresses, address, valueBuilder);
}
else
{
GroupAdd(group, address, valueBuilder);
}
return(endType);
}
private async Task <string> WordFromQuotedPrintable(BufferedByteReader reader, Encoding charset)
{
var nextByte = await reader.ReadByteAhead();
if (nextByte != (byte)SpecialByte.QuestionMark)
{
return("=");
}
nextByte = await reader.ReadByteAhead();
var valueBuilder = new StringBuilder();
while (valueBuilder.Length < 100 && nextByte != (byte)SpecialByte.QuestionMark)
{
switch (nextByte)
{
case (byte)SpecialByte.Equals:
// two byte Hex number ahead
var number = new byte[1]; // GetString needs a Byte Array
var hex = new byte[2];
// First Byte ....
hex[0] = await reader.ReadByteAhead();
hex[1] = await reader.ReadByteAhead();
if (!byte.TryParse(
Encoding.ASCII.GetString(hex),
System.Globalization.NumberStyles.HexNumber,
System.Globalization.CultureInfo.InvariantCulture,
out number[0]))
{
return("=");
}
// Now we know the character in the encoding
valueBuilder.Append(charset.GetString(number));
break;
case (byte)SpecialByte.Underscore:
valueBuilder.Append(' ');
break;
default:
if (!MimeCheckByte(nextByte))
{
return("=");
}
valueBuilder.Append(Convert.ToChar(nextByte));
break;
}
nextByte = await reader.ReadByteAhead();
}
if (nextByte != (byte)SpecialByte.QuestionMark)
{
return("=");
}
nextByte = await reader.ReadByteAhead();
if (nextByte != (byte)SpecialByte.Equals)
{
return("=");
}
reader.Clear();
return(valueBuilder.ToString());
}
public async Task GetOneMail(IByteStreamReader streamReader)
{
var reader = new BufferedByteReader(streamReader);
Received = DateTime.Now;
}
internal async Task <string> MimeQuotedString(BufferedByteReader reader)
{
var resultString = "";
var valueBuilder = new StringBuilder();
var nextByte = await reader.ReadByteAhead();
if (nextByte != (byte)SpecialByte.QuestionMark)
{ // not Mime encoded word....
return("=");
}
// charset
nextByte = await reader.ReadByteAhead();
while (valueBuilder.Length < 50 && MimeCheckByte(nextByte))
{
valueBuilder.Append(Convert.ToChar(nextByte));
nextByte = await reader.ReadByteAhead();
}
if (nextByte != (byte)SpecialByte.QuestionMark)
{
return("=");
}
var charSet = valueBuilder.ToString().ToLower();
Encoding charset;
try
{
charset = Encoding.GetEncoding(charSet);
}
catch (Exception)
{
charset = null;
}
if (charset == null)
{
try
{
// Provide the base class for an encoding provider,
// which supplies encodings that are unavailable on this particular platform.
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
// Now we can try again.
charset = Encoding.GetEncoding(charSet);
}
catch (Exception)
{
var res = new ResourceLoader("EmailProxies/Resources");
charSet = res.GetString("us-ascii");
charset = Encoding.GetEncoding(charSet);
}
}
// encoding
nextByte = await reader.ReadByteAhead();
var encoding = nextByte;
// B = ascii 66
if (encoding == 66)
{
resultString = await WordFromBase64(reader, charset);
}
// Q = ascii 81
if (encoding == 81)
{
resultString = await WordFromQuotedPrintable(reader, charset);
}
if (resultString != "=")
{
reader.Clear();
}
return(resultString);
}
internal async Task<EndType> ReadQuotedString(BufferedByteReader reader, BinaryWriter writer)
{
var nextByte = await reader.ReadByteAsync();
var endType = EndType.None;
while ((endType == EndType.None) && (nextByte != (byte)SpecialByte.Quote))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
endType = await ProcessEol(reader);
break;
case (byte)SpecialByte.BackSlash:
nextByte = await reader.ReadByteAsync();
writer.Write(nextByte);
break;
default:
writer.Write(nextByte);
break;
}
if (endType == EndType.None) nextByte = await reader.ReadByteAsync();
}
return endType;
}
public async Task GetOneMail(IByteStreamReader streamReader)
{
var reader = new BufferedByteReader(streamReader);
Received = DateTime.Now;
}
private async Task<bool> CheckBytes(BufferedByteReader reader, byte newByte, Body body)
{
if (newByte != _boundaryStart[0]) return false;
if ((await reader.ReadByteAhead()) != _boundaryStart[1]) return false;
if ((await reader.ReadByteAhead()) != _boundaryStart[2]) return false;
if ((await reader.ReadByteAhead()) != _boundaryStart[3]) return false;
_boundaryPossible = true;
var i = 0;
while (!_completed && !NoBoundaryPossible && i < _maxBoundaryLength)
{
var oneByte = await reader.ReadByteAhead();
CheckOneByte(oneByte, i, this);
i += 1;
}
if
return true;
}
private async Task<string> WordFromBase64(BufferedByteReader reader, Encoding charset)
{
string decoded;
var nextByte = await reader.ReadByteAhead();
if (nextByte != (byte) SpecialByte.QuestionMark) return "=";
nextByte = await reader.ReadByteAhead();
var valueBuilder = new StringBuilder();
while (valueBuilder.Length < 800 && nextByte != (byte)SpecialByte.QuestionMark)
{
valueBuilder.Append(Convert.ToChar(nextByte));
nextByte = await reader.ReadByteAhead();
}
if (nextByte != (byte) SpecialByte.QuestionMark) return "=";
nextByte = await reader.ReadByteAhead();
if (nextByte != (byte)SpecialByte.Equals) return "=";
var base64String = valueBuilder.ToString();
try
{
var base64DecodedBytes = Convert.FromBase64String(base64String);
decoded = charset.GetString(base64DecodedBytes);
}
catch (Exception)
{
return "=";
}
return decoded;
}
internal async Task<DateTime> ReadDateParameter(BufferedByteReader reader)
{
var stringValue = await ReadStringParameter(reader);
var dateTimeValue = Convert.ToDateTime(stringValue, CultureInfo.InvariantCulture);
return dateTimeValue;
}
internal async Task<string> MimeQuotedString(BufferedByteReader reader)
{
var resultString = "";
var valueBuilder = new StringBuilder();
var nextByte = await reader.ReadByteAhead();
if (nextByte != (byte) SpecialByte.QuestionMark)
{ // not Mime encoded word....
return "=";
}
// charset
nextByte = await reader.ReadByteAhead();
while (valueBuilder.Length < 50 && MimeCheckByte(nextByte))
{
valueBuilder.Append(Convert.ToChar(nextByte));
nextByte = await reader.ReadByteAhead();
}
if (nextByte != (byte) SpecialByte.QuestionMark)
{
return "=";
}
var charSet = valueBuilder.ToString().ToLower();
Encoding charset;
try
{
charset = Encoding.GetEncoding(charSet);
}
catch (Exception)
{
charset = null;
}
if (charset == null)
{
try
{
// Provide the base class for an encoding provider,
// which supplies encodings that are unavailable on this particular platform.
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
// Now we can try again.
charset = Encoding.GetEncoding(charSet);
}
catch (Exception)
{
var res = new ResourceLoader("EmailProxies/Resources");
charSet = res.GetString("us-ascii");
charset = Encoding.GetEncoding(charSet);
}
}
// encoding
nextByte = await reader.ReadByteAhead();
var encoding = nextByte;
// B = ascii 66
if (encoding == 66) resultString = await WordFromBase64(reader, charset);
// Q = ascii 81
if (encoding == 81) resultString = await WordFromQuotedPrintable(reader, charset);
if (resultString != "=")
{
reader.Clear();
}
return resultString;
}
public async Task ReadHeader(BufferedByteReader reader)
{
var fieldName = new HeaderFieldName();
var endType = FieldValue.EndType.None;
var ignore = new HeaderIgnoreFieldValue();
while (endType != FieldValue.EndType.EndOfHeader)
{
var name = await fieldName.ReadFieldName(reader);
switch (name)
{
case "From":
From = new AddressListFieldValue();
endType = await From.ReadFieldValue(reader);
break;
case "Sender":
var sender = new AddressListFieldValue();
endType = await sender.ReadFieldValue(reader);
Sender = sender.Adresses[0];
break;
case "Reply-To":
ReplyTo = new AddressListFieldValue();
endType = await ReplyTo.ReadFieldValue(reader);
break;
case "To":
To = new AddressListFieldValue();
endType = await To.ReadFieldValue(reader);
break;
case "CC":
Cc = new AddressListFieldValue();
endType = await Cc.ReadFieldValue(reader);
break;
case "Date":
var dateField = new DateFieldValue();
endType = await dateField.ReadFieldValue(reader);
OrigDate = dateField.Value;
break;
case "Message-ID":
var ids = new IdentificationFieldValue();
endType = await ids.ReadFieldValue(reader);
MessageId = ids.Identifiers[0];
break;
case "In-Reply-To":
InReplyTo = new IdentificationFieldValue();
endType = await InReplyTo.ReadFieldValue(reader);
break;
case "References":
References = new IdentificationFieldValue();
endType = await References.ReadFieldValue(reader);
break;
case "Subject":
var subject = new UnstructuredTextFieldValue();
endType = await subject.ReadFieldValue(reader);
Subject = subject.Value;
break;
case "Comments":
var comments = new UnstructuredTextFieldValue();
endType = await comments.ReadFieldValue(reader);
Subject = comments.Value;
break;
case "Content-type":
ContentType = new ContentTypeFieldValue();
endType = await ContentType.ReadFieldValue(reader);
break;
case "Content-transfer-encoding":
var contentTransferEncoding = new MimeFieldFieldValue();
ContentTransferEncoding = await contentTransferEncoding.ReadFieldValue(reader);
endType = contentTransferEncoding.TypOfEnd;
break;
case "Content-ID":
var newid = new IdentificationFieldValue();
endType = await newid.ReadFieldValue(reader).ConfigureAwait(false);
ContentId = newid.Identifiers[0];
break;
case "Content-description":
var description = new UnstructuredTextFieldValue();
endType = await description.ReadFieldValue(reader);
ContentDescription = description.Value;
break;
default:
endType = await ignore.ReadFieldValue(reader);
break;
}
}
}
private async Task ReadToStart(BufferedByteReader reader)
{
var nextByte = await reader.ReadByteAsync();
while (!(await CheckBytes(reader, nextByte, null))) await reader.ReadByteAsync();
}
private async Task<string> WordFromQuotedPrintable(BufferedByteReader reader, Encoding charset)
{
var nextByte = await reader.ReadByteAhead();
if (nextByte != (byte)SpecialByte.QuestionMark) return "=";
nextByte = await reader.ReadByteAhead();
var valueBuilder = new StringBuilder();
while (valueBuilder.Length < 100 && nextByte != (byte)SpecialByte.QuestionMark)
{
switch (nextByte)
{
case (byte)SpecialByte.Equals:
// two byte Hex number ahead
var number = new byte[1]; // GetString needs a Byte Array
var hex = new byte[2];
// First Byte ....
hex[0] = await reader.ReadByteAhead();
hex[1] = await reader.ReadByteAhead();
if (!byte.TryParse(
Encoding.ASCII.GetString(hex),
System.Globalization.NumberStyles.HexNumber,
System.Globalization.CultureInfo.InvariantCulture,
out number[0]))
{
return "=";
}
// Now we know the character in the encoding
valueBuilder.Append(charset.GetString(number));
break;
case (byte)SpecialByte.Underscore:
valueBuilder.Append(' ');
break;
default:
if (!MimeCheckByte(nextByte)) return "=";
valueBuilder.Append(Convert.ToChar(nextByte));
break;
}
nextByte = await reader.ReadByteAhead();
}
if (nextByte != (byte)SpecialByte.QuestionMark) return "=";
nextByte = await reader.ReadByteAhead();
if (nextByte != (byte)SpecialByte.Equals) return "=";
reader.Clear();
return valueBuilder.ToString();
}
internal async Task<Int32> ReadNumberParameter(BufferedByteReader reader)
{
var stringValue = await ReadStringParameter(reader);
var numberValue = Convert.ToInt32(stringValue);
return numberValue;
}
private async Task<bool> CheckForEnd(BufferedByteReader reader)
{
if ((await reader.ReadByteAhead()) == 45)
{
if ((await reader.ReadByteAhead()) == 45)
{
reader.Clear();
Complete();
return true;
}
}
return false;
}
private async Task ReadParameter(string key, BufferedByteReader reader)
{
switch (key)
{
case "boundary":
Boundary = await ReadBytesParameter(reader).ConfigureAwait(false);
break;
case "charset":
Charset = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "type":
TYPE = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "padding":
Padding = await ReadNumberParameter(reader).ConfigureAwait(false);
break;
case "number":
Number = await ReadNumberParameter(reader).ConfigureAwait(false);
break;
case "total":
Total = await ReadNumberParameter(reader).ConfigureAwait(false);
break;
case "id":
Id = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "acces-type":
AccesType = (await ReadStringParameter(reader).ConfigureAwait(false)).ToLower();
break;
case "expiration":
Expiration = await ReadDateParameter(reader).ConfigureAwait(false);
break;
case "size":
Size = await ReadNumberParameter(reader).ConfigureAwait(false);
break;
case "permission":
Permission = (await ReadStringParameter(reader).ConfigureAwait(false)).ToLower();
break;
case "name":
Name = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "site":
Site = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "directory":
Directory = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "mode":
Mode = (await ReadStringParameter(reader).ConfigureAwait(false)).ToLower();
break;
case "server":
Server = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "subject":
Subject = await ReadStringParameter(reader).ConfigureAwait(false);
break;
default:
await ReadBytesParameter(reader);
break;
}
return;
}
internal async Task<string> ReadStringParameter(BufferedByteReader reader)
{
var bytes = await ReadBytesParameter(reader);
var stringValue = Encoding.ASCII.GetString(bytes);
return stringValue;
}
internal async Task<EndType> ReadFieldValue(BufferedByteReader reader)
{
var valueBuilder = new StringBuilder();
var nextByte = await reader.ReadByteAsync();
var address = new AddressListFieldValue.Adress();
Group group = new Group();
var endType = EndType.None;
while ((endType == EndType.None))
{
switch (nextByte)
{
case (byte)SpecialByte.CarriageReturn:
endType = await ProcessEol(reader);
break;
case (byte)SpecialByte.Equals:
var resultString = await MimeQuotedString(reader);
if (resultString == "=")
{
MimeState = PreviousMimeQuoted.NotMime;
valueBuilder.Append('=');
}
else
{
if (MimeState == PreviousMimeQuoted.MimeQuoted)
{
if (valueBuilder.Length > 0 && valueBuilder[valueBuilder.Length - 1] == ' ')
{
valueBuilder.Remove(valueBuilder.Length - 1, 1);
}
}
MimeState = PreviousMimeQuoted.MimeQuoted;
valueBuilder.Append(resultString).Append(' ');
}
break;
case (byte)SpecialByte.Space:
if (valueBuilder.Length > 0 && valueBuilder[valueBuilder.Length - 1] != ' ')
{
valueBuilder.Append(' ');
}
break;
case (byte)SpecialByte.LeftParenthesis: // "(": begin comment
await ReadComment(reader);
break;
case (byte)SpecialByte.BackSlash: // "\": begin "quoted character"
valueBuilder.Append(Convert.ToChar(nextByte));
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.Quote: // """: begin quoted string
valueBuilder.Append(await ReadQuotedString(reader));
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.Colon: // ":": = end of group name
group.Name = valueBuilder.ToString().Trim();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.LeftAngledBracket: // "<": begin email address (mailbox)
address.Name = valueBuilder.ToString().Trim();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.RightAngledBracket: // ">" : end of email address (mailbox)
address.MailBox = valueBuilder.ToString().Trim();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.Comma: // "," : end of name-adress spec
AddressAdd
(
((group.Name == null) ? this.Adresses : group.Members),
address,
valueBuilder
);
address = new Adress();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
case (byte)SpecialByte.SemiColon: // ";" End of group
GroupAdd(group, address, valueBuilder);
group = new Group();
address = new Adress();
valueBuilder = new StringBuilder();
MimeState = PreviousMimeQuoted.NotMime;
break;
default: // alle andere gevallen
valueBuilder.Append(Convert.ToChar(nextByte));
MimeState = PreviousMimeQuoted.NotMime;
break;
}
if (endType == EndType.None) nextByte = await reader.ReadByteAsync();
}
if (group.Name == null)
{
AddressAdd(this.Adresses, address, valueBuilder);
}
else
{
GroupAdd(group, address, valueBuilder);
}
return endType;
}
private async Task ReadParameter(string key, BufferedByteReader reader)
{
switch (key)
{
case "boundary":
Boundary = await ReadBytesParameter(reader).ConfigureAwait(false);
break;
case "charset":
Charset = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "type":
TYPE = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "padding":
Padding = await ReadNumberParameter(reader).ConfigureAwait(false);
break;
case "number":
Number = await ReadNumberParameter(reader).ConfigureAwait(false);
break;
case "total":
Total = await ReadNumberParameter(reader).ConfigureAwait(false);
break;
case "id":
Id = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "acces-type":
AccesType = (await ReadStringParameter(reader).ConfigureAwait(false)).ToLower();
break;
case "expiration":
Expiration = await ReadDateParameter(reader).ConfigureAwait(false);
break;
case "size":
Size = await ReadNumberParameter(reader).ConfigureAwait(false);
break;
case "permission":
Permission = (await ReadStringParameter(reader).ConfigureAwait(false)).ToLower();
break;
case "name":
Name = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "site":
Site = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "directory":
Directory = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "mode":
Mode = (await ReadStringParameter(reader).ConfigureAwait(false)).ToLower();
break;
case "server":
Server = await ReadStringParameter(reader).ConfigureAwait(false);
break;
case "subject":
Subject = await ReadStringParameter(reader).ConfigureAwait(false);
break;
default:
await ReadBytesParameter(reader);
break;
}
return;
}
