Esempio n. 1
0
        public void TestIsCapable()
        {
            var list = new ImapCapabilityList(new[] {
            ImapCapability.LiteralNonSync,
            ImapCapability.Binary,
            new ImapCapability("AUTH=CRAM-MD5"),
            new ImapCapability("AUTH=PLAIN"),
              });

              Assert.IsTrue(list.IsCapable(new Extension(ImapCapability.LiteralNonSync)));
              Assert.IsTrue(list.IsCapable(new Extension(ImapCapability.Binary)));
              Assert.IsFalse(list.IsCapable(new Extension(ImapCapability.Imap4Rev1)));
              Assert.IsFalse(list.IsCapable(new Extension(ImapCapability.Notify)));
        }
        /// <summary>sends CAPABILITY command</summary>
        /// <remarks>valid in any state</remarks>
        public ImapCommandResult Capability(out ImapCapabilityList capabilities)
        {
            RejectNonConnectedState();

              capabilities = null;

              using (var t = new CapabilityTransaction(connection)) {
            if (ProcessTransaction(t).Succeeded) {
              SetServerCapabilities(t.Result.Value);
              capabilities = t.Result.Value;
            }

            return t.Result;
              }
        }
Esempio n. 3
0
        public void TestFind()
        {
            var list = new ImapCapabilityList(new[] {
            ImapCapability.LiteralNonSync,
            ImapCapability.Binary,
            new ImapCapability("AUTH=CRAM-MD5"),
            new ImapCapability("AUTH=PLAIN"),
              });

              Assert.AreSame(ImapCapability.LiteralNonSync, list.Find("LITERAL+"));
              Assert.AreSame(ImapCapability.LiteralNonSync, list.Find("literal+"));

              var authPlain = list.Find("AUTH=PLAIN");

              Assert.IsNotNull(authPlain);
              Assert.AreEqual(authPlain, list.Find("auth=plain"));
        }
Esempio n. 4
0
        public void TestHas()
        {
            var list = new ImapCapabilityList(new[] {
            ImapCapability.LiteralNonSync,
            ImapCapability.Binary,
            new ImapCapability("AUTH=CRAM-MD5"),
            new ImapCapability("AUTH=PLAIN"),
              });

              Assert.IsTrue(list.Has(ImapCapability.LiteralNonSync));
              Assert.IsTrue(list.Has("LITERAL+"));
              Assert.IsTrue(list.Has("literal+"));

              Assert.IsTrue(list.Has("AUTH=CRAM-MD5"));
              Assert.IsTrue(list.Has(new ImapCapability("auth=cram-md5")));

              Assert.IsFalse(list.Has(ImapCapability.Imap4Rev1));
              Assert.IsFalse(list.Has("imap4rev1"));
              Assert.IsFalse(list.Has(new ImapCapability("auth=login")));
              Assert.IsFalse(list.Has("auth=login"));
        }
Esempio n. 5
0
 internal static ImapStatusDataItem GetStatusDataItem(ImapCapabilityList serverCapabilities)
 {
     if (serverCapabilities.Has(ImapCapability.CondStore))
     return ImapStatusDataItem.StandardAll + ImapStatusDataItem.HighestModSeq;
       else
     return ImapStatusDataItem.StandardAll;
 }
Esempio n. 6
0
        /*
         * methods for internal state management
         */
        internal void SetServerCapabilities(ImapCapabilityList newCapabilities)
        {
            serverCapabilities = new ImapCapabilityList(true, newCapabilities);

            #if false
              defaultLiteralSynchronizationMode = serverCapabilities.Has(ImapCapability.LiteralNonSync)
            ? ImapLiteralOptions.NonSynchronizing
            : ImapLiteralOptions.Synchronizing;
            #endif
        }
Esempio n. 7
0
 internal void SetSessionInfo(ImapSession session)
 {
     Namespaces = session.Namespaces.Clone();
       ServerCapabilities = new ImapCapabilityList(true, session.ServerCapabilities);
       ServerID = session.ServerID;
 }
Esempio n. 8
0
        static ImapCapability()
        {
            var capabilities = new List<ImapCapability>(GetDefinedConstants<ImapCapability>());

              foreach (var saslMechansim in SaslMechanisms.AllMechanisms) {
            capabilities.Add(new ImapCapability("AUTH=" + saslMechansim));
              }

              AllCapabilities = new ImapCapabilityList(true, capabilities);
        }
Esempio n. 9
0
        private ImapSearchCriteria GetSearchCriteria(ImapCapabilityList serverCapabilities, bool splitCharset, out string charset)
        {
            if (ImapStyleUriParser.GetUriForm(requestUri) != ImapUriForm.SearchMessages)
            throw new InvalidOperationException("request URI does not include query");

              /*
               * http://tools.ietf.org/html/rfc5092
               * RFC 5092 - IMAP URL Scheme
               *
               *    Note that quoted strings and non-synchronizing literals [LITERAL+]
               *    are allowed in the <enc-search> content; however, synchronizing
               *    literals are not allowed, as their presence would effectively mean
               *    that the agent interpreting IMAP URLs needs to parse an <enc-search>
               *    content, find all synchronizing literals, and perform proper command
               *    continuation request handling (see Sections 4.3 and 7 of [IMAP4]).
               */
              charset = null;

              bool containsLiteral;

              var ret = ImapSearchCriteria.FromUri(requestUri, splitCharset, out containsLiteral, out charset);

              if (!serverCapabilities.Has(ImapCapability.LiteralNonSync) && containsLiteral)
            throw new ImapIncapableException("query contains literal but LITERAL+ is incapable.");

              return ret;
        }
Esempio n. 10
0
 protected ImapSearchCriteria GetSearchCriteria(ImapCapabilityList serverCapabilities, out string charset)
 {
     return GetSearchCriteria(serverCapabilities, true, out charset);
 }
Esempio n. 11
0
        protected ImapSearchCriteria GetSearchCriteria(ImapCapabilityList serverCapabilities)
        {
            string discard;

              return GetSearchCriteria(serverCapabilities, false, out discard);
        }
        /// <summary>sends ENABLE command</summary>
        /// <remarks>valid in authenticated state</remarks>
        public ImapCommandResult Enable(out ImapCapabilityList enabledCapabilities, params string[] capabilityNames)
        {
            RejectNonAuthenticatedState();

              if (capabilityNames == null || capabilityNames.Length == 0)
            throw new ArgumentException("at least one capability name is required", "capabilityNames");

              enabledCapabilities = null;

              using (var t = new EnableTransaction(connection)) {
            // capability names
            t.RequestArguments["capability names"] = new ImapStringList(capabilityNames);

            if (ProcessTransaction(t).Succeeded)
              enabledCapabilities = t.Result.Value;

            return t.Result;
              }
        }