Beispiel #1
0
        /// <summary>
        /// Enumerates the message-id references such as those that can be found in
        /// the In-Reply-To or References header.
        /// </summary>
        /// <remarks>
        /// Incrementally parses Message-Ids (such as those from a References header
        /// in a MIME message) from the supplied buffer starting at the given index
        /// and spanning across the specified number of bytes.
        /// </remarks>
        /// <returns>The references.</returns>
        /// <param name="buffer">The raw byte buffer to parse.</param>
        /// <param name="startIndex">The index into the buffer to start parsing.</param>
        /// <param name="length">The length of the buffer to parse.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <paramref name="buffer"/> is <c>null</c>.
        /// </exception>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
        /// a valid range in the byte array.
        /// </exception>
        public static IEnumerable <string> EnumerateReferences(byte[] buffer, int startIndex, int length)
        {
            ParseUtils.ValidateArguments(buffer, startIndex, length);

            int endIndex = startIndex + length;
            int index    = startIndex;

            do
            {
                if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
                {
                    break;
                }

                if (index >= endIndex)
                {
                    break;
                }

                if (buffer[index] == '<')
                {
                    if (ParseUtils.TryParseMsgId(buffer, ref index, endIndex, true, false, out string msgid))
                    {
                        yield return(msgid);
                    }
                }
                else if (!ParseUtils.SkipWord(buffer, ref index, endIndex, false))
                {
                    index++;
                }
            } while (index < endIndex);

            yield break;
        }
Beispiel #2
0
        /// <summary>
        /// Enumerates the message-id references such as those that can be found in
        /// the In-Reply-To or References header.
        /// </summary>
        /// <remarks>
        /// Incrementally parses Message-Ids (such as those from a References header
        /// in a MIME message) from the supplied buffer starting at the given index
        /// and spanning across the specified number of bytes.
        /// </remarks>
        /// <returns>The references.</returns>
        /// <param name="buffer">The raw byte buffer to parse.</param>
        /// <param name="startIndex">The index into the buffer to start parsing.</param>
        /// <param name="length">The length of the buffer to parse.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <paramref name="buffer"/> is <c>null</c>.
        /// </exception>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
        /// a valid range in the byte array.
        /// </exception>
        public static IEnumerable <string> EnumerateReferences(byte[] buffer, int startIndex, int length)
        {
            int             endIndex = startIndex + length;
            int             index    = startIndex;
            InternetAddress addr;

            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }

            if (startIndex < 0 || startIndex > buffer.Length)
            {
                throw new ArgumentOutOfRangeException("startIndex");
            }

            if (length < 0 || length > (buffer.Length - startIndex))
            {
                throw new ArgumentOutOfRangeException("length");
            }

            do
            {
                if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
                {
                    break;
                }

                if (index >= endIndex)
                {
                    break;
                }

                if (buffer[index] == '<')
                {
                    if (!InternetAddress.TryParseMailbox(ParserOptions.Default, buffer, startIndex, ref index, endIndex, "", 65001, false, out addr))
                    {
                        break;
                    }

                    yield return(((MailboxAddress)addr).Address);
                }
                else if (!ParseUtils.SkipWord(buffer, ref index, endIndex, false))
                {
                    index++;
                }
            } while (index < endIndex);

            yield break;
        }
Beispiel #3
0
        /// <summary>
        /// Enumerates the message-id references such as those that can be found in
        /// the In-Reply-To or References header.
        /// </summary>
        /// <remarks>
        /// Incrementally parses Message-Ids (such as those from a References header
        /// in a MIME message) from the supplied buffer starting at the given index
        /// and spanning across the specified number of bytes.
        /// </remarks>
        /// <returns>The references.</returns>
        /// <param name="buffer">The raw byte buffer to parse.</param>
        /// <param name="startIndex">The index into the buffer to start parsing.</param>
        /// <param name="length">The length of the buffer to parse.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <paramref name="buffer"/> is <c>null</c>.
        /// </exception>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
        /// a valid range in the byte array.
        /// </exception>
        public static IEnumerable <string> EnumerateReferences(byte[] buffer, int startIndex, int length)
        {
            byte[] sentinels = { (byte)'>' };
            int    endIndex  = startIndex + length;
            int    index     = startIndex;
            string msgid;

            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }

            if (startIndex < 0 || startIndex > buffer.Length)
            {
                throw new ArgumentOutOfRangeException("startIndex");
            }

            if (length < 0 || length > (buffer.Length - startIndex))
            {
                throw new ArgumentOutOfRangeException("length");
            }

            do
            {
                if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
                {
                    break;
                }

                if (index >= endIndex)
                {
                    break;
                }

                if (buffer[index] == '<')
                {
                    // skip over the '<'
                    index++;

                    if (index >= endIndex)
                    {
                        break;
                    }

                    string localpart;
                    if (!InternetAddress.TryParseLocalPart(buffer, ref index, endIndex, false, out localpart))
                    {
                        continue;
                    }

                    if (index >= endIndex)
                    {
                        break;
                    }

                    if (buffer[index] == (byte)'>')
                    {
                        // The msgid token did not contain an @domain. Technically this is illegal, but for the
                        // sake of maximum compatibility, I guess we have no choice but to accept it...
                        index++;

                        yield return(localpart);

                        continue;
                    }

                    if (buffer[index] != (byte)'@')
                    {
                        // who the hell knows what we have here... ignore it and continue on?
                        continue;
                    }

                    // skip over the '@'
                    index++;

                    if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
                    {
                        break;
                    }

                    if (index >= endIndex)
                    {
                        break;
                    }

                    if (buffer[index] == (byte)'>')
                    {
                        // The msgid token was in the form "<local-part@>". Technically this is illegal, but for
                        // the sake of maximum compatibility, I guess we have no choice but to accept it...
                        // https://github.com/jstedfast/MimeKit/issues/102
                        index++;

                        yield return(localpart + "@");

                        continue;
                    }

                    string domain;
                    if (!ParseUtils.TryParseDomain(buffer, ref index, endIndex, sentinels, false, out domain))
                    {
                        continue;
                    }

                    msgid = localpart + "@" + domain;

                    // Note: some Message-Id's are broken and in the form "<local-part@domain@domain>"
                    // https://github.com/jstedfast/MailKit/issues/138
                    while (index < endIndex && buffer[index] == (byte)'@')
                    {
                        int saved = index;

                        index++;

                        if (!ParseUtils.TryParseDomain(buffer, ref index, endIndex, sentinels, false, out domain))
                        {
                            index = saved;
                            break;
                        }

                        msgid += "@" + domain;
                    }

                    yield return(msgid);
                }
                else if (!ParseUtils.SkipWord(buffer, ref index, endIndex, false))
                {
                    index++;
                }
            } while (index < endIndex);

            yield break;
        }
        /// <summary>
        /// Enumerates the message-id references such as those that can be found in
        /// the In-Reply-To or References header.
        /// </summary>
        /// <remarks>
        /// Incrementally parses Message-Ids (such as those from a References header
        /// in a MIME message) from the supplied buffer starting at the given index
        /// and spanning across the specified number of bytes.
        /// </remarks>
        /// <returns>The references.</returns>
        /// <param name="buffer">The raw byte buffer to parse.</param>
        /// <param name="startIndex">The index into the buffer to start parsing.</param>
        /// <param name="length">The length of the buffer to parse.</param>
        /// <exception cref="System.ArgumentNullException">
        /// <paramref name="buffer"/> is <c>null</c>.
        /// </exception>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
        /// a valid range in the byte array.
        /// </exception>
        public static IEnumerable <string> EnumerateReferences(byte[] buffer, int startIndex, int length)
        {
            byte[]          sentinels = { (byte)'>' };
            int             endIndex  = startIndex + length;
            int             index     = startIndex;
            InternetAddress addr;
            string          msgid;

            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }

            if (startIndex < 0 || startIndex > buffer.Length)
            {
                throw new ArgumentOutOfRangeException("startIndex");
            }

            if (length < 0 || length > (buffer.Length - startIndex))
            {
                throw new ArgumentOutOfRangeException("length");
            }

            do
            {
                if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false))
                {
                    break;
                }

                if (index >= endIndex)
                {
                    break;
                }

                if (buffer[index] == '<')
                {
                    if (!InternetAddress.TryParseMailbox(ParserOptions.Default, buffer, startIndex, ref index, endIndex, "", 65001, false, out addr))
                    {
                        break;
                    }

                    msgid = ((MailboxAddress)addr).Address;

                    // Note: some message-id's are broken and in the form local-part@domain@domain
                    // https://github.com/jstedfast/MailKit/issues/138
                    while (index < endIndex && buffer[index] == (byte)'@')
                    {
                        int    saved = index;
                        string domain;

                        index++;

                        if (!ParseUtils.TryParseDomain(buffer, ref index, endIndex, sentinels, false, out domain))
                        {
                            index = saved;
                            break;
                        }

                        msgid += "@" + domain;
                    }

                    yield return(msgid);
                }
                else if (!ParseUtils.SkipWord(buffer, ref index, endIndex, false))
                {
                    index++;
                }
            } while (index < endIndex);

            yield break;
        }