示例#1
0
文件: lsub.cs 项目: bacome/imapclient
                public bool Process(cBytesCursor pCursor, out cResponseData rResponseData, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cResponseDataParserLSub), nameof(Process));

                    if (!pCursor.SkipBytes(kLSubSpace))
                    {
                        rResponseData = null; return(false);
                    }

                    if (!pCursor.GetFlags(out var lFlags) ||
                        !pCursor.SkipByte(cASCII.SPACE) ||
                        !pCursor.GetMailboxDelimiter(out var lDelimiter) ||
                        !pCursor.SkipByte(cASCII.SPACE) ||
                        !pCursor.GetAString(out IList <byte> lEncodedMailboxPath) ||
                        !pCursor.Position.AtEnd ||
                        !cMailboxName.TryConstruct(lEncodedMailboxPath, lDelimiter, mUTF8Enabled, out var lMailboxName))
                    {
                        lContext.TraceWarning("likely malformed lsub response");
                        rResponseData = null;
                        return(true);
                    }

                    rResponseData = new cResponseDataLSub(lMailboxName, !lFlags.Contains(@"\Noselect", StringComparer.InvariantCultureIgnoreCase));
                    return(true);
                }
示例#2
0
        private static void _Tests_MailboxName(string pMailboxPath, bool pExpectFail, cTrace.cContext pParentContext)
        {
            var lContext = pParentContext.NewMethod(nameof(cMailboxName), nameof(_Tests_MailboxName), pMailboxPath);

            cCommandPartFactory lFactory;
            cCommandPart        lCommandPart;
            cBytesCursor        lCursor;
            IList <byte>        lEncodedMailboxPath;
            cMailboxName        lMailboxName;

            lFactory = new cCommandPartFactory(false, null);

            if (!lFactory.TryAsMailbox(pMailboxPath, '/', out lCommandPart, out _))
            {
                throw new cTestsException($"mailboxname conversion failed on '{pMailboxPath}'");
            }
            cTextCommandPart lTCP = lCommandPart as cTextCommandPart;

            lCursor = new cBytesCursor(lTCP.Bytes);
            lCursor.GetAString(out lEncodedMailboxPath);

            if (cMailboxName.TryConstruct(lEncodedMailboxPath, cASCII.SLASH, false, out lMailboxName))
            {
                if (pExpectFail)
                {
                    throw new cTestsException($"mailboxname construction succeeded on '{pMailboxPath}' and it shouldn't have");
                }
            }
            else
            {
                if (!pExpectFail)
                {
                    throw new cTestsException($"mailboxname construction failed on '{pMailboxPath}' and it shouldn't have");
                }
                return;
            }

            if (lMailboxName.Path != pMailboxPath)
            {
                throw new cTestsException($"mailboxname conversion failed on '{pMailboxPath}' -> {lTCP.Bytes} -> '{lMailboxName}'", lContext);
            }

            lFactory = new cCommandPartFactory(true, null);
            lFactory.TryAsMailbox(pMailboxPath, '/', out lCommandPart, out _);
            lTCP    = lCommandPart as cTextCommandPart;
            lCursor = new cBytesCursor(lTCP.Bytes);
            lCursor.GetAString(out lEncodedMailboxPath);
            cMailboxName.TryConstruct(lEncodedMailboxPath, cASCII.SLASH, true, out lMailboxName);
            if (lMailboxName.Path != pMailboxPath)
            {
                throw new cTestsException($"mailboxname conversion failed on '{pMailboxPath}' -> {lTCP.Bytes} -> '{lMailboxName}'", lContext);
            }
        }
示例#3
0
                public bool Process(cBytesCursor pCursor, out cResponseData rResponseData, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cResponseDataParserList), nameof(Process));

                    if (!pCursor.SkipBytes(kListSpace))
                    {
                        rResponseData = null; return(false);
                    }

                    if (!pCursor.GetFlags(out var lFlags) ||
                        !pCursor.SkipByte(cASCII.SPACE) ||
                        !pCursor.GetMailboxDelimiter(out var lDelimiter) ||
                        !pCursor.SkipByte(cASCII.SPACE) ||
                        !pCursor.GetAString(out IList <byte> lEncodedMailboxPath) ||
                        !ZProcessExtendedItems(pCursor, out var lExtendedItems) ||
                        !pCursor.Position.AtEnd)
                    {
                        lContext.TraceWarning("likely malformed list response");
                        rResponseData = null;
                        return(true);
                    }

                    if (lEncodedMailboxPath.Count == 0)
                    {
                        if (lFlags.Count == 0 && lExtendedItems.Count == 0)
                        {
                            if (lDelimiter == null)
                            {
                                rResponseData = new cResponseDataListDelimiter();
                            }
                            else
                            {
                                rResponseData = new cResponseDataListDelimiter((char)lDelimiter.Value);
                            }
                        }
                        else
                        {
                            lContext.TraceWarning("likely malformed list delimiter response");
                            rResponseData = null;
                        }
                    }
                    else
                    {
                        if (cMailboxName.TryConstruct(lEncodedMailboxPath, lDelimiter, mUTF8Enabled, out var lMailboxName))
                        {
                            fListFlags lListFlags = 0;

                            if (lFlags.Contains(@"\Noinferiors", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.noinferiors | fListFlags.hasnochildren;
                            }
                            if (lFlags.Contains(@"\Noselect", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.noselect;
                            }
                            if (lFlags.Contains(@"\Marked", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.marked;
                            }
                            if (lFlags.Contains(@"\Unmarked", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.unmarked;
                            }

                            if (lFlags.Contains(@"\NonExistent", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.noselect | fListFlags.nonexistent;
                            }
                            if (lFlags.Contains(@"\Subscribed", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.subscribed;
                            }
                            if (lFlags.Contains(@"\Remote", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.remote;
                            }
                            if (lFlags.Contains(@"\HasChildren", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.haschildren;
                            }
                            if (lFlags.Contains(@"\HasNoChildren", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.hasnochildren;
                            }

                            if (lFlags.Contains(@"\All", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.all;
                            }
                            if (lFlags.Contains(@"\Archive", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.archive;
                            }
                            if (lFlags.Contains(@"\Drafts", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.drafts;
                            }
                            if (lFlags.Contains(@"\Flagged", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.flagged;
                            }
                            if (lFlags.Contains(@"\Junk", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.junk;
                            }
                            if (lFlags.Contains(@"\Sent", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.sent;
                            }
                            if (lFlags.Contains(@"\Trash", StringComparer.InvariantCultureIgnoreCase))
                            {
                                lListFlags |= fListFlags.trash;
                            }

                            bool lHasSubscribedChildren = false;

                            foreach (var lItem in lExtendedItems)
                            {
                                if (lItem.Tag.Equals("childinfo", StringComparison.InvariantCultureIgnoreCase) && lItem.Value.Contains("subscribed", StringComparison.InvariantCultureIgnoreCase))
                                {
                                    lHasSubscribedChildren = true;
                                    break;
                                }
                            }

                            rResponseData = new cResponseDataListMailbox(lMailboxName, lListFlags, lHasSubscribedChildren);
                        }
                        else
                        {
                            lContext.TraceWarning("likely malformed list mailbox response");
                            rResponseData = null;
                        }
                    }

                    return(true);
                }