/// <summary> /// Returns parsed IMAP SEARCH <b>SENTBEFORE (string)</b> key. /// </summary> /// <param name="r">String reader.</param> /// <returns>Returns parsed IMAP SEARCH <b>SENTBEFORE (string)</b> key.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>r</b> is null reference.</exception> /// <exception cref="ParseException">Is raised when parsing fails.</exception> internal static IMAP_Search_Key_SentBefore Parse(StringReader r) { if (r == null) { throw new ArgumentNullException("r"); } string word = r.ReadWord(); if (!string.Equals(word, "SENTBEFORE", StringComparison.InvariantCultureIgnoreCase)) { throw new ParseException("Parse error: Not a SEARCH 'SENTBEFORE' key."); } string value = r.ReadWord(); if (value == null) { throw new ParseException("Parse error: Invalid 'SENTBEFORE' value."); } DateTime date; try{ date = IMAP_Utils.ParseDate(value); } catch { throw new ParseException("Parse error: Invalid 'SENTBEFORE' value."); } return(new IMAP_Search_Key_SentBefore(date)); }
/// <summary> /// Parses STATUS response from status-response string. /// </summary> /// <param name="response">Satatus response string.</param> /// <returns>Returns parsed STATUS response.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>response</b> is null reference.</exception> public static IMAP_r_u_Status Parse(string response) { if (response == null) { throw new ArgumentNullException("response"); } /* RFC 3501 7.2.4 STATUS Response. * Contents: name * status parenthesized list * * The STATUS response occurs as a result of an STATUS command. It * returns the mailbox name that matches the STATUS specification and * the requested mailbox status information. * * Example: S: * STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292) */ StringReader r = new StringReader(response); // Eat "*" r.ReadWord(); // Eat "STATUS" r.ReadWord(); int messages = 0; int recent = 0; long uidNext = 0; long folderUid = 0; int unseen = 0; string folder = TextUtils.UnQuoteString(IMAP_Utils.Decode_IMAP_UTF7_String(r.ReadWord())); string[] items = r.ReadParenthesized().Split(' '); for (int i = 0; i < items.Length; i += 2) { if (items[i].Equals("MESSAGES", StringComparison.InvariantCultureIgnoreCase)) { messages = Convert.ToInt32(items[i + 1]); } else if (items[i].Equals("RECENT", StringComparison.InvariantCultureIgnoreCase)) { recent = Convert.ToInt32(items[i + 1]); } else if (items[i].Equals("UIDNEXT", StringComparison.InvariantCultureIgnoreCase)) { uidNext = Convert.ToInt64(items[i + 1]); } else if (items[i].Equals("UIDVALIDITY", StringComparison.InvariantCultureIgnoreCase)) { folderUid = Convert.ToInt64(items[i + 1]); } else if (items[i].Equals("UNSEEN", StringComparison.InvariantCultureIgnoreCase)) { unseen = Convert.ToInt32(items[i + 1]); } } return(new IMAP_r_u_Status(folder, messages, recent, uidNext, folderUid, unseen)); }
/// <summary> /// Parses LSUB response from lsub-response string. /// </summary> /// <param name="lSubResponse">LSub response string.</param> /// <returns>Returns parsed lsub response.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>lSubResponse</b> is null reference.</exception> public static IMAP_r_u_LSub Parse(string lSubResponse) { if (lSubResponse == null) { throw new ArgumentNullException("lSubResponse"); } /* RFC 3501 7.2.3. LSUB Response. * Contents: name attributes * hierarchy delimiter * name * * The LSUB response occurs as a result of an LSUB command. It * returns a single name that matches the LSUB specification. There * can be multiple LSUB responses for a single LSUB command. The * data is identical in format to the LIST response. * * Example: S: * LSUB () "." #news.comp.mail.misc */ StringReader r = new StringReader(lSubResponse); // Eat "*" r.ReadWord(); // Eat "LSUB" r.ReadWord(); string attributes = r.ReadParenthesized(); string delimiter = r.ReadWord(); string folder = TextUtils.UnQuoteString(IMAP_Utils.DecodeMailbox(r.ReadToEnd().Trim())); return(new IMAP_r_u_LSub(folder, delimiter[0], attributes == string.Empty ? new string[0] : attributes.Split(' '))); }
/// <summary> /// Returns this as string. /// </summary> /// <param name="encoding">Specifies how mailbox name is encoded.</param> /// <returns>Returns this as string.</returns> public override string ToString(IMAP_Mailbox_Encoding encoding) { // Example: S: * LSUB (\Noselect) "/" ~/Mail/foo StringBuilder retVal = new StringBuilder(); retVal.Append("* LSUB ("); if (m_pFolderAttributes != null) { for (int i = 0; i < m_pFolderAttributes.Length; i++) { if (i > 0) { retVal.Append(" "); } retVal.Append(m_pFolderAttributes[i]); } } retVal.Append(") "); retVal.Append("\"" + m_Delimiter + "\" "); retVal.Append(IMAP_Utils.EncodeMailbox(m_FolderName, encoding)); retVal.Append("\r\n"); return(retVal.ToString()); }
/// <summary> /// Parses MYRIGHTS response from MYRIGHTS-response string. /// </summary> /// <param name="myRightsResponse">MYRIGHTS response line.</param> /// <returns>Returns parsed MYRIGHTS response.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>myRightsResponse</b> is null reference.</exception> public static IMAP_r_u_MyRights Parse(string myRightsResponse) { if (myRightsResponse == null) { throw new ArgumentNullException("myRightsResponse"); } /* RFC 4314 3.8. MYRIGHTS Response. * Data: mailbox name * rights * * The MYRIGHTS response occurs as a result of a MYRIGHTS command. The * first string is the mailbox name for which these rights apply. The * second string is the set of rights that the client has. * * Section 2.1.1 details additional server requirements related to * handling of the virtual "d" and "c" rights. * * Example: C: A003 MYRIGHTS INBOX * S: * MYRIGHTS INBOX rwiptsldaex * S: A003 OK Myrights complete */ StringReader r = new StringReader(myRightsResponse); // Eat "*" r.ReadWord(); // Eat "MYRIGHTS" r.ReadWord(); string folder = IMAP_Utils.Decode_IMAP_UTF7_String(r.ReadWord(true)); string rights = r.ReadToEnd().Trim(); return(new IMAP_r_u_MyRights(folder, rights)); }
/// <summary> /// Returns parsed IMAP SEARCH <b>HEADER (field-name) (string)</b> key. /// </summary> /// <param name="r">String reader.</param> /// <returns>Returns parsed IMAP SEARCH <b>HEADER (field-name) (string)</b> key.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>r</b> is null reference.</exception> /// <exception cref="ParseException">Is raised when parsing fails.</exception> internal static IMAP_Search_Key_Header Parse(StringReader r) { if (r == null) { throw new ArgumentNullException("r"); } string word = r.ReadWord(); if (!string.Equals(word, "HEADER", StringComparison.InvariantCultureIgnoreCase)) { throw new ParseException("Parse error: Not a SEARCH 'HEADER' key."); } string fieldName = IMAP_Utils.ReadString(r); if (fieldName == null) { throw new ParseException("Parse error: Invalid 'HEADER' field-name value."); } string value = IMAP_Utils.ReadString(r); if (value == null) { throw new ParseException("Parse error: Invalid 'HEADER' string value."); } return(new IMAP_Search_Key_Header(fieldName, value)); }
/// <summary> /// Encodes mailbox name. /// </summary> /// <param name="mailbox">Mailbox name.</param> /// <param name="encoding">Mailbox name encoding mechanism.</param> /// <returns>Renturns encoded mailbox name.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>mailbox</b> is null reference.</exception> public static string EncodeMailbox(string mailbox, IMAP_Mailbox_Encoding encoding) { if (mailbox == null) { throw new ArgumentNullException("mailbox"); } /* RFC 5738 3. * string =/ utf8-quoted * utf8-quoted = "*" DQUOTE *UQUOTED-CHAR DQUOTE * UQUOTED-CHAR = QUOTED-CHAR / UTF8-2 / UTF8-3 / UTF8-4 */ if (encoding == IMAP_Mailbox_Encoding.ImapUtf7) { return("\"" + IMAP_Utils.Encode_IMAP_UTF7_String(mailbox) + "\""); } else if (encoding == IMAP_Mailbox_Encoding.ImapUtf8) { return("*\"" + mailbox + "\""); } else { return("\"" + mailbox + "\""); } }
/// <summary> /// Returns this as string. /// </summary> /// <param name="encoding">Specifies how mailbox name is encoded.</param> /// <returns>Returns this as string.</returns> public override string ToString(IMAP_Mailbox_Encoding encoding) { // Example: S: * STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292) StringBuilder retVal = new StringBuilder(); retVal.Append("* STATUS"); retVal.Append(" " + IMAP_Utils.EncodeMailbox(m_FolderName, encoding)); retVal.Append(" ("); bool firstItem = true; if (m_MessageCount >= 0) { retVal.Append("MESSAGES " + m_MessageCount); firstItem = false; } if (m_RecentCount >= 0) { if (!firstItem) { retVal.Append(' '); } retVal.Append("RECENT " + m_RecentCount); firstItem = false; } if (m_UidNext >= 0) { if (!firstItem) { retVal.Append(' '); } retVal.Append("UIDNEXT " + m_UidNext); firstItem = false; } if (m_FolderUid >= 0) { if (!firstItem) { retVal.Append(' '); } retVal.Append("UIDVALIDITY " + m_FolderUid); firstItem = false; } if (m_UnseenCount >= 0) { if (!firstItem) { retVal.Append(' '); } retVal.Append("UNSEEN " + m_UnseenCount); firstItem = false; } retVal.Append(")\r\n"); return(retVal.ToString()); }
/// <summary> /// Returns this as string. /// </summary> /// <param name="encoding">Specifies how mailbox name is encoded.</param> /// <returns>Returns this as string.</returns> public override string ToString(IMAP_Mailbox_Encoding encoding) { // Example: S: * MYRIGHTS INBOX rwiptsldaex StringBuilder retVal = new StringBuilder(); retVal.Append("* MYRIGHTS " + IMAP_Utils.EncodeMailbox(m_FolderName, encoding) + " \"" + m_pRights + "\"\r\n"); return(retVal.ToString()); }
/// <summary> /// Returns this as string. /// </summary> /// <param name="encoding">Specifies how mailbox name is encoded.</param> /// <returns>Returns this as string.</returns> public override string ToString(IMAP_Mailbox_Encoding encoding) { // Example: S: * LISTRIGHTS ~/Mail/saved smith la r swicdkxte StringBuilder retVal = new StringBuilder(); retVal.Append("* LISTRIGHTS " + IMAP_Utils.EncodeMailbox(m_FolderName, encoding) + " \"" + m_RequiredRights + "\" " + m_OptionalRights + "\r\n"); return(retVal.ToString()); }
/// <summary> /// Returns this as string. /// </summary> /// <param name="encoding">Specifies how mailbox name is encoded.</param> /// <returns>Returns this as string.</returns> public override string ToString(IMAP_Mailbox_Encoding encoding) { // Example: S: * QUOTAROOT INBOX "" StringBuilder retVal = new StringBuilder(); retVal.Append("* QUOTAROOT " + IMAP_Utils.EncodeMailbox(m_FolderName, encoding)); foreach (string root in m_QuotaRoots) { retVal.Append(" \"" + root + "\""); } retVal.Append("\r\n"); return(retVal.ToString()); }
/// <summary> /// Parses LISTRIGHTS response from LISTRIGHTS-response string. /// </summary> /// <param name="listRightsResponse">LISTRIGHTS response line.</param> /// <returns>Returns parsed LISTRIGHTS response.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>listRightsResponse</b> is null reference.</exception> public static IMAP_r_u_ListRights Parse(string listRightsResponse) { if (listRightsResponse == null) { throw new ArgumentNullException("listRightsResponse"); } /* RFC 4314 3.7. LISTRIGHTS Response. * Data: mailbox name * identifier * required rights * list of optional rights * * The LISTRIGHTS response occurs as a result of a LISTRIGHTS command. * The first two strings are the mailbox name and identifier for which * this rights list applies. Following the identifier is a string * containing the (possibly empty) set of rights the identifier will * always be granted in the mailbox. * * Following this are zero or more strings each containing a set of * rights the identifier can be granted in the mailbox. Rights * mentioned in the same string are tied together. The server MUST * either grant all tied rights to the identifier in the mailbox or * grant none. Section 2.1.1 details additional server requirements * related to handling of the virtual "d" and "c" rights. * * The same right MUST NOT be listed more than once in the LISTRIGHTS * command. * * Example: C: a001 LISTRIGHTS ~/Mail/saved smith * S: * LISTRIGHTS ~/Mail/saved smith la r swicdkxte * S: a001 OK Listrights completed */ StringReader r = new StringReader(listRightsResponse); // Eat "*" r.ReadWord(); // Eat "LISTRIGHTS" r.ReadWord(); string folder = IMAP_Utils.Decode_IMAP_UTF7_String(r.ReadWord(true)); string identifier = r.ReadWord(true); string reqRights = r.ReadWord(true); string optRights = r.ReadWord(true); return(new IMAP_r_u_ListRights(folder, identifier, reqRights, optRights)); }
/// <summary> /// Returns this as string. /// </summary> /// <param name="encoding">Specifies how mailbox name is encoded.</param> /// <returns>Returns this as string.</returns> public override string ToString(IMAP_Mailbox_Encoding encoding) { // Example: S: * ACL INBOX Fred rwipslda test rwipslda StringBuilder retVal = new StringBuilder(); retVal.Append("* ACL "); retVal.Append(IMAP_Utils.EncodeMailbox(m_FolderName, encoding)); foreach (IMAP_Acl_Entry e in m_pEntries) { retVal.Append(" \"" + e.Identifier + "\" \"" + e.Rights + "\""); } retVal.Append("\r\n"); return(retVal.ToString()); }
/// <summary> /// Parses QUOTAROOT response from quotaRoot-response string. /// </summary> /// <param name="response">QUOTAROOT response string.</param> /// <returns>Returns parsed QUOTAROOT response.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>response</b> is null reference.</exception> public static IMAP_r_u_QuotaRoot Parse(string response) { if (response == null) { throw new ArgumentNullException("response"); } /* RFC 2087 5.2. QUOTAROOT Response. * Data: mailbox name * zero or more quota root names * * This response occurs as a result of a GETQUOTAROOT command. The * first string is the mailbox and the remaining strings are the * names of the quota roots for the mailbox. * * Example: S: * QUOTAROOT INBOX "" * S: * QUOTAROOT comp.mail.mime */ StringReader r = new StringReader(response); // Eat "*" r.ReadWord(); // Eat "QUOTAROOT" r.ReadWord(); string folderName = TextUtils.UnQuoteString(IMAP_Utils.Decode_IMAP_UTF7_String(r.ReadWord())); List <string> quotaRoots = new List <string>(); while (r.Available > 0) { string quotaRoot = r.ReadWord(); if (quotaRoot != null) { quotaRoots.Add(quotaRoot); } else { break; } } return(new IMAP_r_u_QuotaRoot(folderName, quotaRoots.ToArray())); }
/// <summary> /// Parses ACL response from acl-response string. /// </summary> /// <param name="aclResponse">ACL response.</param> /// <returns>Returns parsed ACL response.</returns> /// <exception cref="ArgumentNullException">Is raised wehn <b>aclResponse</b> is null reference.</exception> public static IMAP_r_u_Acl Parse(string aclResponse) { if (aclResponse == null) { throw new ArgumentNullException("aclResponse"); } /* RFC 4314 3.6. ACL Response. * Data: mailbox name * zero or more identifier rights pairs * * The ACL response occurs as a result of a GETACL command. The first * string is the mailbox name for which this ACL applies. This is * followed by zero or more pairs of strings; each pair contains the * identifier for which the entry applies followed by the set of rights * that the identifier has. * * Example: C: A002 GETACL INBOX * S: * ACL INBOX Fred rwipsldexta * S: A002 OK Getacl complete */ StringReader r = new StringReader(aclResponse); // Eat "*" r.ReadWord(); // Eat "ACL" r.ReadWord(); string folderName = TextUtils.UnQuoteString(IMAP_Utils.Decode_IMAP_UTF7_String(r.ReadWord())); string[] items = r.ReadToEnd().Split(' '); List <IMAP_Acl_Entry> entries = new List <IMAP_Acl_Entry>(); for (int i = 0; i < items.Length; i += 2) { entries.Add(new IMAP_Acl_Entry(items[i], items[i + 1])); } return(new IMAP_r_u_Acl(folderName, entries.ToArray())); }
/// <summary> /// Returns parsed IMAP SEARCH <b>FROM (string)</b> key. /// </summary> /// <param name="r">String reader.</param> /// <returns>Returns parsed IMAP SEARCH <b>FROM (string)</b> key.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>r</b> is null reference.</exception> /// <exception cref="ParseException">Is raised when parsing fails.</exception> internal static IMAP_Search_Key_From Parse(StringReader r) { if (r == null) { throw new ArgumentNullException("r"); } string word = r.ReadWord(); if (!string.Equals(word, "FROM", StringComparison.InvariantCultureIgnoreCase)) { throw new ParseException("Parse error: Not a SEARCH 'FROM' key."); } string value = IMAP_Utils.ReadString(r); if (value == null) { throw new ParseException("Parse error: Invalid 'FROM' value."); } return(new IMAP_Search_Key_From(value)); }
/// <summary> /// Returns this as string. /// </summary> /// <param name="encoding">Specifies how mailbox name is encoded.</param> /// <returns>Returns this as string.</returns> public override string ToString(IMAP_Mailbox_Encoding encoding) { /* * Example: S: * LIST (\Noselect) "/" ~/Mail/foo * * C: A101 LIST "" "" * S: * LIST (\Noselect) "/" "" * S: A101 OK LIST Completed */ // Hierarchy delimiter request. if (string.IsNullOrEmpty(m_FolderName)) { return("* LIST (\\Noselect) \"/\" \"\"\r\n"); } else { StringBuilder retVal = new StringBuilder(); retVal.Append("* LIST ("); if (m_pFolderAttributes != null) { for (int i = 0; i < m_pFolderAttributes.Length; i++) { if (i > 0) { retVal.Append(" "); } retVal.Append(m_pFolderAttributes[i]); } } retVal.Append(") "); retVal.Append("\"" + m_Delimiter + "\" "); retVal.Append(IMAP_Utils.EncodeMailbox(m_FolderName, encoding)); retVal.Append("\r\n"); return(retVal.ToString()); } }
/// <summary> /// Parses LIST response from list-response string. /// </summary> /// <param name="listResponse">List response string.</param> /// <returns>Returns parsed list response.</returns> /// <exception cref="ArgumentNullException">Is raised when <b>listResponse</b> is null reference.</exception> public static IMAP_r_u_List Parse(string listResponse) { if (listResponse == null) { throw new ArgumentNullException("listResponse"); } /* RFC 3501 7.2.2. LIST Response. * Contents: name attributes * hierarchy delimiter * name * * The LIST response occurs as a result of a LIST command. It * returns a single name that matches the LIST specification. There * can be multiple LIST responses for a single LIST command. * * Four name attributes are defined: * * \Noinferiors * It is not possible for any child levels of hierarchy to exist * under this name; no child levels exist now and none can be * created in the future. * * \Noselect * It is not possible to use this name as a selectable mailbox. * * \Marked * The mailbox has been marked "interesting" by the server; the * mailbox probably contains messages that have been added since * the last time the mailbox was selected. * * \Unmarked * The mailbox does not contain any additional messages since the * last time the mailbox was selected. * * If it is not feasible for the server to determine whether or not * the mailbox is "interesting", or if the name is a \Noselect name, * the server SHOULD NOT send either \Marked or \Unmarked. * * The hierarchy delimiter is a character used to delimit levels of * hierarchy in a mailbox name. A client can use it to create child * mailboxes, and to search higher or lower levels of naming * hierarchy. All children of a top-level hierarchy node MUST use * the same separator character. A NIL hierarchy delimiter means * that no hierarchy exists; the name is a "flat" name. * * The name represents an unambiguous left-to-right hierarchy, and * MUST be valid for use as a reference in LIST and LSUB commands. * Unless \Noselect is indicated, the name MUST also be valid as an * argument for commands, such as SELECT, that accept mailbox names. * * Example: S: * LIST (\Noselect) "/" ~/Mail/foo */ StringReader r = new StringReader(listResponse); // Eat "*" r.ReadWord(); // Eat "LIST" r.ReadWord(); string attributes = r.ReadParenthesized(); string delimiter = r.ReadWord(); string folder = IMAP_Utils.DecodeMailbox(r.ReadToEnd().Trim()); return(new IMAP_r_u_List(folder, delimiter[0], attributes == string.Empty ? new string[0] : attributes.Split(' '))); }