static MessageThread ParseThread (ImapEngine engine, uint uidValidity, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
MessageThread thread, node, child;
uint uid;
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out uid))
throw ImapEngine.UnexpectedToken (token, false);
node = thread = new MessageThread (new UniqueId (uidValidity, uid));
do {
token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
if (token.Type == ImapTokenType.OpenParen) {
child = ParseThread (engine, uidValidity, cancellationToken);
node.Children.Add (child);
} else {
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out uid))
throw ImapEngine.UnexpectedToken (token, false);
child = new MessageThread (new UniqueId (uidValidity, uid));
node.Children.Add (child);
node = child;
}
} while (true);
return thread;
}
static void SearchMatches (ImapEngine engine, ImapCommand ic, int index)
{
var results = new SearchResults ();
var uids = new List<UniqueId> ();
ImapToken token;
ulong modseq;
uint uid;
do {
token = engine.PeekToken (ic.CancellationToken);
// keep reading UIDs until we get to the end of the line or until we get a "(MODSEQ ####)"
if (token.Type == ImapTokenType.Eoln || token.Type == ImapTokenType.OpenParen)
break;
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out uid) || uid == 0)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "SEARCH", token);
uids.Add (new UniqueId (ic.Folder.UidValidity, uid));
} while (true);
if (token.Type == ImapTokenType.OpenParen) {
engine.ReadToken (ic.CancellationToken);
do {
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
if (token.Type != ImapTokenType.Atom)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "SEARCH", token);
var atom = (string) token.Value;
switch (atom) {
case "MODSEQ":
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !ulong.TryParse ((string) token.Value, out modseq)) {
Debug.WriteLine ("Expected 64-bit nz-number as the MODSEQ value, but got: {0}", token);
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
}
break;
}
token = engine.PeekToken (ic.CancellationToken);
} while (token.Type != ImapTokenType.Eoln);
}
results.UniqueIds = uids;
ic.UserData = results;
}
internal void OnFetch (ImapEngine engine, int index, CancellationToken cancellationToken)
{
var labels = new MessageLabelsChangedEventArgs (index);
var flags = new MessageFlagsChangedEventArgs (index);
var token = engine.ReadToken (cancellationToken);
bool labelsChanged = false;
bool flagsChanged = false;
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
do {
token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.CloseParen || token.Type == ImapTokenType.Eoln)
break;
if (token.Type != ImapTokenType.Atom)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
var atom = (string) token.Value;
ulong modseq;
uint uid;
switch (atom) {
case "MODSEQ":
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.Atom || !ulong.TryParse ((string) token.Value, out modseq))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
labels.ModSeq = modseq;
flags.ModSeq = modseq;
break;
case "UID":
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out uid) || uid == 0)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
labels.UniqueId = new UniqueId (UidValidity, uid);
flags.UniqueId = new UniqueId (UidValidity, uid);
break;
case "FLAGS":
flags.Flags = ImapUtils.ParseFlagsList (engine, atom, flags.UserFlags, cancellationToken);
flagsChanged = true;
break;
case "X-GM-LABELS":
labels.Labels = ImapUtils.ParseLabelsList (engine, cancellationToken);
labelsChanged = true;
break;
default:
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
}
} while (true);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
if (flagsChanged)
OnMessageFlagsChanged (flags);
if (labelsChanged)
OnMessageLabelsChanged (labels);
}
static void UntaggedQuota (ImapEngine engine, ImapCommand ic, int index)
{
string format = string.Format (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "QUOTA", "{0}");
var encodedName = ReadStringToken (engine, format, ic.CancellationToken);
ImapFolder quotaRoot;
FolderQuota quota;
if (!engine.GetCachedFolder (encodedName, out quotaRoot)) {
// Note: this shouldn't happen because the quota root should
// be one of the parent folders which will all have been added
// to the folder cache by this point.
}
ic.UserData = quota = new FolderQuota (quotaRoot);
var token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (format, token);
while (token.Type != ImapTokenType.CloseParen) {
uint used, limit;
string resource;
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom)
throw ImapEngine.UnexpectedToken (format, token);
resource = (string) token.Value;
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out used))
throw ImapEngine.UnexpectedToken (format, token);
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out limit))
throw ImapEngine.UnexpectedToken (format, token);
switch (resource.ToUpperInvariant ()) {
case "MESSAGE":
quota.CurrentMessageCount = used;
quota.MessageLimit = limit;
break;
case "STORAGE":
quota.CurrentStorageSize = used;
quota.StorageLimit = limit;
break;
}
token = engine.PeekToken (ic.CancellationToken);
}
// read the closing paren
engine.ReadToken (ic.CancellationToken);
}
void FetchSummaryItems (ImapEngine engine, ImapCommand ic, int index)
{
var token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
var ctx = (FetchSummaryContext) ic.UserData;
IMessageSummary isummary;
MessageSummary summary;
if (!ctx.Results.TryGetValue (index, out isummary)) {
summary = new MessageSummary (index);
ctx.Results.Add (index, summary);
} else {
summary = (MessageSummary) isummary;
}
do {
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.CloseParen || token.Type == ImapTokenType.Eoln)
break;
if (token.Type != ImapTokenType.Atom)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
var atom = (string) token.Value;
string format;
ulong value64;
uint value;
int idx;
switch (atom) {
case "INTERNALDATE":
token = engine.ReadToken (ic.CancellationToken);
switch (token.Type) {
case ImapTokenType.QString:
case ImapTokenType.Atom:
summary.InternalDate = ImapUtils.ParseInternalDate ((string) token.Value);
break;
case ImapTokenType.Nil:
summary.InternalDate = null;
break;
default:
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
}
summary.Fields |= MessageSummaryItems.InternalDate;
break;
case "RFC822.SIZE":
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out value))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
summary.Fields |= MessageSummaryItems.MessageSize;
summary.Size = value;
break;
case "BODYSTRUCTURE":
format = string.Format (ImapEngine.GenericItemSyntaxErrorFormat, "BODYSTRUCTURE", "{0}");
summary.Body = ImapUtils.ParseBody (engine, format, string.Empty, ic.CancellationToken);
summary.Fields |= MessageSummaryItems.BodyStructure;
break;
case "BODY":
token = engine.PeekToken (ic.CancellationToken);
if (token.Type == ImapTokenType.OpenBracket) {
// consume the '['
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.OpenBracket)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
// References and/or other headers were requested...
do {
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.CloseBracket)
break;
if (token.Type == ImapTokenType.OpenParen) {
do {
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
// the header field names will generally be atoms or qstrings but may also be literals
switch (token.Type) {
case ImapTokenType.Literal:
engine.ReadLiteral (ic.CancellationToken);
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
break;
default:
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
}
} while (true);
} else if (token.Type != ImapTokenType.Atom) {
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
}
} while (true);
if (token.Type != ImapTokenType.CloseBracket)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Literal)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
summary.References = new MessageIdList ();
try {
summary.Headers = engine.ParseHeaders (engine.Stream, ic.CancellationToken);
} catch (FormatException) {
// consume any remaining literal data...
ReadLiteralData (engine, ic.CancellationToken);
summary.Headers = new HeaderList ();
}
if ((idx = summary.Headers.IndexOf (HeaderId.References)) != -1) {
var references = summary.Headers[idx];
var rawValue = references.RawValue;
foreach (var msgid in MimeUtils.EnumerateReferences (rawValue, 0, rawValue.Length))
summary.References.Add (msgid);
}
summary.Fields |= MessageSummaryItems.References;
} else {
summary.Fields |= MessageSummaryItems.Body;
try {
format = string.Format (ImapEngine.GenericItemSyntaxErrorFormat, "BODY", "{0}");
summary.Body = ImapUtils.ParseBody (engine, format, string.Empty, ic.CancellationToken);
} catch (ImapProtocolException ex) {
if (!ex.UnexpectedToken)
throw;
// Note: GMail's IMAP implementation sometimes replies with completely broken BODY values
// (see issue #32 for the `BODY ("ALTERNATIVE")` example), so to work around this nonsense,
// we need to drop the remainder of this line.
do {
token = engine.PeekToken (ic.CancellationToken);
if (token.Type == ImapTokenType.Eoln)
break;
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.Literal)
ReadLiteralData (engine, ic.CancellationToken);
} while (true);
return;
}
}
break;
case "ENVELOPE":
summary.Envelope = ImapUtils.ParseEnvelope (engine, ic.CancellationToken);
summary.Fields |= MessageSummaryItems.Envelope;
break;
case "FLAGS":
summary.Flags = ImapUtils.ParseFlagsList (engine, atom, summary.UserFlags, ic.CancellationToken);
summary.Fields |= MessageSummaryItems.Flags;
break;
case "MODSEQ":
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !ulong.TryParse ((string) token.Value, out value64))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
summary.Fields |= MessageSummaryItems.ModSeq;
summary.ModSeq = value64;
break;
case "UID":
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out value) || value == 0)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
summary.UniqueId = new UniqueId (ic.Folder.UidValidity, value);
summary.Fields |= MessageSummaryItems.UniqueId;
break;
case "X-GM-MSGID":
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !ulong.TryParse ((string) token.Value, out value64) || value64 == 0)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
summary.Fields |= MessageSummaryItems.GMailMessageId;
summary.GMailMessageId = value64;
break;
case "X-GM-THRID":
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !ulong.TryParse ((string) token.Value, out value64) || value64 == 0)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
summary.Fields |= MessageSummaryItems.GMailThreadId;
summary.GMailThreadId = value64;
break;
case "X-GM-LABELS":
summary.GMailLabels = ImapUtils.ParseLabelsList (engine, ic.CancellationToken);
summary.Fields |= MessageSummaryItems.GMailLabels;
break;
default:
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
}
} while (true);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
if ((ctx.RequestedItems & summary.Fields) == ctx.RequestedItems)
OnMessageSummaryFetched (summary);
}
public void TestParseExampleEnvelopeRfc3501 ()
{
const string text = "(\"Wed, 17 Jul 1996 02:23:25 -0700 (PDT)\" \"IMAP4rev1 WG mtg summary and minutes\" ((\"Terry Gray\" NIL \"gray\" \"cac.washington.edu\")) ((\"Terry Gray\" NIL \"gray\" \"cac.washington.edu\")) ((\"Terry Gray\" NIL \"gray\" \"cac.washington.edu\")) ((NIL NIL \"imap\" \"cac.washington.edu\")) ((NIL NIL \"minutes\" \"CNRI.Reston.VA.US\") (\"John Klensin\" NIL \"KLENSIN\" \"MIT.EDU\")) NIL NIL \"<*****@*****.**>\")\r\n";
using (var memory = new MemoryStream (Encoding.ASCII.GetBytes (text), false)) {
using (var tokenizer = new ImapStream (memory, null, new NullProtocolLogger ())) {
using (var engine = new ImapEngine (null)) {
Envelope envelope;
engine.SetStream (tokenizer);
try {
envelope = ImapUtils.ParseEnvelope (engine, CancellationToken.None);
} catch (Exception ex) {
Assert.Fail ("Parsing ENVELOPE failed: {0}", ex);
return;
}
var token = engine.ReadToken (CancellationToken.None);
Assert.AreEqual (ImapTokenType.Eoln, token.Type, "Expected new-line, but got: {0}", token);
Assert.IsTrue (envelope.Date.HasValue, "Parsed ENVELOPE date is null.");
Assert.AreEqual ("Wed, 17 Jul 1996 02:23:25 -0700", DateUtils.FormatDate (envelope.Date.Value), "Date does not match.");
Assert.AreEqual ("IMAP4rev1 WG mtg summary and minutes", envelope.Subject, "Subject does not match.");
Assert.AreEqual (1, envelope.From.Count, "From counts do not match.");
Assert.AreEqual ("\"Terry Gray\" <*****@*****.**>", envelope.From.ToString (), "From does not match.");
Assert.AreEqual (1, envelope.Sender.Count, "Sender counts do not match.");
Assert.AreEqual ("\"Terry Gray\" <*****@*****.**>", envelope.Sender.ToString (), "Sender does not match.");
Assert.AreEqual (1, envelope.ReplyTo.Count, "Reply-To counts do not match.");
Assert.AreEqual ("\"Terry Gray\" <*****@*****.**>", envelope.ReplyTo.ToString (), "Reply-To does not match.");
Assert.AreEqual (1, envelope.To.Count, "To counts do not match.");
Assert.AreEqual ("*****@*****.**", envelope.To.ToString (), "To does not match.");
Assert.AreEqual (2, envelope.Cc.Count, "Cc counts do not match.");
Assert.AreEqual ("[email protected], \"John Klensin\" <*****@*****.**>", envelope.Cc.ToString (), "Cc does not match.");
Assert.AreEqual (0, envelope.Bcc.Count, "Bcc counts do not match.");
Assert.IsNull (envelope.InReplyTo, "In-Reply-To is not null.");
Assert.AreEqual ("*****@*****.**", envelope.MessageId, "Message-Id does not match.");
}
}
}
}
public void TestParseExampleThreads ()
{
const string text = "(2)(3 6 (4 23)(44 7 96))\r\n";
using (var memory = new MemoryStream (Encoding.ASCII.GetBytes (text), false)) {
using (var tokenizer = new ImapStream (memory, null, new NullProtocolLogger ())) {
using (var engine = new ImapEngine (null)) {
IList<MessageThread> threads;
engine.SetStream (tokenizer);
try {
threads = ImapUtils.ParseThreads (engine, 0, CancellationToken.None);
} catch (Exception ex) {
Assert.Fail ("Parsing THREAD response failed: {0}", ex);
return;
}
var token = engine.ReadToken (CancellationToken.None);
Assert.AreEqual (ImapTokenType.Eoln, token.Type, "Expected new-line, but got: {0}", token);
Assert.AreEqual (2, threads.Count, "Expected 2 threads.");
Assert.AreEqual ((uint) 2, threads[0].UniqueId.Value.Id);
Assert.AreEqual ((uint) 3, threads[1].UniqueId.Value.Id);
var branches = threads[1].Children.ToArray ();
Assert.AreEqual (1, branches.Length, "Expected 1 child.");
Assert.AreEqual ((uint) 6, branches[0].UniqueId.Value.Id);
branches = branches[0].Children.ToArray ();
Assert.AreEqual (2, branches.Length, "Expected 2 branches.");
Assert.AreEqual ((uint) 4, branches[0].UniqueId.Value.Id);
Assert.AreEqual ((uint) 44, branches[1].UniqueId.Value.Id);
var children = branches[0].Children.ToArray ();
Assert.AreEqual (1, children.Length, "Expected 1 child.");
Assert.AreEqual ((uint) 23, children[0].UniqueId.Value.Id);
Assert.AreEqual (0, children[0].Children.Count (), "Expected no children.");
children = branches[1].Children.ToArray ();
Assert.AreEqual (1, children.Length, "Expected 1 child.");
Assert.AreEqual ((uint) 7, children[0].UniqueId.Value.Id);
children = children[0].Children.ToArray ();
Assert.AreEqual (1, children.Length, "Expected 1 child.");
Assert.AreEqual ((uint) 96, children[0].UniqueId.Value.Id);
Assert.AreEqual (0, children[0].Children.Count (), "Expected no children.");
}
}
}
}
static void ParseParameterList (StringBuilder builder, ImapEngine engine, CancellationToken cancellationToken)
{
ImapToken token;
do {
token = engine.PeekToken (cancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
var name = ReadStringToken (engine, cancellationToken);
// Note: technically, the value should also be a 'string' token and not an 'nstring',
// but issue #124 reveals a server that is sending NIL for boundary values.
var value = ReadNStringToken (engine, false, cancellationToken) ?? string.Empty;
builder.Append ("; ").Append (name).Append ('=');
if (NeedsQuoting (value))
builder.Append (MimeUtils.Quote (value));
else
builder.Append (value);
} while (true);
// read the ')'
engine.ReadToken (cancellationToken);
}
static bool ParseContentType (ImapEngine engine, CancellationToken cancellationToken, out ContentType contentType, out string value)
{
var type = ReadNStringToken (engine, false, cancellationToken) ?? string.Empty;
var token = engine.PeekToken (cancellationToken);
value = null;
if (engine.IsGMail && token.Type == ImapTokenType.OpenParen) {
// Note: GMail's IMAP server implementation breaks when it encounters
// nested multiparts with the same boundary and returns a BODYSTRUCTURE
// like the example in https://github.com/jstedfast/MailKit/issues/205
contentType = null;
value = type;
return false;
}
var subtype = ReadNStringToken (engine, false, cancellationToken) ?? string.Empty;
token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.Nil) {
contentType = new ContentType (type, subtype);
return true;
}
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
var builder = new StringBuilder ();
builder.AppendFormat ("{0}/{1}", type, subtype);
ParseParameterList (builder, engine, cancellationToken);
if (!ContentType.TryParse (builder.ToString (), out contentType))
contentType = new ContentType (type, subtype);
return true;
}
static string ReadNStringToken (ImapEngine engine, bool rfc2047, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
string value;
switch (token.Type) {
case ImapTokenType.Literal:
value = engine.ReadLiteral (cancellationToken);
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
value = (string) token.Value;
break;
case ImapTokenType.Nil:
return null;
default:
throw ImapEngine.UnexpectedToken (token, false);
}
return rfc2047 ? Rfc2047.DecodeText (Latin1.GetBytes (value)) : value;
}
static uint ReadNumber (ImapEngine engine, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
uint number;
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out number))
throw ImapEngine.UnexpectedToken (token, false);
return number;
}
/// <summary>
/// Parses an untagged LIST or LSUB response.
/// </summary>
/// <param name="engine">The IMAP engine.</param>
/// <param name="ic">The IMAP command.</param>
/// <param name="index">The index.</param>
public static void ParseFolderList (ImapEngine engine, ImapCommand ic, int index)
{
var token = engine.ReadToken (ic.CancellationToken);
var list = (List<ImapFolder>) ic.UserData;
var attrs = FolderAttributes.None;
string encodedName;
ImapFolder folder;
char delim;
// parse the folder attributes list
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
token = engine.ReadToken (ic.CancellationToken);
while (token.Type == ImapTokenType.Flag || token.Type == ImapTokenType.Atom) {
string atom = (string) token.Value;
switch (atom) {
case "\\NoInferiors": attrs |= FolderAttributes.NoInferiors; break;
case "\\Noselect": attrs |= FolderAttributes.NoSelect; break;
case "\\Marked": attrs |= FolderAttributes.Marked; break;
case "\\Unmarked": attrs |= FolderAttributes.Unmarked; break;
case "\\NonExistent": attrs |= FolderAttributes.NonExistent; break;
case "\\Subscribed": attrs |= FolderAttributes.Subscribed; break;
case "\\Remote": attrs |= FolderAttributes.Remote; break;
case "\\HasChildren": attrs |= FolderAttributes.HasChildren; break;
case "\\HasNoChildren": attrs |= FolderAttributes.HasNoChildren; break;
case "\\All": attrs |= FolderAttributes.All; break;
case "\\Archive": attrs |= FolderAttributes.Archive; break;
case "\\Drafts": attrs |= FolderAttributes.Drafts; break;
case "\\Flagged": attrs |= FolderAttributes.Flagged; break;
case "\\Junk": attrs |= FolderAttributes.Junk; break;
case "\\Sent": attrs |= FolderAttributes.Sent; break;
case "\\Trash": attrs |= FolderAttributes.Trash; break;
// XLIST flags:
case "\\AllMail": attrs |= FolderAttributes.All; break;
case "\\Important": attrs |= FolderAttributes.Flagged; break;
case "\\Inbox": attrs |= FolderAttributes.Inbox; break;
case "\\Spam": attrs |= FolderAttributes.Junk; break;
case "\\Starred": attrs |= FolderAttributes.Flagged; break;
}
token = engine.ReadToken (ic.CancellationToken);
}
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (token, false);
// parse the path delimeter
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.QString) {
var qstring = (string) token.Value;
delim = qstring[0];
} else if (token.Type == ImapTokenType.Nil) {
delim = '\0';
} else {
throw ImapEngine.UnexpectedToken (token, false);
}
// parse the folder name
token = engine.ReadToken (ImapStream.StringSpecials, ic.CancellationToken);
switch (token.Type) {
case ImapTokenType.Literal:
encodedName = engine.ReadLiteral (ic.CancellationToken);
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
encodedName = (string) token.Value;
break;
default:
throw ImapEngine.UnexpectedToken (token, false);
}
if (IsInbox (encodedName))
attrs |= FolderAttributes.Inbox;
if (engine.GetCachedFolder (encodedName, out folder)) {
attrs |= (folder.Attributes & ~(FolderAttributes.Marked | FolderAttributes.Unmarked));
folder.UpdateAttributes (attrs);
} else {
folder = engine.CreateImapFolder (encodedName, attrs, delim);
engine.CacheFolder (folder);
}
list.Add (folder);
}
/// <summary>
/// Parses an untagged ID response.
/// </summary>
/// <param name="engine">The IMAP engine.</param>
/// <param name="ic">The IMAP command.</param>
/// <param name="index">The index.</param>
public static void ParseImplementation (ImapEngine engine, ImapCommand ic, int index)
{
var token = engine.ReadToken (ic.CancellationToken);
var implementation = new ImapImplementation ();
ic.UserData = implementation;
if (token.Type == ImapTokenType.Nil)
return;
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
token = engine.PeekToken (ic.CancellationToken);
while (token.Type != ImapTokenType.CloseParen) {
var property = ImapUtils.ReadStringToken (engine, ic.CancellationToken);
var value = ImapUtils.ReadNStringToken (engine, false, ic.CancellationToken);
implementation.Properties[property] = value;
token = engine.PeekToken (ic.CancellationToken);
}
// read the ')' token
engine.ReadToken (ic.CancellationToken);
}
/// <summary>
/// Parses the threads.
/// </summary>
/// <returns>The threads.</returns>
/// <param name="engine">The IMAP engine.</param>
/// <param name="uidValidity">The UIDVALIDITY of the folder.</param>
/// <param name="cancellationToken">The cancellation token.</param>
public static IList<MessageThread> ParseThreads (ImapEngine engine, uint uidValidity, CancellationToken cancellationToken)
{
var threads = new List<MessageThread> ();
ImapToken token;
do {
token = engine.PeekToken (cancellationToken);
if (token.Type == ImapTokenType.Eoln)
break;
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
threads.Add (ParseThread (engine, uidValidity, cancellationToken));
} while (true);
return threads;
}
public void TestParseLabelsListWithNIL ()
{
const string text = "(atom-label \\flag-label \"quoted-label\" NIL)\r\n";
using (var memory = new MemoryStream (Encoding.ASCII.GetBytes (text), false)) {
using (var tokenizer = new ImapStream (memory, null, new NullProtocolLogger ())) {
using (var engine = new ImapEngine (null)) {
IList<string> labels;
engine.SetStream (tokenizer);
try {
labels = ImapUtils.ParseLabelsList (engine, CancellationToken.None);
} catch (Exception ex) {
Assert.Fail ("Parsing X-GM-LABELS failed: {0}", ex);
return;
}
var token = engine.ReadToken (CancellationToken.None);
Assert.AreEqual (ImapTokenType.Eoln, token.Type, "Expected new-line, but got: {0}", token);
}
}
}
}
static ContentDisposition ParseContentDisposition (ImapEngine engine, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.Nil)
return null;
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
var dsp = ReadStringToken (engine, cancellationToken);
var builder = new StringBuilder (dsp);
ContentDisposition disposition;
token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.OpenParen)
ParseParameterList (builder, engine, cancellationToken);
else if (token.Type != ImapTokenType.Nil)
throw ImapEngine.UnexpectedToken (token, false);
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (token, false);
if (!ContentDisposition.TryParse (builder.ToString (), out disposition))
disposition = new ContentDisposition (dsp);
return disposition;
}
public void TestParseExampleBodyRfc3501 ()
{
const string text = "(\"TEXT\" \"PLAIN\" (\"CHARSET\" \"US-ASCII\") NIL NIL \"7BIT\" 3028 92)\r\n";
using (var memory = new MemoryStream (Encoding.ASCII.GetBytes (text), false)) {
using (var tokenizer = new ImapStream (memory, null, new NullProtocolLogger ())) {
using (var engine = new ImapEngine (null)) {
BodyPartText basic;
BodyPart body;
engine.SetStream (tokenizer);
try {
body = ImapUtils.ParseBody (engine, "Unexpected token: {0}", string.Empty, CancellationToken.None);
} catch (Exception ex) {
Assert.Fail ("Parsing BODY failed: {0}", ex);
return;
}
var token = engine.ReadToken (CancellationToken.None);
Assert.AreEqual (ImapTokenType.Eoln, token.Type, "Expected new-line, but got: {0}", token);
Assert.IsInstanceOf<BodyPartText> (body, "Body types did not match.");
basic = (BodyPartText) body;
Assert.IsTrue (body.ContentType.IsMimeType ("text", "plain"), "Content-Type did not match.");
Assert.AreEqual ("US-ASCII", body.ContentType.Parameters["charset"], "charset param did not match");
Assert.IsNotNull (basic, "The parsed body is not BodyPartText.");
Assert.AreEqual ("7BIT", basic.ContentTransferEncoding, "Content-Transfer-Encoding did not match.");
Assert.AreEqual (3028, basic.Octets, "Octet count did not match.");
Assert.AreEqual (92, basic.Lines, "Line count did not match.");
}
}
}
}
static string[] ParseContentLanguage (ImapEngine engine, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
var languages = new List<string> ();
string language;
switch (token.Type) {
case ImapTokenType.Literal:
language = engine.ReadLiteral (cancellationToken);
languages.Add (language);
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
language = (string) token.Value;
languages.Add (language);
break;
case ImapTokenType.Nil:
return null;
case ImapTokenType.OpenParen:
do {
token = engine.PeekToken (cancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
language = ReadStringToken (engine, cancellationToken);
languages.Add (language);
} while (true);
// read the ')'
engine.ReadToken (cancellationToken);
break;
default:
throw ImapEngine.UnexpectedToken (token, false);
}
return languages.ToArray ();
}
public void TestParseExampleMultiLevelDovecotBodyStructure ()
{
const string text = "(((\"text\" \"plain\" (\"charset\" \"iso-8859-2\") NIL NIL \"quoted-printable\" 28 2 NIL NIL NIL NIL) (\"text\" \"html\" (\"charset\" \"iso-8859-2\") NIL NIL \"quoted-printable\" 1707 65 NIL NIL NIL NIL) \"alternative\" (\"boundary\" \"----=_NextPart_001_0078_01CBB179.57530990\") NIL NIL NIL) (\"message\" \"rfc822\" NIL NIL NIL \"7bit\" 641 (\"Sat, 8 Jan 2011 14:16:36 +0100\" \"Subj 2\" ((\"Some Name, SOMECOMPANY\" NIL \"recipient\" \"example.com\")) ((\"Some Name, SOMECOMPANY\" NIL \"recipient\" \"example.com\")) ((\"Some Name, SOMECOMPANY\" NIL \"recipient\" \"example.com\")) ((\"Recipient\" NIL \"example\" \"gmail.com\")) NIL NIL NIL NIL) (\"text\" \"plain\" (\"charset\" \"iso-8859-2\") NIL NIL \"quoted-printable\" 185 18 NIL NIL (\"cs\") NIL) 31 NIL (\"attachment\" NIL) NIL NIL) (\"message\" \"rfc822\" NIL NIL NIL \"7bit\" 50592 (\"Sat, 8 Jan 2011 13:58:39 +0100\" \"Subj 1\" ((\"Some Name, SOMECOMPANY\" NIL \"recipient\" \"example.com\")) ((\"Some Name, SOMECOMPANY\" NIL \"recipient\" \"example.com\")) ((\"Some Name, SOMECOMPANY\" NIL \"recipient\" \"example.com\")) ((\"Recipient\" NIL \"example\" \"gmail.com\")) NIL NIL NIL NIL) ( (\"text\" \"plain\" (\"charset\" \"iso-8859-2\") NIL NIL \"quoted-printable\" 4296 345 NIL NIL NIL NIL) (\"text\" \"html\" (\"charset\" \"iso-8859-2\") NIL NIL \"quoted-printable\" 45069 1295 NIL NIL NIL NIL) \"alternative\" (\"boundary\" \"----=_NextPart_000_0073_01CBB179.57530990\") NIL (\"cs\") NIL) 1669 NIL (\"attachment\" NIL) NIL NIL) \"mixed\" (\"boundary\" \"----=_NextPart_000_0077_01CBB179.57530990\") NIL (\"cs\") NIL)\r\n";
using (var memory = new MemoryStream (Encoding.ASCII.GetBytes (text), false)) {
using (var tokenizer = new ImapStream (memory, null, new NullProtocolLogger ())) {
using (var engine = new ImapEngine (null)) {
BodyPartMultipart multipart;
BodyPart body;
engine.SetStream (tokenizer);
try {
body = ImapUtils.ParseBody (engine, "Unexpected token: {0}", string.Empty, CancellationToken.None);
} catch (Exception ex) {
Assert.Fail ("Parsing BODYSTRUCTURE failed: {0}", ex);
return;
}
var token = engine.ReadToken (CancellationToken.None);
Assert.AreEqual (ImapTokenType.Eoln, token.Type, "Expected new-line, but got: {0}", token);
Assert.IsInstanceOf<BodyPartMultipart> (body, "Body types did not match.");
multipart = (BodyPartMultipart) body;
Assert.IsTrue (body.ContentType.IsMimeType ("multipart", "mixed"), "Content-Type did not match.");
Assert.AreEqual ("----=_NextPart_000_0077_01CBB179.57530990", body.ContentType.Parameters["boundary"], "boundary param did not match");
Assert.AreEqual (3, multipart.BodyParts.Count, "BodyParts count does not match.");
Assert.IsInstanceOf<BodyPartMultipart> (multipart.BodyParts[0], "The type of the first child does not match.");
Assert.IsInstanceOf<BodyPartMessage> (multipart.BodyParts[1], "The type of the second child does not match.");
Assert.IsInstanceOf<BodyPartMessage> (multipart.BodyParts[2], "The type of the third child does not match.");
// FIXME: assert more stuff?
}
}
}
}
static void SkipBodyExtensions (ImapEngine engine, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
switch (token.Type) {
case ImapTokenType.OpenParen:
do {
token = engine.PeekToken (cancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
SkipBodyExtensions (engine, cancellationToken);
} while (true);
// read the ')'
engine.ReadToken (cancellationToken);
break;
case ImapTokenType.Literal:
engine.ReadLiteral (cancellationToken);
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
case ImapTokenType.Nil:
break;
default:
throw ImapEngine.UnexpectedToken (token, false);
}
}
static string ReadStringToken (ImapEngine engine, string format, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
switch (token.Type) {
case ImapTokenType.Literal: return engine.ReadLiteral (cancellationToken);
case ImapTokenType.QString: return (string) token.Value;
case ImapTokenType.Atom: return (string) token.Value;
default:
throw ImapEngine.UnexpectedToken (format, token);
}
}
static BodyPart ParseMultipart (ImapEngine engine, string path, string subtype, CancellationToken cancellationToken)
{
var prefix = path.Length > 0 ? path + "." : string.Empty;
var body = new BodyPartMultipart ();
ImapToken token;
int index = 1;
// Note: if subtype is not null, then we are working around a GMail bug...
if (subtype == null) {
do {
body.BodyParts.Add (ParseBody (engine, prefix + index, cancellationToken));
token = engine.PeekToken (cancellationToken);
index++;
} while (token.Type == ImapTokenType.OpenParen);
subtype = ReadStringToken (engine, cancellationToken);
}
body.ContentType = new ContentType ("multipart", subtype);
body.PartSpecifier = path;
token = engine.PeekToken (cancellationToken);
if (token.Type != ImapTokenType.CloseParen) {
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
var builder = new StringBuilder ();
ContentType contentType;
builder.AppendFormat ("{0}/{1}", body.ContentType.MediaType, body.ContentType.MediaSubtype);
ParseParameterList (builder, engine, cancellationToken);
if (ContentType.TryParse (builder.ToString (), out contentType))
body.ContentType = contentType;
token = engine.PeekToken (cancellationToken);
}
if (token.Type != ImapTokenType.CloseParen) {
body.ContentDisposition = ParseContentDisposition (engine, cancellationToken);
token = engine.PeekToken (cancellationToken);
}
if (token.Type != ImapTokenType.CloseParen) {
body.ContentLanguage = ParseContentLanguage (engine, cancellationToken);
token = engine.PeekToken (cancellationToken);
}
if (token.Type != ImapTokenType.CloseParen) {
body.ContentLocation = ParseContentLocation (engine, cancellationToken);
token = engine.PeekToken (cancellationToken);
}
if (token.Type != ImapTokenType.CloseParen)
SkipBodyExtensions (engine, cancellationToken);
// read the ')'
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (token, false);
return body;
}
static void UntaggedMetadata (ImapEngine engine, ImapCommand ic, int index)
{
string format = string.Format (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "METADATA", "{0}");
var encodedName = ReadStringToken (engine, format, ic.CancellationToken);
var metadata = (MetadataCollection) ic.UserData;
ImapFolder folder;
engine.GetCachedFolder (encodedName, out folder);
var token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (format, token);
while (token.Type != ImapTokenType.CloseParen) {
var tag = ReadStringToken (engine, format, ic.CancellationToken);
var value = ReadStringToken (engine, format, ic.CancellationToken);
metadata.Add (new Metadata (MetadataTag.Create (tag), value));
token = engine.PeekToken (ic.CancellationToken);
}
// read the closing paren
engine.ReadToken (ic.CancellationToken);
}
public static BodyPart ParseBody (ImapEngine engine, string path, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.Nil)
return null;
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
token = engine.PeekToken (cancellationToken);
if (token.Type == ImapTokenType.OpenParen)
return ParseMultipart (engine, path, null, cancellationToken);
ContentType type;
string value;
if (!ParseContentType (engine, cancellationToken, out type, out value)) {
// GMail breakage... yay! What we have is a nested multipart with
// the same boundary as its parent.
return ParseMultipart (engine, path, value, cancellationToken);
}
var id = ReadNStringToken (engine, false, cancellationToken);
var desc = ReadNStringToken (engine, true, cancellationToken);
// Note: technically, body-fld-enc, is not allowed to be NIL, but we need to deal with broken servers...
var enc = ReadNStringToken (engine, false, cancellationToken);
var octets = ReadNumber (engine, cancellationToken);
BodyPartBasic body;
if (type.Matches ("message", "rfc822")) {
var mesg = new BodyPartMessage ();
// Note: GMail (and potentially other IMAP servers) will send body-part-basic
// expressions instead of body-part-msg expressions when they encounter
// message/rfc822 MIME parts that are illegally encoded using base64 (or
// quoted-printable?). According to rfc3501, IMAP servers are REQUIRED to
// send body-part-msg expressions for message/rfc822 parts, however, it is
// understandable why GMail (and other IMAP servers?) do what they do in this
// particular case.
//
// For examples, see issue #32 and issue #59.
//
// The workaround is to check for the expected '(' signifying an envelope token.
// If we do not get an '(', then we are likely looking at the Content-MD5 token
// which gets handled below.
token = engine.PeekToken (cancellationToken);
if (token.Type == ImapTokenType.OpenParen) {
mesg.Envelope = ParseEnvelope (engine, cancellationToken);
mesg.Body = ParseBody (engine, path, cancellationToken);
mesg.Lines = ReadNumber (engine, cancellationToken);
}
body = mesg;
} else if (type.Matches ("text", "*")) {
var text = new BodyPartText ();
text.Lines = ReadNumber (engine, cancellationToken);
body = text;
} else {
body = new BodyPartBasic ();
}
body.ContentTransferEncoding = enc;
body.ContentDescription = desc;
body.PartSpecifier = path;
body.ContentType = type;
body.ContentId = id;
body.Octets = octets;
// if we are parsing a BODYSTRUCTURE, we may get some more tokens before the ')'
token = engine.PeekToken (cancellationToken);
if (token.Type != ImapTokenType.CloseParen) {
body.ContentMd5 = ReadNStringToken (engine, false, cancellationToken);
token = engine.PeekToken (cancellationToken);
}
if (token.Type != ImapTokenType.CloseParen) {
body.ContentDisposition = ParseContentDisposition (engine, cancellationToken);
token = engine.PeekToken (cancellationToken);
}
if (token.Type != ImapTokenType.CloseParen) {
body.ContentLanguage = ParseContentLanguage (engine, cancellationToken);
token = engine.PeekToken (cancellationToken);
}
if (token.Type != ImapTokenType.CloseParen) {
body.ContentLocation = ParseContentLocation (engine, cancellationToken);
token = engine.PeekToken (cancellationToken);
}
if (token.Type != ImapTokenType.CloseParen)
SkipBodyExtensions (engine, cancellationToken);
// read the ')'
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (token, false);
return body;
}
void FetchStream (ImapEngine engine, ImapCommand ic, int index)
{
var token = engine.ReadToken (ic.CancellationToken);
var labels = new MessageLabelsChangedEventArgs (index);
var flags = new MessageFlagsChangedEventArgs (index);
var ctx = (FetchStreamContext) ic.UserData;
var section = new StringBuilder ();
bool labelsChanged = false;
bool flagsChanged = false;
var buf = new byte[4096];
long nread = 0, size = 0;
UniqueId? uid = null;
Stream stream;
int n;
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
do {
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.CloseParen || token.Type == ImapTokenType.Eoln)
break;
if (token.Type != ImapTokenType.Atom)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
var atom = (string) token.Value;
int offset = 0, length;
ulong modseq;
uint value;
switch (atom) {
case "BODY":
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.OpenBracket)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
section.Clear ();
do {
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.CloseBracket)
break;
if (token.Type == ImapTokenType.OpenParen) {
section.Append (" (");
do {
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
// the header field names will generally be atoms or qstrings but may also be literals
switch (token.Type) {
case ImapTokenType.Literal:
section.Append (engine.ReadLiteral (ic.CancellationToken));
section.Append (' ');
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
section.Append ((string) token.Value);
break;
default:
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
}
} while (true);
if (section[section.Length - 1] == ' ')
section.Length--;
section.Append (')');
} else if (token.Type != ImapTokenType.Atom) {
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
} else {
section.Append ((string) token.Value);
}
} while (true);
if (token.Type != ImapTokenType.CloseBracket)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.Atom) {
// this might be a region ("<###>")
var expr = (string) token.Value;
if (expr.Length > 2 && expr[0] == '<' && expr[expr.Length - 1] == '>') {
var region = expr.Substring (1, expr.Length - 2);
int.TryParse (region, out offset);
token = engine.ReadToken (ic.CancellationToken);
}
}
switch (token.Type) {
case ImapTokenType.Literal:
length = (int) token.Value;
size += length;
stream = CreateStream (uid, section.ToString (), offset, length);
try {
while ((n = engine.Stream.Read (buf, 0, buf.Length, ic.CancellationToken)) > 0) {
stream.Write (buf, 0, n);
nread += n;
ctx.Report (nread, size);
}
stream.Position = 0;
} catch {
stream.Dispose ();
throw;
}
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
var buffer = Encoding.UTF8.GetBytes ((string) token.Value);
length = buffer.Length;
nread += length;
size += length;
stream = CreateStream (uid, section.ToString (), offset, length);
try {
stream.Write (buffer, 0, length);
ctx.Report (nread, size);
stream.Position = 0;
} catch {
stream.Dispose ();
throw;
}
break;
case ImapTokenType.Nil:
stream = CreateStream (uid, section.ToString (), offset, 0);
break;
default:
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
}
if (uid.HasValue)
ctx.Sections[section.ToString ()] = CommitStream (stream, uid.Value);
else
ctx.Sections[section.ToString ()] = stream;
break;
case "UID":
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out value) || value == 0)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
uid = new UniqueId (UidValidity, value);
foreach (var key in ctx.Sections.Keys.ToArray ())
ctx.Sections[key] = CommitStream (ctx.Sections[key], uid.Value);
labels.UniqueId = uid.Value;
flags.UniqueId = uid.Value;
break;
case "MODSEQ":
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom || !ulong.TryParse ((string) token.Value, out modseq))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
labels.ModSeq = modseq;
flags.ModSeq = modseq;
break;
case "FLAGS":
// even though we didn't request this piece of information, the IMAP server
// may send it if another client has recently modified the message flags.
flags.Flags = ImapUtils.ParseFlagsList (engine, atom, flags.UserFlags, ic.CancellationToken);
flagsChanged = true;
break;
case "X-GM-LABELS":
// even though we didn't request this piece of information, the IMAP server
// may send it if another client has recently modified the message labels.
labels.Labels = ImapUtils.ParseLabelsList (engine, ic.CancellationToken);
labelsChanged = true;
break;
default:
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
}
} while (true);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "FETCH", token);
if (flagsChanged)
ic.Folder.OnMessageFlagsChanged (flags);
if (labelsChanged)
ic.Folder.OnMessageLabelsChanged (labels);
}
static EnvelopeAddress ParseEnvelopeAddress (ImapEngine engine, CancellationToken cancellationToken)
{
var values = new string[4];
ImapToken token;
int index = 0;
do {
token = engine.ReadToken (cancellationToken);
switch (token.Type) {
case ImapTokenType.Literal:
values[index] = engine.ReadLiteral (cancellationToken);
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
values[index] = (string) token.Value;
break;
case ImapTokenType.Nil:
break;
default:
throw ImapEngine.UnexpectedToken (token, false);
}
index++;
} while (index < 4);
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (token, false);
return new EnvelopeAddress (values);
}
static void ESearchMatches (ImapEngine engine, ImapCommand ic, int index)
{
var token = engine.ReadToken (ic.CancellationToken);
var results = new SearchResults ();
UniqueIdSet uids = null;
//bool uid = false;
uint min, max;
ulong modseq;
string atom;
string tag;
int count;
if (token.Type == ImapTokenType.OpenParen) {
// optional search correlator
do {
token = engine.ReadToken (ic.CancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
if (token.Type != ImapTokenType.Atom)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "ESEARCH", token);
atom = (string) token.Value;
if (atom == "TAG") {
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom && token.Type != ImapTokenType.QString)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "ESEARCH", token);
tag = (string) token.Value;
if (tag != ic.Tag)
throw new ImapProtocolException ("Unexpected TAG value in untagged ESEARCH response: " + tag);
}
} while (true);
token = engine.ReadToken (ic.CancellationToken);
}
if (token.Type == ImapTokenType.Atom && ((string) token.Value) == "UID") {
token = engine.ReadToken (ic.CancellationToken);
//uid = true;
}
do {
if (token.Type == ImapTokenType.Eoln) {
// unget the eoln token
engine.Stream.UngetToken (token);
break;
}
if (token.Type != ImapTokenType.Atom)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "ESEARCH", token);
atom = (string) token.Value;
token = engine.ReadToken (ic.CancellationToken);
if (token.Type != ImapTokenType.Atom)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "ESEARCH", token);
switch (atom) {
case "MODSEQ":
if (!ulong.TryParse ((string) token.Value, out modseq))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
results.ModSeq = modseq;
break;
case "COUNT":
if (!int.TryParse ((string) token.Value, out count))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
results.Count = count;
break;
case "MIN":
if (!uint.TryParse ((string) token.Value, out min))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
results.Min = new UniqueId (ic.Folder.UidValidity, min);
break;
case "MAX":
if (!uint.TryParse ((string) token.Value, out max))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
results.Max = new UniqueId (ic.Folder.UidValidity, max);
break;
case "ALL":
if (!UniqueIdSet.TryParse ((string) token.Value, ic.Folder.UidValidity, out uids))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericItemSyntaxErrorFormat, atom, token);
results.Count = uids.Count;
break;
default:
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "ESEARCH", token);
}
token = engine.ReadToken (ic.CancellationToken);
} while (true);
results.UniqueIds = uids ?? new UniqueIdSet ();
ic.UserData = results;
}
static void ParseEnvelopeAddressList (InternetAddressList list, ImapEngine engine, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.Nil)
return;
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
GroupAddress group = null;
do {
token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
var item = ParseEnvelopeAddress (engine, cancellationToken);
if (item.IsGroupStart && !engine.IsGMail && group == null) {
group = item.ToGroupAddress ();
list.Add (group);
} else if (item.IsGroupEnd) {
group = null;
} else if (group != null) {
group.Members.Add (item.ToMailboxAddress ());
} else {
list.Add (item.ToMailboxAddress ());
}
} while (true);
}
internal void OnVanished (ImapEngine engine, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
UniqueIdSet vanished;
bool earlier = false;
if (token.Type == ImapTokenType.OpenParen) {
do {
token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
if (token.Type != ImapTokenType.Atom)
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "VANISHED", token);
var atom = (string) token.Value;
if (atom == "EARLIER")
earlier = true;
} while (true);
token = engine.ReadToken (cancellationToken);
}
if (token.Type != ImapTokenType.Atom || !UniqueIdSet.TryParse ((string) token.Value, UidValidity, out vanished))
throw ImapEngine.UnexpectedToken (ImapEngine.GenericUntaggedResponseSyntaxErrorFormat, "VANISHED", token);
OnMessagesVanished (new MessagesVanishedEventArgs (vanished, earlier));
}
/// <summary>
/// Parses the X-GM-LABELS list.
/// </summary>
/// <returns>The message labels.</returns>
/// <param name="engine">The IMAP engine.</param>
/// <param name="cancellationToken">The cancellation token.</param>
public static ReadOnlyCollection<string> ParseLabelsList (ImapEngine engine, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
var labels = new List<string> ();
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
// Note: GMail's IMAP implementation is broken and does not quote strings with ']' like it should.
token = engine.ReadToken (ImapStream.GMailLabelSpecials, cancellationToken);
while (token.Type == ImapTokenType.Flag || token.Type == ImapTokenType.Atom || token.Type == ImapTokenType.QString || token.Type == ImapTokenType.Nil) {
// Apparently it's possible to set a NIL label in GMail...
//
// See https://github.com/jstedfast/MailKit/issues/244 for an example.
if (token.Type != ImapTokenType.Nil) {
var label = engine.DecodeMailboxName ((string) token.Value);
labels.Add (label);
} else {
labels.Add (null);
}
token = engine.ReadToken (ImapStream.GMailLabelSpecials, cancellationToken);
}
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (token, false);
return new ReadOnlyCollection<string> (labels);
}