/// <summary>
/// Tries to parse a version from a header such as Mime-Version.
/// </summary>
/// <remarks>
/// Parses a MIME version string from the supplied buffer starting at the given index
/// and spanning across the specified number of bytes.
/// </remarks>
/// <returns><c>true</c>, if the version was successfully parsed, <c>false</c> otherwise.</returns>
/// <param name="buffer">The raw byte buffer to parse.</param>
/// <param name="startIndex">The index into the buffer to start parsing.</param>
/// <param name="length">The length of the buffer to parse.</param>
/// <param name="version">The parsed version.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="buffer"/> is <c>null</c>.
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
/// a valid range in the byte array.
/// </exception>
public static bool TryParseVersion(byte[] buffer, int startIndex, int length, out Version version)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (startIndex < 0 || startIndex > buffer.Length)
{
throw new ArgumentOutOfRangeException("startIndex");
}
if (length < 0 || length > (buffer.Length - startIndex))
{
throw new ArgumentOutOfRangeException("length");
}
List <int> values = new List <int> ();
int endIndex = startIndex + length;
int index = startIndex;
int value;
version = null;
do
{
if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false) || index >= endIndex)
{
return(false);
}
if (!ParseUtils.TryParseInt32(buffer, ref index, endIndex, out value))
{
return(false);
}
values.Add(value);
if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
{
return(false);
}
if (index >= endIndex)
{
break;
}
if (buffer[index++] != (byte)'.')
{
return(false);
}
} while (index < endIndex);
switch (values.Count)
{
case 4: version = new Version(values[0], values[1], values[2], values[3]); break;
case 3: version = new Version(values[0], values[1], values[2]); break;
case 2: version = new Version(values[0], values[1]); break;
default: return(false);
}
return(true);
}
/// <summary>
/// Enumerates the message-id references such as those that can be found in
/// the In-Reply-To or References header.
/// </summary>
/// <remarks>
/// Incrementally parses Message-Ids (such as those from a References header
/// in a MIME message) from the supplied buffer starting at the given index
/// and spanning across the specified number of bytes.
/// </remarks>
/// <returns>The references.</returns>
/// <param name="buffer">The raw byte buffer to parse.</param>
/// <param name="startIndex">The index into the buffer to start parsing.</param>
/// <param name="length">The length of the buffer to parse.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="buffer"/> is <c>null</c>.
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
/// a valid range in the byte array.
/// </exception>
public static IEnumerable <string> EnumerateReferences(byte[] buffer, int startIndex, int length)
{
byte[] sentinels = { (byte)'>' };
int endIndex = startIndex + length;
int index = startIndex;
InternetAddress addr;
string msgid;
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (startIndex < 0 || startIndex > buffer.Length)
{
throw new ArgumentOutOfRangeException("startIndex");
}
if (length < 0 || length > (buffer.Length - startIndex))
{
throw new ArgumentOutOfRangeException("length");
}
do
{
if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
{
break;
}
if (index >= endIndex)
{
break;
}
if (buffer[index] == '<')
{
if (!InternetAddress.TryParseMailbox(ParserOptions.Default, buffer, startIndex, ref index, endIndex, "", 65001, false, out addr))
{
break;
}
msgid = ((MailboxAddress)addr).Address;
// Note: some message-id's are broken and in the form local-part@domain@domain
// https://github.com/jstedfast/MailKit/issues/138
while (index < endIndex && buffer[index] == (byte)'@')
{
int saved = index;
string domain;
index++;
if (!ParseUtils.TryParseDomain(buffer, ref index, endIndex, sentinels, false, out domain))
{
index = saved;
break;
}
msgid += "@" + domain;
}
yield return(msgid);
}
else if (!ParseUtils.SkipWord(buffer, ref index, endIndex, false))
{
index++;
}
} while (index < endIndex);
yield break;
}
static bool TryParseUnknownDateFormat(IList <DateToken> tokens, byte[] text, out DateTimeOffset date)
{
int? day = null, month = null, year = null, tzone = null;
int hour = 0, minute = 0, second = 0;
bool numericMonth = false;
bool haveWeekday = false;
bool haveTime = false;
DayOfWeek weekday;
TimeSpan offset;
for (int i = 0; i < tokens.Count; i++)
{
int value;
if (!haveWeekday && tokens[i].IsWeekday)
{
if (TryGetWeekday(tokens[i], text, out weekday))
{
haveWeekday = true;
continue;
}
}
if ((month == null || numericMonth) && tokens[i].IsMonth)
{
if (TryGetMonth(tokens[i], text, out value))
{
if (numericMonth)
{
numericMonth = false;
day = month;
}
month = value;
continue;
}
}
if (!haveTime && tokens[i].IsTimeOfDay)
{
if (TryGetTimeOfDay(tokens[i], text, out hour, out minute, out second))
{
haveTime = true;
continue;
}
}
if (tzone == null && tokens[i].IsTimeZone)
{
if (TryGetTimeZone(tokens[i], text, out value))
{
tzone = value;
continue;
}
}
if (tokens[i].IsNumeric)
{
if (tokens[i].Length == 4)
{
if (year == null)
{
if (TryGetYear(tokens[i], text, out value))
{
year = value;
}
}
else if (tzone == null)
{
if (TryGetTimeZone(tokens[i], text, out value))
{
tzone = value;
}
}
continue;
}
if (tokens[i].Length > 2)
{
continue;
}
// Note: we likely have either YYYY[-/]MM[-/]DD or MM[-/]DD[-/]YY
int endIndex = tokens[i].StartIndex + tokens[i].Length;
int index = tokens[i].StartIndex;
ParseUtils.TryParseInt32(text, ref index, endIndex, out value);
if (month == null && value > 0 && value <= 12)
{
numericMonth = true;
month = value;
continue;
}
if (day == null && value > 0 && value <= 31)
{
day = value;
continue;
}
if (year == null && value >= 69)
{
year = 1900 + value;
continue;
}
}
// WTF is this??
}
if (year == null || month == null || day == null)
{
date = new DateTimeOffset();
return(false);
}
if (!haveTime)
{
hour = minute = second = 0;
}
if (tzone != null)
{
int minutes = tzone.Value % 100;
int hours = tzone.Value / 100;
offset = new TimeSpan(hours, minutes, 0);
}
else
{
offset = new TimeSpan(0);
}
try {
date = new DateTimeOffset(year.Value, month.Value, day.Value, hour, minute, second, offset);
} catch (ArgumentOutOfRangeException) {
date = new DateTimeOffset();
return(false);
}
return(true);
}
static bool TryGetTimeZone(DateToken token, byte[] text, out int tzone)
{
tzone = 0;
if (token.IsNumericZone)
{
int endIndex = token.StartIndex + token.Length;
int index = token.StartIndex;
int sign;
if (text[index] == (byte)'-')
{
sign = -1;
}
else if (text[index] == (byte)'+')
{
sign = 1;
}
else
{
return(false);
}
index++;
if (!ParseUtils.TryParseInt32(text, ref index, endIndex, out tzone) || index != endIndex)
{
return(false);
}
tzone *= sign;
}
else if (token.IsAlphaZone)
{
if (token.Length > 3)
{
return(false);
}
var name = Encoding.ASCII.GetString(text, token.StartIndex, token.Length);
if (!timezones.TryGetValue(name, out tzone))
{
return(false);
}
}
else if (token.IsNumeric)
{
int endIndex = token.StartIndex + token.Length;
int index = token.StartIndex;
if (!ParseUtils.TryParseInt32(text, ref index, endIndex, out tzone) || index != endIndex)
{
return(false);
}
}
if (tzone < -1200 || tzone > 1400)
{
return(false);
}
return(true);
}
/// <summary>
/// Parses a Message-Id header value.
/// </summary>
/// <remarks>
/// Parses the Message-Id value, returning the addr-spec portion of the msg-id token.
/// </remarks>
/// <returns>The addr-spec portion of the msg-id token.</returns>
/// <param name="buffer">The raw byte buffer to parse.</param>
/// <param name="startIndex">The index into the buffer to start parsing.</param>
/// <param name="length">The length of the buffer to parse.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="buffer"/> is <c>null</c>.
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
/// a valid range in the byte array.
/// </exception>
public static string ParseMessageId(byte[] buffer, int startIndex, int length)
{
ParseUtils.ValidateArguments(buffer, startIndex, length);
byte[] sentinels = { (byte)'>' };
int endIndex = startIndex + length;
int index = startIndex;
string msgid;
if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
{
return(null);
}
if (index >= endIndex)
{
return(null);
}
if (buffer[index] == '<')
{
// skip over the '<'
index++;
if (index >= endIndex)
{
return(null);
}
}
string localpart;
if (!InternetAddress.TryParseLocalPart(buffer, ref index, endIndex, false, out localpart))
{
return(null);
}
if (index >= endIndex)
{
return(null);
}
if (buffer[index] == (byte)'>')
{
// The msgid token did not contain an @domain. Technically this is illegal, but for the
// sake of maximum compatibility, I guess we have no choice but to accept it...
return(localpart);
}
if (buffer[index] != (byte)'@')
{
// who the hell knows what we have here...
return(null);
}
// skip over the '@'
index++;
if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
{
return(null);
}
if (index >= endIndex)
{
return(null);
}
if (buffer[index] == (byte)'>')
{
// The msgid token was in the form "<local-part@>". Technically this is illegal, but for
// the sake of maximum compatibility, I guess we have no choice but to accept it...
// https://github.com/jstedfast/MimeKit/issues/102
return(localpart + "@");
}
string domain;
if (!ParseUtils.TryParseDomain(buffer, ref index, endIndex, sentinels, false, out domain))
{
return(null);
}
msgid = localpart + "@" + domain;
// Note: some Message-Id's are broken and in the form "<local-part@domain@domain>"
// https://github.com/jstedfast/MailKit/issues/138
while (index < endIndex && buffer[index] == (byte)'@')
{
index++;
if (!ParseUtils.TryParseDomain(buffer, ref index, endIndex, sentinels, false, out domain))
{
break;
}
msgid += "@" + domain;
}
return(msgid);
}
/// <summary>
/// Enumerates the message-id references such as those that can be found in
/// the In-Reply-To or References header.
/// </summary>
/// <remarks>
/// Incrementally parses Message-Ids (such as those from a References header
/// in a MIME message) from the supplied buffer starting at the given index
/// and spanning across the specified number of bytes.
/// </remarks>
/// <returns>The references.</returns>
/// <param name="buffer">The raw byte buffer to parse.</param>
/// <param name="startIndex">The index into the buffer to start parsing.</param>
/// <param name="length">The length of the buffer to parse.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="buffer"/> is <c>null</c>.
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
/// a valid range in the byte array.
/// </exception>
public static IEnumerable <string> EnumerateReferences(byte[] buffer, int startIndex, int length)
{
byte[] sentinels = { (byte)'>' };
int endIndex = startIndex + length;
int index = startIndex;
string msgid;
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (startIndex < 0 || startIndex > buffer.Length)
{
throw new ArgumentOutOfRangeException("startIndex");
}
if (length < 0 || length > (buffer.Length - startIndex))
{
throw new ArgumentOutOfRangeException("length");
}
do
{
if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
{
break;
}
if (index >= endIndex)
{
break;
}
if (buffer[index] == '<')
{
int tokenIndex = index;
// skip over the '<'
index++;
if (index >= endIndex)
{
break;
}
string localpart;
if (!InternetAddress.TryParseLocalPart(buffer, ref index, endIndex, false, out localpart))
{
continue;
}
if (index >= endIndex)
{
break;
}
if (buffer[index] == (byte)'>')
{
// The msgid token did not contain an @domain. Technically this is illegal, but for the
// sake of maximum compatibility, I guess we have no choice but to accept it...
index++;
yield return(localpart);
continue;
}
if (buffer[index] != (byte)'@')
{
// who the hell knows what we have here... ignore it and continue on?
continue;
}
// skip over the '@'
index++;
if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
{
break;
}
if (index >= endIndex)
{
break;
}
if (buffer[index] == (byte)'>')
{
// The msgid token was in the form "<local-part@>". Technically this is illegal, but for
// the sake of maximum compatibility, I guess we have no choice but to accept it...
// https://github.com/jstedfast/MimeKit/issues/102
index++;
yield return(localpart + "@");
continue;
}
string domain;
if (!ParseUtils.TryParseDomain(buffer, ref index, endIndex, sentinels, false, out domain))
{
continue;
}
msgid = localpart + "@" + domain;
// Note: some Message-Id's are broken and in the form "<local-part@domain@domain>"
// https://github.com/jstedfast/MailKit/issues/138
while (index < endIndex && buffer[index] == (byte)'@')
{
int saved = index;
index++;
if (!ParseUtils.TryParseDomain(buffer, ref index, endIndex, sentinels, false, out domain))
{
index = saved;
break;
}
msgid += "@" + domain;
}
yield return(msgid);
}
else if (!ParseUtils.SkipWord(buffer, ref index, endIndex, false))
{
index++;
}
} while (index < endIndex);
yield break;
}