예제 #1
0
        internal cCulturedString(IList <byte> pBytes)
        {
            if (pBytes == null)
            {
                throw new ArgumentNullException(nameof(pBytes));
            }

            if (pBytes.Count == 0)
            {
                Parts = null;
                return;
            }

            cBytesCursor lCursor = new cBytesCursor(pBytes);

            List <cCulturedStringPart> lParts = new List <cCulturedStringPart>();
            cByteList lBytes        = new cByteList();
            bool      lPendingSpace = false;

            while (!lCursor.Position.AtEnd)
            {
                var lBookmark = lCursor.Position;

                if (lCursor.ProcessEncodedWord(out var lString, out var lLanguageTag) && (lCursor.Position.AtEnd || lCursor.SkipByte(cASCII.SPACE)))
                {
                    if (lBytes.Count > 0)
                    {
                        lParts.Add(new cCulturedStringPart(cTools.UTF8BytesToString(lBytes), null));
                        lBytes = new cByteList();
                    }

                    lParts.Add(new cCulturedStringPart(lString, lLanguageTag));

                    lPendingSpace = true;
                }
예제 #2
0
                public override eProcessDataResult ProcessData(cBytesCursor pCursor, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cNamespaceDataProcessor), nameof(ProcessData));

                    if (!pCursor.SkipBytes(kNamespaceSpace))
                    {
                        return(eProcessDataResult.notprocessed);
                    }

                    if (ZProcessData(pCursor, out var lPersonal, lContext) &&
                        pCursor.SkipByte(cASCII.SPACE) &&
                        ZProcessData(pCursor, out var lOtherUsers, lContext) &&
                        pCursor.SkipByte(cASCII.SPACE) &&
                        ZProcessData(pCursor, out var lShared, lContext) &&
                        pCursor.Position.AtEnd
                        )
                    {
                        lContext.TraceVerbose("got namespaces");
                        NamespaceNames = new cNamespaceNames(lPersonal, lOtherUsers, lShared);
                        mSynchroniser.InvokePropertyChanged(nameof(cIMAPClient.Namespaces), lContext);
                        return(eProcessDataResult.processed);
                    }

                    lContext.TraceWarning("likely malformed namespace");
                    return(eProcessDataResult.notprocessed);
                }
예제 #3
0
                public override void ProcessTextCode(eResponseTextContext pTextContext, cByteList pCode, cByteList pArguments, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandHookInitial), nameof(ProcessTextCode), pTextContext, pCode, pArguments);

                    if (pTextContext == eResponseTextContext.greetingok || pTextContext == eResponseTextContext.greetingpreauth || pTextContext == eResponseTextContext.success)
                    {
                        if (pCode.Equals(kCapability))
                        {
                            if (pArguments != null)
                            {
                                cBytesCursor lCursor = new cBytesCursor(pArguments);

                                if (lCursor.ProcessCapability(out var lCapabilities, out var lAuthenticationMechanisms, lContext) && lCursor.Position.AtEnd)
                                {
                                    lContext.TraceVerbose("received capabilities: {0} {1}", lCapabilities, lAuthenticationMechanisms);
                                    Capabilities             = lCapabilities;
                                    AuthenticationMechanisms = lAuthenticationMechanisms;
                                    return;
                                }
                            }

                            lContext.TraceWarning("likely malformed capability response");
                        }
                    }
                }
예제 #4
0
                public override void ProcessTextCode(eResponseTextContext pTextContext, cByteList pCode, cByteList pArguments, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandHookStore), nameof(ProcessTextCode), pTextContext, pCode, pArguments);

                    if (pTextContext == eResponseTextContext.success || pTextContext == eResponseTextContext.failure)
                    {
                        if (pCode.Equals(kModified))
                        {
                            if (pArguments != null)
                            {
                                cBytesCursor lCursor = new cBytesCursor(pArguments);

                                if (lCursor.GetSequenceSet(out var lSequenceSet) && lCursor.Position.AtEnd && cUIntList.TryConstruct(lSequenceSet, mSelectedMailbox.MessageCache.Count, true, out var lUInts))
                                {
                                    foreach (var lUInt in lUInts)
                                    {
                                        if (!mFeedbackCollector.WasNotUnchangedSince(lUInt))
                                        {
                                            lContext.TraceWarning("likely malformed modified response: message number not recognised: ", lUInt);
                                            return;
                                        }
                                    }

                                    return;
                                }
                            }

                            lContext.TraceWarning("likely malformed modified response");
                        }
                    }
                }
예제 #5
0
                public override void ProcessTextCode(eResponseTextContext pTextContext, cByteList pCode, cByteList pArguments, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandHookCopy), nameof(ProcessTextCode), pTextContext, pCode, pArguments);

                    if (pTextContext == eResponseTextContext.success && pCode.Equals(kCopyUID))
                    {
                        if (pArguments != null)
                        {
                            cBytesCursor lCursor = new cBytesCursor(pArguments);

                            if (lCursor.GetNZNumber(out _, out var lDestinationUIDValidity) &&
                                lCursor.SkipByte(cASCII.SPACE) &&
                                lCursor.GetSequenceSet(out var lSourceUIDSet) &&
                                lCursor.SkipByte(cASCII.SPACE) &&
                                lCursor.GetSequenceSet(out var lCreatedUIDSet) &&
                                lCursor.Position.AtEnd &&
                                cUIntList.TryConstruct(lSourceUIDSet, -1, false, out var lSourceUIDs) &&
                                cUIntList.TryConstruct(lCreatedUIDSet, -1, false, out var lCreatedUIDs) &&
                                lSourceUIDs.Count == lCreatedUIDs.Count)
                            {
                                Feedback = new cCopyFeedback(mSourceUIDValidity, lSourceUIDs, lDestinationUIDValidity, lCreatedUIDs);
                                return;
                            }
                        }

                        lContext.TraceWarning("likely malformed copyuid response");
                    }
                }
예제 #6
0
        internal static bool TryConstruct(string pName, IList <byte> pValue, out cHeaderFieldMsgIds rMsgIds)
        {
            if (pValue == null)
            {
                rMsgIds = null; return(false);
            }

            List <string> lMsgIds = new List <string>();

            cBytesCursor lCursor = new cBytesCursor(pValue);

            while (true)
            {
                if (!lCursor.GetRFC822MsgId(out var lMsgId))
                {
                    break;
                }
                lMsgIds.Add(lMsgId);
            }

            if (lCursor.Position.AtEnd)
            {
                rMsgIds = new cHeaderFieldMsgIds(pName, new cBytes(pValue), new cStrings(lMsgIds));
                return(true);
            }

            rMsgIds = null;
            return(false);
        }
예제 #7
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);
                }
예제 #8
0
                private bool ZProcessDataStatusAttributes(cBytesCursor pCursor, out cStatus rStatus, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cMailboxCache), nameof(ZProcessDataStatusAttributes));

                    uint? lMessages      = null;
                    uint? lRecent        = null;
                    uint? lUIDNext       = null;
                    uint? lUIDValidity   = null;
                    uint? lUnseen        = null;
                    ulong?lHighestModSeq = null;

                    while (true)
                    {
                        eProcessStatusAttributeResult lResult;

                        lResult = ZProcessDataStatusAttribute(pCursor, kMessagesSpace, ref lMessages, lContext);

                        if (lResult == eProcessStatusAttributeResult.notprocessed)
                        {
                            lResult = ZProcessDataStatusAttribute(pCursor, kRecentSpace, ref lRecent, lContext);

                            if (lResult == eProcessStatusAttributeResult.notprocessed)
                            {
                                lResult = ZProcessDataStatusAttribute(pCursor, kUIDNextSpace, ref lUIDNext, lContext);

                                if (lResult == eProcessStatusAttributeResult.notprocessed)
                                {
                                    lResult = ZProcessDataStatusAttribute(pCursor, kUIDValiditySpace, ref lUIDValidity, lContext);

                                    if (lResult == eProcessStatusAttributeResult.notprocessed)
                                    {
                                        lResult = ZProcessDataStatusAttribute(pCursor, kUnseenSpace, ref lUnseen, lContext);

                                        if (lResult == eProcessStatusAttributeResult.notprocessed)
                                        {
                                            lResult = ZProcessDataStatusAttribute(pCursor, kHighestModSeqSpace, ref lHighestModSeq, lContext);
                                        }
                                    }
                                }
                            }
                        }

                        if (lResult != eProcessStatusAttributeResult.processed)
                        {
                            rStatus = null;
                            return(false);
                        }

                        if (!pCursor.SkipByte(cASCII.SPACE))
                        {
                            if (!mCapabilities.CondStore)
                            {
                                lHighestModSeq = 0;
                            }
                            rStatus = new cStatus(mSequence++, lMessages, lRecent, lUIDNext, lUIDValidity, lUnseen, lHighestModSeq);
                            return(true);
                        }
                    }
                }
예제 #9
0
                private static bool ZGetId(cBytesCursor pCursor, out cId rServerId, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cIdDataProcessor), nameof(ZGetId));

                    if (pCursor.SkipBytes(cBytesCursor.Nil))
                    {
                        rServerId = null; return(true);
                    }

                    if (!pCursor.SkipByte(cASCII.LPAREN))
                    {
                        rServerId = null; return(false);
                    }

                    Dictionary <string, string> lDictionary = new Dictionary <string, string>();

                    try
                    {
                        bool lFirst = true;

                        while (true)
                        {
                            if (pCursor.SkipByte(cASCII.RPAREN))
                            {
                                break;
                            }

                            if (lFirst)
                            {
                                lFirst = false;
                            }
                            else if (!pCursor.SkipByte(cASCII.SPACE))
                            {
                                rServerId = null; return(false);
                            }

                            if (!pCursor.GetString(out string lField) || !pCursor.SkipByte(cASCII.SPACE))
                            {
                                rServerId = null; return(false);
                            }
                            if (!pCursor.GetNString(out string lValue))
                            {
                                rServerId = null; return(false);
                            }

                            lDictionary[lField] = lValue;
                        }

                        rServerId = new cId(lDictionary);
                        return(true);
                    }
                    catch (Exception e)
                    {
                        lContext.TraceException("error when constructing the id dictionary", e);
                        rServerId = null;
                        return(false);
                    }
                }
예제 #10
0
파일: idle.cs 프로젝트: bacome/imapclient
                private async Task <eIdleProcessResponsesTerminatedBy> ZIdleProcessResponsesAsync(bool pMonitorBackgroundReleaser, Task pCountdownTask, cCommandTag pTag, bool pExpectContinueRequest, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandPipeline), nameof(ZIdleProcessResponsesAsync), pMonitorBackgroundReleaser, pTag, pExpectContinueRequest);

                    Task lBackgroundReleaserTask;

                    if (pMonitorBackgroundReleaser)
                    {
                        lBackgroundReleaserTask = mBackgroundReleaser.GetAwaitReleaseTask(lContext);
                    }
                    else
                    {
                        lBackgroundReleaserTask = null;
                    }

                    while (true)
                    {
                        Task lBuildResponseTask = mConnection.GetBuildResponseTask(lContext);

                        Task lTask = await mBackgroundAwaiter.AwaitAny(lBuildResponseTask, lBackgroundReleaserTask, pCountdownTask).ConfigureAwait(false);

                        if (ReferenceEquals(lTask, lBackgroundReleaserTask))
                        {
                            return(eIdleProcessResponsesTerminatedBy.backgroundreleaser);
                        }
                        if (ReferenceEquals(lTask, pCountdownTask))
                        {
                            return(eIdleProcessResponsesTerminatedBy.countdowntask);
                        }

                        var lResponse = mConnection.GetResponse(lContext);
                        mSynchroniser.InvokeNetworkReceive(lResponse, lContext);
                        var lCursor = new cBytesCursor(lResponse);

                        if (lCursor.SkipBytes(kPlusSpace))
                        {
                            if (!pExpectContinueRequest)
                            {
                                throw new cUnexpectedServerActionException(fCapabilities.idle, "unexpected continuation request", lContext);
                            }
                            mResponseTextProcessor.Process(eResponseTextContext.continuerequest, lCursor, null, lContext);
                            return(eIdleProcessResponsesTerminatedBy.continuerequest);
                        }

                        if (ZProcessDataResponse(lCursor, lContext))
                        {
                            continue;
                        }

                        if (pTag != null && ZProcessCommandCompletionResponse(lCursor, pTag, false, null, lContext) != null)
                        {
                            return(eIdleProcessResponsesTerminatedBy.commandcompletion);
                        }

                        lContext.TraceError("unrecognised response: {0}", lResponse);
                    }
                }
예제 #11
0
파일: uri.cs 프로젝트: bacome/imapclient
        private cURLParts ZGetURLParts(string pURL)
        {
            var lCursor = new cBytesCursor(pURL);

            if (!cURLParts.Process(lCursor, out var lParts, cTrace.cContext.None) || !lCursor.Position.AtEnd)
            {
                return(null);
            }
            return(lParts);
        }
예제 #12
0
                private async Task ZBackgroundTaskProcessResponseAsync(cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandPipeline), nameof(ZBackgroundTaskProcessResponseAsync));

                    var lResponse = mConnection.GetResponse(lContext);

                    mSynchroniser.InvokeNetworkReceive(lResponse, lContext);
                    var lCursor = new cBytesCursor(lResponse);

                    if (lCursor.SkipBytes(kPlusSpace))
                    {
                        var lCurrentCommand = mCurrentCommand;

                        if (lCurrentCommand == null || !lCurrentCommand.WaitingForContinuationRequest)
                        {
                            throw new cUnexpectedServerActionException(0, "unexpected continuation request", lContext);
                        }

                        if (lCurrentCommand.IsAuthentication)
                        {
                            await ZProcessChallengeAsync(lCursor, lContext).ConfigureAwait(false);
                        }
                        else
                        {
                            mResponseTextProcessor.Process(eResponseTextContext.continuerequest, lCursor, lCurrentCommand.Hook, lContext);
                            lCurrentCommand.WaitingForContinuationRequest = false;
                        }

                        return;
                    }

                    lock (mPipelineLock)
                    {
                        if (ZProcessDataResponse(lCursor, lContext))
                        {
                            return;
                        }

                        if (ZBackgroundTaskProcessActiveCommandCompletion(lCursor, lContext))
                        {
                            return;
                        }

                        if (mCurrentCommand != null && ZBackgroundTaskProcessCommandCompletion(lCursor, mCurrentCommand, lContext))
                        {
                            if (mCurrentCommand.IsAuthentication)
                            {
                                mCurrentCommand = null;
                            }
                            return;
                        }
                    }

                    lContext.TraceError("unrecognised response: {0}", lResponse);
                }
예제 #13
0
                private bool ZProcessDataResponse(cBytesCursor pCursor, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandPipeline), nameof(ZProcessDataResponse));

                    if (!pCursor.SkipBytes(kProcessResponseAsteriskSpace))
                    {
                        return(false);
                    }

                    lContext.TraceVerbose("got data");

                    if (pCursor.SkipBytes(kProcessResponseOKSpace))
                    {
                        lContext.TraceVerbose("got information");
                        mResponseTextProcessor.Process(eResponseTextContext.information, pCursor, mActiveCommands, lContext);
                        return(true);
                    }

                    if (pCursor.SkipBytes(kProcessResponseNoSpace))
                    {
                        lContext.TraceVerbose("got a warning");
                        mResponseTextProcessor.Process(eResponseTextContext.warning, pCursor, mActiveCommands, lContext);
                        return(true);
                    }

                    if (pCursor.SkipBytes(kProcessResponseBadSpace))
                    {
                        lContext.TraceVerbose("got a protocol error");
                        mResponseTextProcessor.Process(eResponseTextContext.protocolerror, pCursor, mActiveCommands, lContext);
                        return(true);
                    }

                    if (pCursor.SkipBytes(kProcessResponseCapabilitySpace))
                    {
                        if (mState == eState.connected)
                        {
                            if (pCursor.ProcessCapability(out var lCapabilities, out var lAuthenticationMechanisms, lContext) && pCursor.Position.AtEnd)
                            {
                                lContext.TraceVerbose("got capabilities: {0} {1}", lCapabilities, lAuthenticationMechanisms);
                                mCapabilities             = lCapabilities;
                                mAuthenticationMechanisms = lAuthenticationMechanisms;
                            }
                            else
                            {
                                lContext.TraceWarning("likely malformed capability");
                            }
                        }
                        else
                        {
                            lContext.TraceWarning("capability response received at the wrong time - not processed");
                        }

                        return(true);
                    }
예제 #14
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);
            }
        }
예제 #15
0
                public eProcessDataResult ProcessData(cBytesCursor pCursor, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cSelectedMailboxCache), nameof(ProcessData));

                    if (pCursor.GetNZNumber(out _, out var lNumber) && pCursor.SkipBytes(kSpaceExpunge) && pCursor.Position.AtEnd)
                    {
                        lContext.TraceVerbose("got expunge: {0}", lNumber);
                        ZExpunge((int)lNumber, lContext);
                        return(eProcessDataResult.processed);
                    }

                    return(eProcessDataResult.notprocessed);
                }
예제 #16
0
                private async Task ZProcessChallengeAsync(cBytesCursor pCursor, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandPipeline), nameof(ZProcessChallengeAsync));

                    IList <byte> lResponse;

                    if (cBase64.TryDecode(pCursor.GetRestAsBytes(), out var lChallenge, out var lError))
                    {
                        try { lResponse = mCurrentCommand.GetAuthenticationResponse(lChallenge); }
                        catch (Exception e)
                        {
                            lContext.TraceException("SASL authentication object threw", e);
                            lResponse = null;
                        }
                    }
예제 #17
0
파일: url.cs 프로젝트: bacome/imapclient
        /// <summary>
        /// Initialises a new instance from the specified string. Will throw if the string cannot be parsed.
        /// </summary>
        /// <param name="pURL"></param>
        public cURL(string pURL)
        {
            if (string.IsNullOrEmpty(pURL))
            {
                throw new ArgumentOutOfRangeException(nameof(pURL));
            }
            var lCursor = new cBytesCursor(pURL);

            if (!cURLParts.Process(lCursor, out mParts, cTrace.cContext.None) || !lCursor.Position.AtEnd)
            {
                throw new ArgumentOutOfRangeException(nameof(pURL));
            }

            OriginalString = pURL;
        }
예제 #18
0
                public override eProcessDataResult ProcessData(cBytesCursor pCursor, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cEnableCommandHook), nameof(ProcessData));

                    if (!pCursor.SkipBytes(kEnabled))
                    {
                        return(eProcessDataResult.notprocessed);
                    }

                    fEnableableExtensions lEnabledExtensions = fEnableableExtensions.none;

                    while (true)
                    {
                        if (!pCursor.SkipByte(cASCII.SPACE))
                        {
                            break;
                        }

                        if (!pCursor.GetToken(cCharset.Atom, null, null, out cByteList lAtom))
                        {
                            lContext.TraceWarning("likely malformed enabled: not an atom list?");
                            return(eProcessDataResult.notprocessed);
                        }

                        lContext.TraceVerbose("got an enabled for {0}", lAtom);

                        if (cASCII.Compare(lAtom, kEnableExtensionUTF8, false))
                        {
                            lEnabledExtensions = lEnabledExtensions | fEnableableExtensions.utf8;
                        }
                        // more here as required
                        else
                        {
                            lContext.TraceError("unknown extension enabled: {0}", lAtom);
                        }
                    }

                    if (!pCursor.Position.AtEnd)
                    {
                        lContext.TraceWarning("likely malformed enabled: not at end?");
                        return(eProcessDataResult.notprocessed);
                    }

                    mEnabledExtensions |= lEnabledExtensions;
                    return(eProcessDataResult.processed);
                }
예제 #19
0
                private bool ZBackgroundTaskProcessActiveCommandCompletion(cBytesCursor pCursor, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandPipeline), nameof(ZBackgroundTaskProcessActiveCommandCompletion));

                    for (int i = 0; i < mActiveCommands.Count; i++)
                    {
                        var lCommand = mActiveCommands[i];

                        if (ZBackgroundTaskProcessCommandCompletion(pCursor, lCommand, lContext))
                        {
                            mActiveCommands.RemoveAt(i);
                            return(true);
                        }
                    }

                    return(false);
                }
예제 #20
0
                private bool ZProcessData(cBytesCursor pCursor, out List <cNamespaceName> rNames, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cNamespaceDataProcessor), nameof(ZProcessData));

                    if (pCursor.SkipBytes(cBytesCursor.Nil))
                    {
                        rNames = null;
                        return(true);
                    }

                    if (!pCursor.SkipByte(cASCII.LPAREN))
                    {
                        rNames = null; return(false);
                    }

                    rNames = new List <cNamespaceName>();

                    while (true)
                    {
                        if (!pCursor.SkipByte(cASCII.LPAREN) ||
                            !pCursor.GetString(out IList <byte> lEncodedPrefix) ||
                            !pCursor.SkipByte(cASCII.SPACE) ||
                            !pCursor.GetMailboxDelimiter(out var lDelimiter) ||
                            !ZProcessNamespaceExtension(pCursor) ||
                            !pCursor.SkipByte(cASCII.RPAREN)
                            )
                        {
                            rNames = null;
                            return(false);
                        }

                        if (!cNamespaceName.TryConstruct(lEncodedPrefix, lDelimiter, mUTF8Enabled, out var lNamespaceName))
                        {
                            rNames = null;
                            return(false);
                        }

                        rNames.Add(lNamespaceName);

                        if (pCursor.SkipByte(cASCII.RPAREN))
                        {
                            return(true);
                        }
                    }
                }
예제 #21
0
        private bool ZValidPart(string pPart)
        {
            var lCursor = new cBytesCursor(pPart);

            while (true)
            {
                if (!lCursor.GetNZNumber(out _, out _))
                {
                    return(false);
                }
                if (!lCursor.SkipByte(cASCII.DOT))
                {
                    break;
                }
            }

            return(lCursor.Position.AtEnd);
        }
예제 #22
0
        internal static bool TryConstruct(string pName, IList <byte> pValue, out cHeaderFieldMsgId rMsgId)
        {
            if (pValue == null)
            {
                rMsgId = null; return(false);
            }

            cBytesCursor lCursor = new cBytesCursor(pValue);

            if (!lCursor.GetRFC822MsgId(out var lMsgId) || !lCursor.Position.AtEnd)
            {
                rMsgId = null;
                return(false);
            }

            rMsgId = new cHeaderFieldMsgId(pName, new cBytes(pValue), lMsgId);
            return(true);
        }
예제 #23
0
파일: uri.cs 프로젝트: bacome/imapclient
        /// <summary>
        /// Tries to parse a string as a URI.
        /// </summary>
        /// <param name="pURI"></param>
        /// <param name="rURI"></param>
        /// <returns></returns>
        public static bool TryParse(string pURI, out cURI rURI)
        {
            if (string.IsNullOrWhiteSpace(pURI))
            {
                rURI = null; return(false);
            }

            var lCursor = new cBytesCursor(pURI);

            if (!cURIParts.Process(lCursor, out var lParts, cTrace.cContext.None) || !lCursor.Position.AtEnd)
            {
                rURI = null; return(false);
            }
            ;

            rURI = new cURI(pURI, lParts);
            return(true);
        }
예제 #24
0
                public bool Process(cBytesCursor pCursor, out cResponseData rResponseData, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cResponseDataParserSelect), nameof(Process));

                    if (pCursor.SkipBytes(kFlagsSpace))
                    {
                        if (pCursor.GetFlags(out var lRawFlags) && pCursor.Position.AtEnd && cFetchableFlags.TryConstruct(lRawFlags, out var lFlags))
                        {
                            rResponseData = new cResponseDataFlags(lFlags);
                        }
                        else
                        {
                            lContext.TraceWarning("likely malformed flags response");
                            rResponseData = null;
                        }

                        return(true);
                    }
예제 #25
0
                public override eProcessDataResult ProcessData(cBytesCursor pCursor, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandHookBaseSearch), nameof(ProcessData));

                    if (!pCursor.SkipBytes(kSearch))
                    {
                        return(eProcessDataResult.notprocessed);
                    }

                    cUIntList lMSNs = new cUIntList();

                    while (true)
                    {
                        if (!pCursor.SkipByte(cASCII.SPACE))
                        {
                            break;
                        }

                        if (!pCursor.GetNZNumber(out _, out var lMSN))
                        {
                            lContext.TraceWarning("likely malformed search: not an nz-number list?");
                            return(eProcessDataResult.notprocessed);
                        }

                        lMSNs.Add(lMSN);
                    }

                    if (!pCursor.Position.AtEnd)
                    {
                        lContext.TraceWarning("likely malformed search: not at end?");
                        return(eProcessDataResult.notprocessed);
                    }

                    if (mMSNs == null)
                    {
                        mMSNs = lMSNs;
                    }
                    else
                    {
                        mMSNs.AddRange(lMSNs);
                    }

                    return(eProcessDataResult.processed);
                }
예제 #26
0
                public override eProcessDataResult ProcessData(cBytesCursor pCursor, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cIdDataProcessor), nameof(ProcessData));

                    if (pCursor.SkipBytes(kIdSpace))
                    {
                        if (ZGetId(pCursor, out var lServerId, lContext) && pCursor.Position.AtEnd)
                        {
                            lContext.TraceVerbose("got id: {0}", lServerId);
                            mServerId = lServerId;
                            mSynchroniser.InvokePropertyChanged(nameof(cIMAPClient.ServerId), lContext);
                            return(eProcessDataResult.processed);
                        }

                        lContext.TraceWarning("likely malformed id response");
                    }

                    return(eProcessDataResult.notprocessed);
                }
예제 #27
0
        internal static bool TryConstruct(IList <byte> pValue, out cHeaderFieldImportance rImportance)
        {
            if (pValue == null)
            {
                rImportance = null; return(false);
            }

            eImportance lImportance;

            cBytesCursor lCursor = new cBytesCursor(pValue);

            lCursor.SkipRFC822CFWS();

            if (lCursor.SkipBytes(kLow))
            {
                lImportance = eImportance.low;
            }
            else if (lCursor.SkipBytes(kNormal))
            {
                lImportance = eImportance.normal;
            }
            else if (lCursor.SkipBytes(kHigh))
            {
                lImportance = eImportance.high;
            }
            else
            {
                rImportance = null; return(false);
            }

            lCursor.SkipRFC822CFWS();

            if (lCursor.Position.AtEnd)
            {
                rImportance = new cHeaderFieldImportance(new cBytes(pValue), lImportance);
                return(true);
            }

            rImportance = null;
            return(false);
        }
예제 #28
0
                private static bool ZProcessExtendedItems(cBytesCursor pCursor, out cListExtendedItems rItems)
                {
                    rItems = new cListExtendedItems();

                    if (!pCursor.SkipByte(cASCII.SPACE))
                    {
                        return(true);
                    }
                    if (!pCursor.SkipByte(cASCII.LPAREN))
                    {
                        return(false);
                    }

                    while (true)
                    {
                        if (!pCursor.GetAString(out string lTag))
                        {
                            break;
                        }
                        if (!pCursor.SkipByte(cASCII.SPACE))
                        {
                            return(false);
                        }
                        if (!pCursor.ProcessExtendedValue(out var lValue))
                        {
                            return(false);
                        }
                        rItems.Add(new cListExtendedItem(lTag, lValue));
                        if (!pCursor.SkipByte(cASCII.SPACE))
                        {
                            break;
                        }
                    }

                    if (!pCursor.SkipByte(cASCII.RPAREN))
                    {
                        return(false);
                    }

                    return(true);
                }
예제 #29
0
                public eProcessDataResult ProcessData(cBytesCursor pCursor, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cMailboxCache), nameof(ProcessData));

                    if (mSelectedMailbox != null)
                    {
                        var lBookmark = pCursor.Position;
                        var lResult   = mSelectedMailbox.ProcessData(pCursor, lContext);
                        if (lResult != eProcessDataResult.notprocessed)
                        {
                            return(lResult);
                        }
                        pCursor.Position = lBookmark;
                    }

                    if (pCursor.SkipBytes(kStatusSpace))
                    {
                        if (!pCursor.GetAString(out string lEncodedMailboxPath) ||
                            !pCursor.SkipBytes(cBytesCursor.SpaceLParen) ||
                            !ZProcessDataStatusAttributes(pCursor, out var lStatus, lContext) ||
                            !pCursor.SkipByte(cASCII.RPAREN) ||
                            !pCursor.Position.AtEnd)
                        {
                            lContext.TraceWarning("likely malformed status response");
                            return(eProcessDataResult.notprocessed);
                        }

                        var lItem = ZItem(lEncodedMailboxPath);
                        lItem.UpdateStatus(lStatus, lContext);
                        if (!ReferenceEquals(mSelectedMailbox?.MailboxHandle, lItem))
                        {
                            lItem.UpdateMailboxStatus(lContext);
                        }

                        return(eProcessDataResult.processed);
                    }

                    return(eProcessDataResult.notprocessed);
                }
예제 #30
0
                private bool ZBackgroundTaskProcessCommandCompletion(cBytesCursor pCursor, cCommand pCommand, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandPipeline), nameof(ZBackgroundTaskProcessCommandCompletion), pCommand);

                    var lResult = ZProcessCommandCompletionResponse(pCursor, pCommand.Tag, pCommand.IsAuthentication, pCommand.Hook, lContext);

                    if (lResult == null)
                    {
                        return(false);
                    }

                    if (pCommand.UIDValidity != null && pCommand.UIDValidity != mMailboxCache?.SelectedMailboxDetails?.MessageCache.UIDValidity)
                    {
                        pCommand.SetException(new cUIDValidityException(lContext), lContext);
                    }
                    else
                    {
                        pCommand.SetResult(lResult, lContext);
                    }

                    return(true);
                }